chore: add rule @typescript-eslint/restrict-template-expressions

.eslintrc.js

@@ -114,6 +114,10 @@ module.exports = {
  allowAny: true,
  },
  ],
+ "@typescript-eslint/restrict-template-expressions": [
+ "error",
+ {allowNumber: true, allowBoolean: true, allowNullish: true, allowNever: true, allowRegExp: true},
+ ],
  "import/no-extraneous-dependencies": [
  "error",
  {

packages/api/test/utils/utils.ts

@@ -15,7 +15,7 @@ export function getTestServer(): {baseUrl: string; server: FastifyInstance} {
 
  server.addHook("onError", (request, reply, error, done) => {
  // eslint-disable-next-line no-console
- console.log(`onError: ${error}`);
+ console.log(`onError: ${error.toString()}`);
  done();
  });
 

packages/beacon-node/src/api/rest/base.ts

@@ -87,14 +87,14 @@ export class RestApiServer {
  // Note: Must be an async method so fastify can continue the release lifecycle. Otherwise we must call done() or the request stalls
  server.addHook("onRequest", async (req, _res) => {
  const {operationId} = req.routeConfig as RouteConfig;
- this.logger.debug(`Req ${req.id} ${req.ip} ${operationId}`);
+ this.logger.debug(`Req ${req.id as string} ${req.ip} ${operationId}`);
  metrics?.requests.inc({operationId});
  });
 
  // Log after response
  server.addHook("onResponse", async (req, res) => {
  const {operationId} = req.routeConfig as RouteConfig;
- this.logger.debug(`Res ${req.id} ${operationId} - ${res.raw.statusCode}`);
+ this.logger.debug(`Res ${req.id as string} ${operationId} - ${res.raw.statusCode}`);
  metrics?.responseTime.observe({operationId}, res.getResponseTime() / 1000);
  });
 
@@ -107,9 +107,9 @@ export class RestApiServer {
  const {operationId} = req.routeConfig as RouteConfig;
 
  if (err instanceof ApiError) {
- this.logger.warn(`Req ${req.id} ${operationId} failed`, {reason: err.message});
+ this.logger.warn(`Req ${req.id as string} ${operationId} failed`, {reason: err.message});
  } else {
- this.logger.error(`Req ${req.id} ${operationId} error`, {}, err);
+ this.logger.error(`Req ${req.id as string} ${operationId} error`, {}, err);
  }
  metrics?.errors.inc({operationId});
  });

packages/beacon-node/src/chain/validation/blobsSidecar.ts

@@ -1,7 +1,7 @@
 import bls from "@chainsafe/bls";
 import {CoordType} from "@chainsafe/bls/types";
 import {deneb, Root, ssz} from "@lodestar/types";
-import {bytesToBigInt} from "@lodestar/utils";
+import {bytesToBigInt, toHex} from "@lodestar/utils";
 import {BYTES_PER_FIELD_ELEMENT, FIELD_ELEMENTS_PER_BLOB} from "@lodestar/params";
 import {verifyKzgCommitmentsAgainstTransactions} from "@lodestar/state-transition";
 import {BlobsSidecarError, BlobsSidecarErrorCode} from "../errors/blobsSidecarError.js";
@@ -83,7 +83,9 @@ export function validateBlobsSidecar(
  // assert beacon_block_root == blobs_sidecar.beacon_block_root
  if (!byteArrayEquals(beaconBlockRoot, blobsSidecar.beaconBlockRoot)) {
  throw new Error(
- `beacon block root mismatch. Block root: ${beaconBlockRoot}, Blob root ${blobsSidecar.beaconBlockRoot}`
+ `beacon block root mismatch. Block root: ${toHex(beaconBlockRoot)}, Blob root ${toHex(
+ blobsSidecar.beaconBlockRoot
+ )}`
  );
  }
 

packages/beacon-node/src/network/reqresp/beaconBlocksMaybeBlobsByRange.ts

@@ -87,7 +87,8 @@ export async function beaconBlocksMaybeBlobsByRange(
  blobsSidecars.length
  } lastMatchedSlot=${lastMatchedSlot}, pending blobsSidecars slots=${blobsSidecars
  .slice(blobSideCarIndex)
- .map((blb) => blb.beaconBlockSlot)}`
+ .map((blb) => blb.beaconBlockSlot)
+ .join(",")}`
  );
  }
  return blockInputs;

packages/beacon-node/src/sync/backfill/backfill.ts

@@ -3,7 +3,7 @@ import {StrictEventEmitter} from "strict-event-emitter-types";
 import {BeaconStateAllForks, blockToHeader} from "@lodestar/state-transition";
 import {BeaconConfig, ChainForkConfig} from "@lodestar/config";
 import {phase0, Root, Slot, allForks, ssz} from "@lodestar/types";
-import {ErrorAborted, Logger, sleep} from "@lodestar/utils";
+import {ErrorAborted, Logger, sleep, toHex} from "@lodestar/utils";
 import {toHexString} from "@chainsafe/ssz";
 
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
@@ -528,7 +528,7 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
  )
  // TODO: explode and stop the entire node
  throw new Error(
- `InvalidWsCheckpoint root=${this.wsCheckpointHeader.root}, epoch=${
+ `InvalidWsCheckpoint root=${toHex(this.wsCheckpointHeader.root)}, epoch=${
  this.wsCheckpointHeader.slot / SLOTS_PER_EPOCH
  }, ${
  wsDbCheckpointBlock
@@ -590,9 +590,9 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
  } else {
  validSequence = false;
  this.logger.warn(
- `Invalid backfill sequence: previous finalized or checkpoint block root=${
+ `Invalid backfill sequence: previous finalized or checkpoint block root=${toHex(
  this.prevFinalizedCheckpointBlock.root
- }, slot=${this.prevFinalizedCheckpointBlock.slot} ${
+ )}, slot=${this.prevFinalizedCheckpointBlock.slot} ${
  prevBackfillCpBlock ? "found at slot=" + prevBackfillCpBlock.message.slot : "not found"
  }, ignoring the sequence`
  );
@@ -644,7 +644,9 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
  if (cleanupSeqs.length > 0) {
  await this.db.backfilledRanges.batchDelete(cleanupSeqs.map((entry) => entry.key));
  this.logger.debug(
- `Cleaned up the old sequences between ${this.backfillStartFromSlot},${this.syncAnchor.lastBackSyncedBlock}`,
+ `Cleaned up the old sequences between ${this.backfillStartFromSlot},${toHex(
+ this.syncAnchor.lastBackSyncedBlock.root
+ )}`,
  {cleanupSeqs: JSON.stringify(cleanupSeqs)}
  );
  }
@@ -668,7 +670,9 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
 
  if (expectedSlot !== null && anchorBlock.message.slot !== expectedSlot)
  throw Error(
- `Invalid slot of anchorBlock read from DB with root=${anchorBlockRoot}, expected=${expectedSlot}, actual=${anchorBlock.message.slot}`
+ `Invalid slot of anchorBlock read from DB with root=${toHex(
+ anchorBlockRoot
+ )}, expected=${expectedSlot}, actual=${anchorBlock.message.slot}`
  );
 
  // If possible, read back till anchorBlock > this.prevFinalizedCheckpointBlock
@@ -683,9 +687,9 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
  // Before moving anchorBlock back, we need check for prevFinalizedCheckpointBlock
  if (anchorBlock.message.slot < this.prevFinalizedCheckpointBlock.slot) {
  throw Error(
- `Skipped a prevFinalizedCheckpointBlock with slot=${this.prevFinalizedCheckpointBlock}, root=${toHexString(
+ `Skipped a prevFinalizedCheckpointBlock with slot=${toHex(
  this.prevFinalizedCheckpointBlock.root
- )}`
+ )}, root=${toHexString(this.prevFinalizedCheckpointBlock.root)}`
  );
  }
  if (anchorBlock.message.slot === this.prevFinalizedCheckpointBlock.slot) {
@@ -696,7 +700,7 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
  throw Error(
  `Invalid root for prevFinalizedCheckpointBlock at slot=${
  this.prevFinalizedCheckpointBlock.slot
- }, expected=${toHexString(this.prevFinalizedCheckpointBlock.root)}, found=${anchorBlockRoot}`
+ }, expected=${toHexString(this.prevFinalizedCheckpointBlock.root)}, found=${toHex(anchorBlockRoot)}`
  );
  }
 

packages/beacon-node/test/spec/utils/sszTestCaseParser.ts

@@ -47,7 +47,7 @@ export function parseSszValidTestcase(dirpath: string, metaFilename: string): Va
  const metaStr = fs.readFileSync(path.join(dirpath, metaFilename), "utf8");
  const meta = jsyaml.load(metaStr) as {root: string};
  if (typeof meta.root !== "string") {
- throw Error(`meta.root not a string: ${meta.root}\n${fs}`);
+ throw Error(`meta.root not a string: ${meta.root}\n${metaStr}`);
  }
 
  // The serialized value is stored in serialized.ssz_snappy

packages/beacon-node/test/unit/monitoring/remoteService.ts

@@ -69,7 +69,7 @@ function validateRequestData(data: ReceivedData): void {
  validateClientStats(data, SYSTEM_STATS_SCHEMA);
  break;
  default:
- throw new Error(`Invalid process type "${data.process}"`);
+ throw new Error(`Invalid process type "${data.process as string}"`);
  }
 }
 

packages/beacon-node/test/unit/network/fork.test.ts

@@ -143,7 +143,7 @@ for (const testScenario of testScenarios) {
  it(` on epoch ${epoch} should return ${JSON.stringify({
  currentFork,
  nextFork,
- })}, getActiveForks: ${activeForks}`, () => {
+ })}, getActiveForks: ${activeForks.join(",")}`, () => {
  expect(getCurrentAndNextFork(forkConfig, epoch)).to.deep.equal({
  currentFork: forks[currentFork as ForkName],
  nextFork: (nextFork && forks[nextFork as ForkName]) ?? undefined,

packages/beacon-node/test/utils/node/validator.ts

@@ -86,8 +86,8 @@ export async function getAndInitDevValidators({
 }
 
 export function getApiFromServerHandlers(api: {[K in keyof Api]: ServerApi<Api[K]>}): Api {
- return mapValues(api, (module) =>
- mapValues(module, (api: APIServerHandler) => {
+ return mapValues(api, (apiModule) =>
+ mapValues(apiModule, (api: APIServerHandler) => {
  return async (...args: any) => {
  let code: HttpStatusCode = HttpStatusCode.OK;
  try {
@@ -110,7 +110,7 @@ export function getApiFromServerHandlers(api: {[K in keyof Api]: ServerApi<Api[K
  error: {
  code: code ?? HttpStatusCode.INTERNAL_SERVER_ERROR,
  message: (err as Error).message,
- operationId: `${module}.${api.name}`,
+ operationId: api.name,
  },
  };
  }

packages/cli/test/sim/deneb.test.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import path from "node:path";
 import {activePreset} from "@lodestar/params";
-import {toHexString} from "@lodestar/utils";
+import {toHex, toHexString} from "@lodestar/utils";
 import {ApiError} from "@lodestar/api";
 import {nodeAssertion} from "../utils/simulation/assertions/nodeAssertion.js";
 import {CLIQUE_SEALING_PERIOD, SIM_TESTS_SECONDS_PER_SLOT} from "../utils/simulation/constants.js";
@@ -89,7 +89,7 @@ const checkpointSync = await env.createNodePair({
  id: "checkpoint-sync-node",
  cl: {
  type: CLClient.Lodestar,
- options: {clientOptions: {wssCheckpoint: `${headForCheckpointSync.root}:${headForCheckpointSync.epoch}`}},
+ options: {clientOptions: {wssCheckpoint: `${toHex(headForCheckpointSync.root)}:${headForCheckpointSync.epoch}`}},
  },
  el: ELClient.Geth,
  keysCount: 0,

packages/cli/test/sim/multi_fork.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import path from "node:path";
-import {sleep, toHexString} from "@lodestar/utils";
+import {sleep, toHex, toHexString} from "@lodestar/utils";
 import {ApiError} from "@lodestar/api";
 import {CLIQUE_SEALING_PERIOD, SIM_TESTS_SECONDS_PER_SLOT} from "../utils/simulation/constants.js";
 import {AssertionMatch, CLClient, ELClient} from "../utils/simulation/interfaces.js";
@@ -116,7 +116,7 @@ const checkpointSync = await env.createNodePair({
  id: "checkpoint-sync-node",
  cl: {
  type: CLClient.Lodestar,
- options: {clientOptions: {wssCheckpoint: `${headForCheckpointSync.root}:${headForCheckpointSync.epoch}`}},
+ options: {clientOptions: {wssCheckpoint: `${toHex(headForCheckpointSync.root)}:${headForCheckpointSync.epoch}`}},
  },
  el: ELClient.Geth,
  keysCount: 0,

packages/cli/test/utils/simulation/TableReporter.ts

@@ -139,7 +139,7 @@ export class TableReporter extends SimulationReporter<typeof defaultAssertions>
  for (const error of assertionErrors) {
  console.info(
  `├──── ${error.nodeId}: ${error.message} ${Object.entries(error.data ?? {})
- .map(([k, v]) => `${k}=${v}`)
+ .map(([k, v]) => `${k}=${v as string}`)
  .join(" ")}`
  );
  }

packages/config/src/chainConfig/json.ts

@@ -52,7 +52,7 @@ export function serializeSpecValue(value: SpecValue, typeName: SpecValueTypeName
  switch (typeName) {
  case "number":
  if (typeof value !== "number") {
- throw Error(`Invalid value ${value} expected number`);
+ throw Error(`Invalid value ${value.toString()} expected number`);
  }
  if (value === Infinity) {
  return MAX_UINT64_JSON;
@@ -61,27 +61,27 @@ export function serializeSpecValue(value: SpecValue, typeName: SpecValueTypeName
 
  case "bigint":
  if (typeof value !== "bigint") {
- throw Error(`Invalid value ${value} expected bigint`);
+ throw Error(`Invalid value ${value.toString()} expected bigint`);
  }
  return value.toString(10);
 
  case "bytes":
  if (!(value instanceof Uint8Array)) {
- throw Error(`Invalid value ${value} expected Uint8Array`);
+ throw Error(`Invalid value ${value.toString()} expected Uint8Array`);
  }
  return toHexString(value);
 
  case "string":
  if (typeof value !== "string") {
- throw Error(`Invalid value ${value} expected string`);
+ throw Error(`Invalid value ${value.toString()} expected string`);
  }
  return value;
  }
 }
 
 export function deserializeSpecValue(valueStr: unknown, typeName: SpecValueTypeName, keyName: string): SpecValue {
  if (typeof valueStr !== "string") {
- throw Error(`Invalid ${keyName} value ${valueStr} expected string`);
+ throw Error(`Invalid ${keyName} value ${valueStr as string} expected string`);
  }
 
  switch (typeName) {

packages/logger/test/unit/logger.test.ts

@@ -52,7 +52,9 @@ describe("shouldDeleteLogFile", function () {
  ];
 
  for (const {logFile, maxFiles, result} of tcs) {
- it(`should ${result ? "" : "not"} delete ${logFile}, maxFiles ${maxFiles}, today ${new Date()}`, () => {
+ it(`should ${
+ result ? "" : "not"
+ } delete ${logFile}, maxFiles ${maxFiles}, today ${new Date().toUTCString()}`, () => {
  expect(shouldDeleteLogFile(prefix, extension, logFile, maxFiles)).to.be.equal(result);
  });
  }

packages/params/src/json.ts

@@ -45,7 +45,7 @@ export function presetFromJson(json: Record<string, unknown>): Partial<BeaconPre
  */
 function deserializePresetValue(valueStr: unknown, keyName: string): number {
  if (typeof valueStr !== "string") {
- throw Error(`Invalid ${keyName} value ${valueStr} expected string`);
+ throw Error(`Invalid ${keyName} value ${valueStr as string} expected string`);
  }
 
  const value = parseInt(valueStr, 10);

packages/prover/test/unit/verified_requests/eth_call.test.ts

@@ -36,7 +36,7 @@ describe("verified_requests / eth_call", () => {
  // Temper the responses to make them invalid
  for (const tx of testCase.dependentRequests) {
  if (tx.payload.method === "eth_getCode") {
- tx.response.result = `${tx.response.result}12`;
+ tx.response.result = `${tx.response.result as string}12`;
  }
  }
 

packages/prover/test/unit/verified_requests/eth_estimateGas.test.ts

@@ -37,7 +37,7 @@ describe("verified_requests / eth_estimateGas", () => {
  // Temper the responses to make them invalid
  for (const tx of testCase.dependentRequests) {
  if (tx.payload.method === "eth_getCode") {
- tx.response.result = `${tx.response.result}12`;
+ tx.response.result = `${tx.response.result as string}12`;
  }
  }
 

packages/spec-test-util/src/downloadTests.ts

@@ -77,7 +77,7 @@ export async function downloadGenericSpecTests<TestNames extends string>(
  timeout: 30 * 60 * 1000,
  });
 
- const totalSize = headers["content-length"];
+ const totalSize = headers["content-length"] as string;
  log(`Downloading ${url} - ${totalSize} bytes`);
 
  // extract tar into output directory

packages/spec-test-util/src/sszGeneric.ts

@@ -17,7 +17,7 @@ export function parseSszValidTestcase(dirpath: string, metaFilename: string): Va
  const metaStr = fs.readFileSync(path.join(dirpath, metaFilename), "utf8");
  const meta = loadYaml(metaStr) as {root: string};
  if (typeof meta.root !== "string") {
- throw Error(`meta.root not a string: ${meta.root}\n${fs}`);
+ throw Error(`meta.root not a string: ${meta.root}\n${metaStr}`);
  }
 
  // The serialized value is stored in serialized.ssz_snappy

packages/utils/src/assert.ts

@@ -16,6 +16,7 @@ export const assert = {
  */
  equal<T>(actual: T, expected: T, message?: string): void {
  if (!(actual === expected)) {
+ // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
  throw new AssertionError(`${message || "Expected values to be equal"}: ${actual} === ${expected}`);
  }
  },