feat: forward arbitrary args to tempo

Author: jxom

.changeset/icy-lizards-judge.md

@@ -0,0 +1,5 @@
+---
+"prool": patch
+---
+
+Modified `Instance.tempo` to forward arbitrary arguments.

package.json

@@ -7,7 +7,7 @@
     "check:types": "tsc",
     "dev": "zile dev",
     "postinstall": "pnpm dev",
-    "test": "vitest --testTimeout=10000"
+    "test": "vitest --testTimeout=100000"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.8",

src/instances/tempo.ts

@@ -6,43 +6,60 @@ import {
   Wait,
 } from 'testcontainers'
 import * as Instance from '../Instance.js'
+import { deepAssign, toArgs } from '../internal/utils.js'
 import { execa } from '../processes/execa.js'
 
 export function command(parameters: tempo.Parameters): string[] {
-  const { faucet, port } = parameters
-  const dataDir = path.join(os.tmpdir(), '.prool', `tempo.${port}`)
+  const { blockMaxTransactions, blockTime, mnemonic, port, ...rest } =
+    parameters
+
+  const datadir = path.join(os.tmpdir(), '.prool', `tempo.${port}`)
+  const defaultParameters = {
+    authrpc: {
+      port: port! + 30,
+    },
+    datadir,
+    dev: [
+      true,
+      {
+        blockTime: blockTime ?? '50ms',
+        ...(blockMaxTransactions ? { blockMaxTransactions } : {}),
+        ...(mnemonic ? { mnemonic } : {}),
+      },
+    ],
+    engine: {
+      disablePrecompileCache: true,
+      legacyStateRoot: true,
+    },
+    faucet: {
+      address: [
+        '0x20c0000000000000000000000000000000000000',
+        '0x20c0000000000000000000000000000000000001',
+        '0x20c0000000000000000000000000000000000002',
+        '0x20c0000000000000000000000000000000000003',
+      ],
+      amount: '1000000000000',
+      enabled: true,
+      privateKey:
+        '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+    },
+    http: {
+      addr: '0.0.0.0',
+      api: 'all',
+      corsdomain: '*',
+      port: port!,
+    },
+    port: port! + 10,
+    ws: {
+      port: port! + 20,
+    },
+  }
+
   return [
     'node',
-    `--authrpc.port=${port! + 30}`,
-    `--datadir=${dataDir}`,
-    '--dev',
-    `--dev.block-time=${parameters?.blockTime ?? '50ms'}`,
-    '--engine.disable-precompile-cache',
-    '--engine.legacy-state-root',
-    '--faucet.address',
-    ...(faucet?.addresses ?? [
-      '0x20c0000000000000000000000000000000000000',
-      '0x20c0000000000000000000000000000000000001',
-      '0x20c0000000000000000000000000000000000002',
-      '0x20c0000000000000000000000000000000000003',
-    ]),
-    `--faucet.amount=${faucet?.amount ?? '1000000000000'}`,
-    '--faucet.enabled',
-    `--faucet.private-key=${faucet?.privateKey ?? '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'}`,
-    '--http',
-    '--http.addr=0.0.0.0',
-    '--http.api=all',
-    '--http.corsdomain=*',
-    `--http.port=${port!}`,
-    `--port=${port! + 10}`,
-    '--txpool.basefee-max-count=10000000000000',
-    '--txpool.basefee-max-size=10000',
-    '--txpool.max-account-slots=500000',
-    '--txpool.pending-max-count=10000000000000',
-    '--txpool.pending-max-size=10000',
-    '--txpool.queued-max-count=10000000000000',
-    '--txpool.queued-max-size=10000',
-    `--ws.port=${port! + 20}`,
+    ...toArgs(deepAssign(defaultParameters, rest), {
+      arraySeparator: null,
+    }),
   ]
 }
 
@@ -89,7 +106,7 @@ export const tempo = Instance.define((parameters?: tempo.Parameters) => {
             env: {
               RUST_LOG,
             },
-          })`${[binary, ...command({ ...parameters, port })]}`,
+          })`${[binary, ...command({ ...args, port })]}`,
         {
           ...options,
           // Resolve when the process is listening via "RPC HTTP server started" message.
@@ -124,6 +141,28 @@ export declare namespace tempo {
      * Interval between blocks.
      */
     blockTime?: string | undefined
+    /**
+     * How many transactions to mine per block
+     */
+    blockMaxTransactions?: number | undefined
+    /**
+     * Path to a configuration file.
+     */
+    config?: string | undefined
+    /**
+     * The chain this node is running.
+     * Possible values are either a built-in chain or the path to a chain specification file.
+     *
+     * Built-in chains:
+     * - testnet
+     *
+     * @default "testnet"
+     */
+    chain?: string | undefined
+    /**
+     * The path to the data dir for all reth files and subdirectories.
+     */
+    datadir?: string | undefined
     /**
      * Faucet options.
      */
@@ -160,11 +199,16 @@ export declare namespace tempo {
      * Host the server will listen on.
      */
     host?: string | undefined
+    /**
+     * Derive dev accounts from a fixed mnemonic instead of random ones.
+     * @default "test test test test test test test test test test test junk"
+     */
+    mnemonic?: string | undefined
     /**
      * Port the server will listen on.
      */
     port?: number | undefined
-  }
+  } & Record<string, unknown>
 }
 
 /**
@@ -218,7 +262,7 @@ export const tempoDocker = Instance.define(
           ])
           .withName(containerName)
           .withEnvironment({ RUST_LOG })
-          .withCommand(command({ ...parameters, port }))
+          .withCommand(command({ ...args, port }))
           .withWaitStrategy(Wait.forLogMessage(/RPC HTTP server started/))
           .withLogConsumer((stream) => {
             stream.on('data', (data) => {

src/internal/utils.test.ts

@@ -30,10 +30,12 @@ test.each([
   [[{ foo: 0 }], ['--foo', '0']],
   [[{ foo: 1 }], ['--foo', '1']],
   [[{ foo: 1n }], ['--foo', '1']],
+  [[{ foo: 1n }], ['--foo', '1']],
   [[{ foo: 'bar', baz: 1 }], ['--foo', 'bar', '--baz', '1']],
   [[{ fooBar: 'test' }], ['--foo-bar', 'test']],
   [[{ foo: ['bar', 'baz'] }], ['--foo', 'bar,baz']],
   [[{ foo: { barBaz: 'test' } }], ['--foo.bar-baz', 'test']],
+  [[{ foo: [true, { barBaz: 'test' }] }], ['--foo', '--foo.bar-baz', 'test']],
   [[{ foo: { barBaz: ['test', 'test2'] } }], ['--foo.bar-baz', 'test,test2']],
   [
     [{ fooBar: 'test' }, { casing: 'snake' }],
@@ -43,6 +45,18 @@ test.each([
     [{ foo: { barBaz: 'test' } }, { casing: 'snake' }],
     ['--foo.bar_baz', 'test'],
   ],
+  [
+    [{ foo: ['bar', 'baz'] }, { arraySeparator: null }],
+    ['--foo', 'bar', 'baz'],
+  ],
+  [
+    [{ foo: { bar: ['baz', 'qux'] } }, { arraySeparator: null }],
+    ['--foo.bar', 'baz', 'qux'],
+  ],
+  [
+    [{ foo: ['bar', 'baz'] }, { arraySeparator: null }],
+    ['--foo', 'bar', 'baz'],
+  ],
 ] as [Parameters<typeof toArgs>, string[]][])('toArgs(%o) -> %o', ([
   input,
   options,

src/internal/utils.ts

@@ -50,23 +50,26 @@ export function stripColors(message: string) {
  * @returns The command line arguments.
  */
 export function toArgs(
-  obj: {
-    [key: string]:
-      | Record<string, any>
-      | string
-      | readonly string[]
-      | boolean
-      | number
-      | bigint
-      | undefined
-  },
-  options: { casing: 'kebab' | 'snake' } = { casing: 'kebab' },
-) {
-  const { casing } = options
+  obj: Record<string, unknown>,
+  options: {
+    arraySeparator?: string | null | undefined
+    casing?: 'kebab' | 'snake' | undefined
+  } = {},
+): string[] {
+  const { arraySeparator = ',', casing = 'kebab' } = options
   return Object.entries(obj).flatMap(([key, value]) => {
     if (value === undefined) return []
 
-    if (Array.isArray(value)) return [toFlagCase(key), value.join(',')]
+    if (Array.isArray(value)) {
+      if (value[0] === true)
+        return [toFlagCase(key), ...toArgs({ [key]: value[1] }, options)]
+      const arrayValue = (() => {
+        if (arraySeparator === null) return value
+        return value.join(arraySeparator)
+      })()
+
+      return [toFlagCase(key), arrayValue].flat()
+    }
 
     if (typeof value === 'object' && value !== null) {
       return Object.entries(value).flatMap(([subKey, subValue]) => {
@@ -75,7 +78,7 @@ export function toArgs(
           `${key}.${subKey}`,
           casing === 'kebab' ? '-' : '_',
         )
-        return [flag, Array.isArray(subValue) ? subValue.join(',') : subValue]
+        return toArgs({ [flag.slice(2)]: subValue }, options)
       })
     }
 
@@ -84,7 +87,7 @@ export function toArgs(
     if (value === false) return [flag, 'false']
     if (value === true) return [flag]
 
-    const stringified = value.toString()
+    const stringified = value?.toString() ?? ''
     if (stringified === '') return [flag]
 
     return [flag, stringified]
@@ -106,3 +109,30 @@ export function toFlagCase(str: string, separator = '-') {
   }
   return `--${keys.join('.')}`
 }
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return Object.prototype.toString.call(value) === '[object Object]'
+}
+
+export function deepAssign(
+  target: Record<string, unknown>,
+  ...sources: Record<string, unknown>[]
+): Record<string, unknown> {
+  for (const source of sources) {
+    if (!isPlainObject(source)) continue
+
+    for (const key of Reflect.ownKeys(source)) {
+      const srcVal = source[key as keyof typeof source]
+      const tgtVal = target[key as keyof typeof target]
+
+      // If both are plain objects, merge recursively
+      if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+        deepAssign(tgtVal, srcVal)
+        continue
+      }
+      // Otherwise, assign a deep clone of the source value
+      ;(target as any)[key] = structuredClone(srcVal)
+    }
+  }
+  return target
+}