envio 3.7.0-svm-alpha.1 → 3.8.0

package/src/SimulateItems.res.mjs

@@ -5,11 +5,14 @@ import * as Config from "./Config.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
+import * as BlockStore from "./sources/BlockStore.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 HandlerRegister from "./HandlerRegister.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";
+import * as TransactionStore from "./sources/TransactionStore.res.mjs";
+import * as SvmHyperSyncSource from "./sources/SvmHyperSyncSource.res.mjs";
 
 let evmSimulateBlockSchema = S$RescriptSchema.schema(s => ({
   number: s.m(S$RescriptSchema.Option.getOr(S$RescriptSchema.$$null(S$RescriptSchema.int), 0)),
@@ -168,6 +171,16 @@ function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig, config)
   }
 }
 
+function liveRegistrationsFor(config, chainId, eventConfig) {
+  return HandlerRegister.getSimulateOnEventRegistrations(config, chainId, eventConfig).filter(reg => {
+    if (Stdlib_Option.isSome(reg.handler) || Stdlib_Option.isSome(reg.contractRegister)) {
+      return !HandlerRegister.isDroppedByWhere(config, reg);
+    } else {
+      return false;
+    }
+  });
+}
+
 function parse(simulateItems, config, chainConfig, onEventRegistrations) {
   let chainId = chainConfig.id;
   let startBlock = chainConfig.startBlock;
@@ -178,21 +191,161 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
     contents: 0
   };
   let items = [];
+  let svmTxs = [];
+  let svmActivities = [];
+  let svmBlocks = [];
   let seenCoordinates = {};
   simulateItems.forEach((rawJson, itemIndex) => {
-    let match = rawJson.contract;
-    let match$1 = rawJson.event;
-    if (match === undefined) {
-      return Stdlib_JsError.throwWithMessage(`simulate: Invalid item. Each item must have "contract" and "event" fields.`);
-    }
-    if (match$1 === undefined) {
-      return Stdlib_JsError.throwWithMessage(`simulate: Invalid item. Each item must have "contract" and "event" fields.`);
+    let match = config.ecosystem.name;
+    let match$1 = rawJson.program;
+    let match$2 = rawJson.instruction;
+    switch (match) {
+      case "evm" :
+      case "fuel" :
+        break;
+      case "svm" :
+        if (match$1 === undefined) {
+          return Stdlib_JsError.throwWithMessage(`simulate: Invalid item. Each item must have "program" and "instruction" fields.`);
+        }
+        if (match$2 === undefined) {
+          return Stdlib_JsError.throwWithMessage(`simulate: Invalid item. Each item must have "program" and "instruction" fields.`);
+        }
+        let ec = findEventConfig(config, match$1, match$2);
+        let eventConfig = ec !== undefined ? ec : Stdlib_JsError.throwWithMessage(`simulate: Instruction "` + match$2 + `" not found on program "` + match$1 + `". Check that the program and instruction names match your config.yaml.`);
+        let blockJson = rawJson.block;
+        let s = rawJson.slot;
+        let slot;
+        if (s !== undefined) {
+          slot = s;
+        } else if (blockJson == null) {
+          slot = currentBlock.contents;
+        } else {
+          let v = blockJson["slot"];
+          slot = v !== undefined ? Stdlib_Option.getOr((v == null) ? undefined : Primitive_option.some(v), currentBlock.contents) : currentBlock.contents;
+        }
+        currentBlock.contents = slot;
+        let tx = rawJson.transaction;
+        let transaction = tx !== undefined ? Primitive_option.valFromOption(tx) : ({});
+        let transactionIndex = Stdlib_Option.getOr(transaction.transactionIndex, 0);
+        let path = Stdlib_Option.getOr(rawJson.path, [0]);
+        let programId = Stdlib_Option.getOr(rawJson.programId, eventConfig.programId);
+        let args = rawJson.accountArguments;
+        let accountArguments;
+        if (args !== undefined) {
+          accountArguments = args;
+        } else {
+          let named = rawJson.accounts;
+          accountArguments = named !== undefined ? eventConfig.accounts.map(name => {
+              let match = named[name];
+              if (match !== undefined) {
+                return match.address;
+              } else {
+                return "";
+              }
+            }) : [];
+        }
+        let data = Stdlib_Option.getOr(rawJson.data, Stdlib_Option.getOr(eventConfig.discriminator, "0x"));
+        let decoded = Stdlib_Option.map(rawJson.args, args => ({
+          name: match$2,
+          argsJson: JSON.stringify(args),
+          accountsJson: "{}",
+          extraAccounts: []
+        }));
+        let logs = Stdlib_Option.map(rawJson.logs, logs => logs.map(log => ({
+          kind: log.kind,
+          message: log.message
+        })));
+        let liveRegistrations = liveRegistrationsFor(config, chainId, eventConfig);
+        if (Utils.$$Array.isEmpty(liveRegistrations)) {
+          Stdlib_JsError.throwWithMessage(`simulate: no handler runs for instruction "` + match$2 + `" on program "` + match$1 + `". Register a handler with indexer.onInstruction before simulating it.`);
+        }
+        svmTxs.push({
+          slot: slot,
+          transactionIndex: transactionIndex,
+          signature: transaction.signature,
+          allSignatures: transaction.allSignatures,
+          feePayer: transaction.feePayer,
+          success: transaction.success,
+          err: transaction.err,
+          fee: transaction.fee,
+          computeUnitsConsumed: transaction.computeUnitsConsumed,
+          accountKeys: transaction.accountKeys,
+          recentBlockhash: transaction.recentBlockhash,
+          version: transaction.version
+        });
+        let rows = transaction.accountActivities;
+        if (rows !== undefined) {
+          rows.forEach(activity => {
+            svmActivities.push({
+              slot: slot,
+              transactionIndex: transactionIndex,
+              account: activity.address,
+              accountIndex: activity.transactionAccountIndex,
+              isSigner: activity.isSigner,
+              isWritable: activity.isWritable,
+              preBalance: Stdlib_Option.flatMap(activity.lamports, l => l.pre),
+              postBalance: Stdlib_Option.flatMap(activity.lamports, l => l.post),
+              mint: Stdlib_Option.flatMap(activity.token, t => t.mint),
+              owner: Stdlib_Option.flatMap(activity.token, t => t.owner),
+              decimals: Stdlib_Option.flatMap(activity.token, t => t.decimals),
+              preAmount: Stdlib_Option.flatMap(activity.token, t => t.preAmount),
+              postAmount: Stdlib_Option.flatMap(activity.token, t => t.postAmount)
+            });
+          });
+        }
+        let block = rawJson.block;
+        let blockTime = block !== undefined ? block.time : undefined;
+        let block$1 = rawJson.block;
+        let blockHash = block$1 !== undefined ? block$1.hash : undefined;
+        svmBlocks.push({
+          blockNumber: slot,
+          blockHash: blockHash,
+          blockTimestamp: blockTime
+        });
+        liveRegistrations.forEach(reg => {
+          let onEventRegistrationIndex = onEventRegistrations.length;
+          let newrecord = {...reg};
+          newrecord.index = onEventRegistrationIndex;
+          onEventRegistrations.push(newrecord);
+          let payload = SvmHyperSyncSource.toSvmInstruction({
+            onEventRegistrationIndex: onEventRegistrationIndex,
+            slot: slot,
+            transactionIndex: transactionIndex,
+            path: path,
+            programId: programId,
+            accounts: accountArguments,
+            data: data,
+            isInner: Stdlib_Option.getOr(rawJson.isInner, false),
+            decoded: decoded,
+            logs: logs
+          }, match$1, match$2, eventConfig, newrecord.fieldSelection);
+          payload["srcAddress"] = programId;
+          items.push({
+            kind: 0,
+            onEventRegistration: newrecord,
+            chainId: chainId,
+            blockNumber: slot,
+            logIndex: transactionIndex,
+            orderPath: path,
+            transactionIndex: transactionIndex,
+            payload: payload
+          });
+        });
+        return;
     }
-    let ec = findEventConfig(config, match, match$1);
-    let eventConfig = ec !== undefined ? ec : Stdlib_JsError.throwWithMessage(`simulate: Event "` + match$1 + `" not found on contract "` + match + `". Check that the contract and event names match your config.yaml.`);
+    let match$3 = rawJson.contract;
+    let match$4 = rawJson.event;
+    let match$5 = match$3 !== undefined && match$4 !== undefined ? [
+        match$3,
+        match$4
+      ] : Stdlib_JsError.throwWithMessage(`simulate: Invalid item. Each item must have "contract" and "event" fields.`);
+    let eventName = match$5[1];
+    let contractName = match$5[0];
+    let ec$1 = findEventConfig(config, contractName, eventName);
+    let eventConfig$1 = ec$1 !== undefined ? ec$1 : Stdlib_JsError.throwWithMessage(`simulate: Event "` + eventName + `" not found on contract "` + contractName + `". Check that the contract and event names match your config.yaml.`);
     let json = rawJson.params;
     let paramsJson = json !== undefined ? json : ({});
-    let params = S$RescriptSchema.convertOrThrow(paramsJson, eventConfig.simulateParamsSchema);
+    let params = S$RescriptSchema.convertOrThrow(paramsJson, eventConfig$1.simulateParamsSchema);
     let li = rawJson.logIndex;
     let logIndex;
     if (li !== undefined) {
@@ -205,45 +358,45 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
       currentLogIndex.contents = li$1 + 1 | 0;
       logIndex = li$1;
     }
-    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig, chainConfig, config);
-    let blockJson = rawJson.block;
-    let blockJson$1 = (blockJson == null) ? undefined : Primitive_option.some(blockJson);
+    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig$1, chainConfig, config);
+    let blockJson$1 = rawJson.block;
+    let blockJson$2 = (blockJson$1 == null) ? undefined : Primitive_option.some(blockJson$1);
     let transactionJson = rawJson.transaction;
     let transactionJson$1 = (transactionJson == null) ? undefined : Primitive_option.some(transactionJson);
-    let match$2 = config.ecosystem.name;
-    let match$3;
-    switch (match$2) {
+    let match$6 = config.ecosystem.name;
+    let match$7;
+    switch (match$6) {
       case "evm" :
-        let block = parseEvmSimulateBlock(currentBlock.contents, blockJson$1);
-        match$3 = [
-          block,
-          block.number
+        let block$2 = parseEvmSimulateBlock(currentBlock.contents, blockJson$2);
+        match$7 = [
+          block$2,
+          block$2.number
         ];
         break;
       case "fuel" :
-        let block$1 = parseFuelSimulateBlock(currentBlock.contents, blockJson$1);
-        match$3 = [
-          block$1,
-          block$1.height
+        let block$3 = parseFuelSimulateBlock(currentBlock.contents, blockJson$2);
+        match$7 = [
+          block$3,
+          block$3.height
         ];
         break;
       case "svm" :
-        match$3 = Stdlib_JsError.throwWithMessage("simulate is not supported for SVM ecosystem");
+        match$7 = Stdlib_JsError.throwWithMessage("simulate is not supported for SVM ecosystem");
         break;
     }
-    let blockNumber = match$3[1];
-    let block$2 = match$3[0];
-    let match$4 = config.ecosystem.name;
-    let transaction;
-    switch (match$4) {
+    let blockNumber = match$7[1];
+    let block$4 = match$7[0];
+    let match$8 = config.ecosystem.name;
+    let transaction$1;
+    switch (match$8) {
       case "evm" :
-        transaction = parseEvmSimulateTransaction(transactionJson$1);
+        transaction$1 = parseEvmSimulateTransaction(transactionJson$1);
         break;
       case "fuel" :
-        transaction = parseFuelSimulateTransaction(transactionJson$1);
+        transaction$1 = parseFuelSimulateTransaction(transactionJson$1);
         break;
       case "svm" :
-        transaction = Stdlib_JsError.throwWithMessage("simulate is not supported for SVM ecosystem");
+        transaction$1 = Stdlib_JsError.throwWithMessage("simulate is not supported for SVM ecosystem");
         break;
     }
     currentBlock.contents = blockNumber;
@@ -254,20 +407,20 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
     } else {
       seenCoordinates[coordinate] = itemIndex;
     }
-    let liveRegistrations = HandlerRegister.getSimulateOnEventRegistrations(config, chainId, eventConfig).filter(reg => {
+    let liveRegistrations$1 = HandlerRegister.getSimulateOnEventRegistrations(config, chainId, eventConfig$1).filter(reg => {
       if (Stdlib_Option.isSome(reg.handler) || Stdlib_Option.isSome(reg.contractRegister)) {
         return !HandlerRegister.isDroppedByWhere(config, reg);
       } else {
         return false;
       }
     });
-    if (Utils.$$Array.isEmpty(liveRegistrations)) {
-      let match$5 = ChainMap.values(config.chainMap).length;
-      Stdlib_JsError.throwWithMessage(`simulate: no handler runs for event "` + match$1 + `" on contract "` + match + `"` + (
-        match$5 !== 1 ? ` on chain ` + ChainId.toString(chainId) : ""
+    if (Utils.$$Array.isEmpty(liveRegistrations$1)) {
+      let match$9 = ChainMap.values(config.chainMap).length;
+      Stdlib_JsError.throwWithMessage(`simulate: no handler runs for event "` + eventName + `" on contract "` + contractName + `"` + (
+        match$9 !== 1 ? ` on chain ` + ChainId.toString(chainId) : ""
       ) + `. Register a handler with indexer.onEvent (and check any \`where\` filter isn't excluding this chain) before simulating it.`);
     }
-    liveRegistrations.forEach(reg => {
+    liveRegistrations$1.forEach(reg => {
       let onEventRegistrationIndex = onEventRegistrations.length;
       let newrecord = {...reg};
       newrecord.index = onEventRegistrationIndex;
@@ -280,19 +433,34 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
         logIndex: logIndex,
         transactionIndex: 0,
         payload: {
-          contractName: eventConfig.contractName,
-          eventName: eventConfig.name,
+          contractName: eventConfig$1.contractName,
+          eventName: eventConfig$1.name,
           params: params,
           chainId: chainId,
           srcAddress: srcAddress,
           logIndex: logIndex,
-          transaction: Primitive_option.some(transaction),
-          block: Primitive_option.some(block$2)
+          transaction: Primitive_option.some(transaction$1),
+          block: Primitive_option.some(block$4)
         }
       });
     });
   });
-  return items;
+  let match = config.ecosystem.name;
+  switch (match) {
+    case "evm" :
+    case "fuel" :
+      return {
+        items: items,
+        transactionStore: undefined,
+        blockStore: undefined
+      };
+    case "svm" :
+      return {
+        items: items,
+        transactionStore: Primitive_option.some(TransactionStore.fromSvmJs(svmTxs, svmActivities)),
+        blockStore: Primitive_option.some(BlockStore.fromJs(svmBlocks, "svm", false))
+      };
+  }
 }
 
 function patchConfig(config, processConfig, registrationsByChainId) {
@@ -329,12 +497,14 @@ function patchConfig(config, processConfig, registrationsByChainId) {
     let newrecord = {...chainConfig};
     newrecord.endBlock = endBlock;
     newrecord.startBlock = startBlock;
-    let items = parse(simulateRaw, config, newrecord, chainRegistrations.onEventRegistrations);
+    let match = parse(simulateRaw, config, newrecord, chainRegistrations.onEventRegistrations);
     let newrecord$1 = {...newrecord};
     newrecord$1.sourceConfig = {
       TAG: "SimulateSourceConfig",
-      items: items,
-      endBlock: endBlock
+      items: match.items,
+      endBlock: endBlock,
+      transactionStore: match.transactionStore,
+      blockStore: match.blockStore
     };
     return newrecord$1;
   });
@@ -356,6 +526,7 @@ export {
   dummySrcAddress,
   firstContractAddress,
   deriveSrcAddress,
+  liveRegistrationsFor,
   parse,
   patchConfig,
 }

package/src/TestIndexer.res

@@ -10,6 +10,12 @@ type fuelChainConfig = {
   simulate?: array<Envio.fuelSimulateItem>,
 }
 
+type svmChainConfig = {
+  startBlock?: int,
+  endBlock?: int,
+  simulate?: array<Envio.svmSimulateItem>,
+}
+
 // Internal type used for block range validation and state management
 type chainConfig = {
   startBlock: int,
@@ -314,22 +320,32 @@ let getSimulateEndBlock = (
   ~startBlock: int,
 ): int => {
   let maxBlock = ref(startBlock)
+  let blockNumberKey = switch config.ecosystem.name {
+  | Svm => "slot"
+  | _ => config.ecosystem.blockNumberName
+  }
+  let bump = (n: option<int>) =>
+    switch n {
+    | Some(v) if v > maxBlock.contents => maxBlock := v
+    | _ => ()
+    }
+  let getInt = (d: dict<JSON.t>, key) =>
+    d
+    ->Dict.get(key)
+    ->Option.flatMap(v => v->(Utils.magic: JSON.t => Nullable.t<int>)->Nullable.toOption)
   simulateItems->Array.forEach(rawJson => {
+    let itemDict = rawJson->(Utils.magic: JSON.t => dict<JSON.t>)
+    // SVM items carry the slot at the top level (`block.slot` is the override).
+    switch config.ecosystem.name {
+    | Svm => itemDict->getInt("slot")->bump
+    | _ => ()
+    }
     let blockJson: option<JSON.t> =
       (rawJson->(Utils.magic: JSON.t => {..}))["block"]
       ->(Utils.magic: 'a => Nullable.t<JSON.t>)
       ->Nullable.toOption
     switch blockJson {
-    | Some(bj) =>
-      let blockDict = bj->(Utils.magic: JSON.t => dict<JSON.t>)
-      let n: option<int> =
-        blockDict
-        ->Dict.get(config.ecosystem.blockNumberName)
-        ->Option.flatMap(v => v->(Utils.magic: JSON.t => Nullable.t<int>)->Nullable.toOption)
-      switch n {
-      | Some(v) if v > maxBlock.contents => maxBlock := v
-      | _ => ()
-      }
+    | Some(bj) => bj->(Utils.magic: JSON.t => dict<JSON.t>)->getInt(blockNumberKey)->bump
     | None => ()
     }
   })

package/src/TestIndexer.res.mjs

@@ -230,22 +230,44 @@ function getSimulateEndBlock(simulateItems, config, startBlock) {
   let maxBlock = {
     contents: startBlock
   };
-  simulateItems.forEach(rawJson => {
-    let blockJson = rawJson.block;
-    if (blockJson == null) {
-      return;
-    }
-    let n = Stdlib_Option.flatMap(blockJson[config.ecosystem.blockNumberName], v => {
-      if (v == null) {
-        return;
-      } else {
-        return Primitive_option.some(v);
-      }
-    });
+  let match = config.ecosystem.name;
+  let blockNumberKey;
+  switch (match) {
+    case "evm" :
+    case "fuel" :
+      blockNumberKey = config.ecosystem.blockNumberName;
+      break;
+    case "svm" :
+      blockNumberKey = "slot";
+      break;
+  }
+  let bump = n => {
     if (n !== undefined && n > maxBlock.contents) {
       maxBlock.contents = n;
       return;
     }
+  };
+  let getInt = (d, key) => Stdlib_Option.flatMap(d[key], v => {
+    if (v == null) {
+      return;
+    } else {
+      return Primitive_option.some(v);
+    }
+  });
+  simulateItems.forEach(rawJson => {
+    let match = config.ecosystem.name;
+    switch (match) {
+      case "evm" :
+      case "fuel" :
+        break;
+      case "svm" :
+        bump(getInt(rawJson, "slot"));
+        break;
+    }
+    let blockJson = rawJson.block;
+    if (!(blockJson == null)) {
+      return bump(getInt(blockJson, blockNumberKey));
+    }
   });
   return maxBlock.contents;
 }

package/src/bindings/ClickHouse.res

@@ -14,8 +14,13 @@ type execParams = {query: string}
 @module("@clickhouse/client")
 external createClient: clientConfig => client = "createClient"
 
+// `command`, not `exec`: exec hands its response stream to the caller and holds
+// the socket until it is consumed, which nothing here does. The pool is 10
+// sockets wide, so a schema whose DDL needs more than that — initialize issues
+// 2N+3 statements for N entities — stalled every statement past the tenth until
+// the 30s request timeout freed one. command destroys the stream for us.
 @send
-external exec: (client, execParams) => promise<unit> = "exec"
+external command: (client, execParams) => promise<unit> = "command"
 
 @send
 external close: client => promise<unit> = "close"
@@ -352,6 +357,17 @@ let setUpdatesOrThrow = async (
 // The '{cluster}' macro resolves to each node's configured cluster name.
 let onClusterClause = (~onCluster: bool) => onCluster ? ` ON CLUSTER '{cluster}'` : ""
 
+// ReplicatedMergeTree drops an insert whose block hash is already in Keeper, and
+// mutations don't clear those hashes. Crash recovery trims the history tail past
+// the committed Postgres checkpoint with ALTER ... DELETE and then replays it, so
+// an identical replayed block would be discarded while still reporting success —
+// a permanent gap that nothing surfaces. Trim-then-replay is what makes recovery
+// correct here, and the duplicates dedup would have caught are already collapsed
+// by the entity view's `LIMIT 1 BY`. Plain MergeTree goes by
+// non_replicated_deduplication_window (0 by default), so it needs no clause.
+let replicatedTableSettingsClause = (~replicated: bool) =>
+  replicated ? "\nSETTINGS replicated_deduplication_window = 0" : ""
+
 // Strip both engine arguments `(...)` and a trailing `SETTINGS ...` clause to
 // get the bare engine name, e.g. `Replicated('/p','{shard}','{replica}') SETTINGS x=1`
 // and `Replicated SETTINGS x=1` both yield `Replicated`.
@@ -390,9 +406,9 @@ let makeCreateHistoryTableQuery = (
     }
   })
 
-  let (partitionBy, orderBy, ttl) = switch entityConfig.storage.clickhouseOptions {
-  | Some(options) => (options.partitionBy, options.orderBy, options.ttl)
-  | None => (None, None, None)
+  let (partitionBy, orderBy, ttl, skippingIndexes) = switch entityConfig.storage.clickhouseOptions {
+  | Some(options) => (options.partitionBy, options.orderBy, options.ttl, options.skippingIndexes)
+  | None => (None, None, None, None)
   }
 
   // Schema field name -> ClickHouse column name, so @storage(clickhouse: {...})
@@ -456,6 +472,22 @@ let makeCreateHistoryTableQuery = (
   | None => ""
   }
 
+  // Data skipping indexes live inside the column list, after the last column.
+  // GRANULARITY is omitted when unset, leaving ClickHouse's default of 1.
+  let skippingIndexDefinitions = switch skippingIndexes {
+  | Some(skippingIndexes) =>
+    skippingIndexes
+    ->Array.map(index => {
+      let granularityClause = switch index.granularity {
+      | Some(granularity) => ` GRANULARITY ${granularity->Int.toString}`
+      | None => ""
+      }
+      `,\n  INDEX \`${index.name}\` ${index.expr->resolveExpressionColumns} TYPE ${index.type_}${granularityClause}`
+    })
+    ->Array.joinUnsafe("")
+  | None => ""
+  }
+
   `CREATE TABLE IF NOT EXISTS ${database}.\`${EntityHistory.historyTableName(
       ~entityName=entityConfig.name,
       ~entityIndex=entityConfig.index,
@@ -470,10 +502,10 @@ let makeCreateHistoryTableQuery = (
       ~fieldType=Enum({config: EntityHistory.RowAction.config->Table.fromGenericEnumConfig}),
       ~isNullable=false,
       ~isArray=false,
-    )}
+    )}${skippingIndexDefinitions}
 )
 ENGINE = ${tableEngine}${partitionByClause}
-ORDER BY (${orderByColumns})${ttlClause}`
+ORDER BY (${orderByColumns})${ttlClause}${replicatedTableSettingsClause(~replicated)}`
 }
 
 // Generate CREATE TABLE query for checkpoints
@@ -517,7 +549,7 @@ let makeCreateCheckpointsTableQuery = (
     )}
 )
 ENGINE = ${tableEngine}
-ORDER BY (${idField})`
+ORDER BY (${idField})${replicatedTableSettingsClause(~replicated)}`
 }
 
 // Generate CREATE VIEW query for entity current state
@@ -628,21 +660,21 @@ let initialize = async (
       // CLUSTER removes the database from every node — the engine's own log
       // can't replicate the drop of the database it lives in — and SYNC waits
       // for the drop to finish before the CREATE below.
-      await client->exec({
+      await client->command({
         query: `DROP DATABASE IF EXISTS ${database} ON CLUSTER '{cluster}' SYNC`,
       })
     } else {
-      await client->exec({
+      await client->command({
         query: `TRUNCATE DATABASE IF EXISTS ${database}${onClusterClause(~onCluster=ddlOnCluster)}`,
       })
     }
-    await client->exec({
+    await client->command({
       query: `CREATE DATABASE IF NOT EXISTS ${database}${databaseOnClusterClause}${databaseEngineClause}`,
     })
 
     await Promise.all(
       entities->Array.map(entityConfig =>
-        client->exec({
+        client->command({
           query: makeCreateHistoryTableQuery(
             ~entityConfig,
             ~database,
@@ -653,7 +685,7 @@ let initialize = async (
         })
       ),
     )->Utils.Promise.ignoreValue
-    await client->exec({
+    await client->command({
       query: makeCreateCheckpointsTableQuery(
         ~database,
         ~replicated,
@@ -670,14 +702,14 @@ let initialize = async (
     // caught up before creating the views. ON CLUSTER must precede the
     // database name in this command's grammar.
     if hasReplicatedDatabaseEngine {
-      await client->exec({
+      await client->command({
         query: `SYSTEM SYNC DATABASE REPLICA ON CLUSTER '{cluster}' ${database}`,
       })
     }
 
     await Promise.all(
       entities->Array.map(entityConfig =>
-        client->exec({
+        client->command({
           query: makeCreateViewQuery(~entityConfig, ~database, ~onCluster=ddlOnCluster),
         })
       ),
@@ -697,7 +729,7 @@ let resume = async (client, ~database: string, ~checkpointId: Internal.checkpoin
   try {
     // Try to use the database - will throw if it doesn't exist
     try {
-      await client->exec({query: `USE ${database}`})
+      await client->command({query: `USE ${database}`})
     } catch {
     | exn =>
       Logging.errorWithExn(
@@ -717,14 +749,14 @@ let resume = async (client, ~database: string, ~checkpointId: Internal.checkpoin
     await Promise.all(
       tables->Array.map(table => {
         let tableName = table["name"]
-        client->exec({
+        client->command({
           query: `ALTER TABLE ${database}.\`${tableName}\` DELETE WHERE \`${EntityHistory.checkpointIdFieldName}\` > ${checkpointId->BigInt.toString}`,
         })
       }),
     )->Utils.Promise.ignoreValue
 
     // Delete stale checkpoints
-    await client->exec({
+    await client->command({
       query: `DELETE FROM ${database}.\`${InternalTable.Checkpoints.table.tableName}\` WHERE \`${Table.idFieldName}\` > ${checkpointId->BigInt.toString}`,
     })
   } catch {