prool 0.1.0 → 0.2.0

package/dist/testcontainers/Instance.js

@@ -0,0 +1,83 @@
+import { GenericContainer, Wait, } from 'testcontainers';
+import * as Instance from '../Instance.js';
+import { command } from '../instances/tempo.js';
+/**
+ * Defines a Tempo instance.
+ *
+ * @example
+ * ```ts
+ * const instance = Instance.tempo({ port: 8545 })
+ * await instance.start()
+ * // ...
+ * await instance.stop()
+ * ```
+ */
+export const tempo = Instance.define((parameters) => {
+    const { containerName = `tempo.${crypto.randomUUID()}`, image = 'ghcr.io/tempoxyz/tempo:latest', log: log_, ...args } = parameters || {};
+    const log = (() => {
+        try {
+            return JSON.parse(log_);
+        }
+        catch {
+            return log_;
+        }
+    })();
+    const RUST_LOG = log && typeof log !== 'boolean' ? log : '';
+    const name = 'tempo';
+    let container;
+    return {
+        _internal: {
+            args,
+        },
+        host: args.host ?? 'localhost',
+        name,
+        port: args.port ?? 8545,
+        async start({ port = args.port }, { emitter }) {
+            const promise = Promise.withResolvers();
+            const c = new GenericContainer(image)
+                .withPlatform('linux/x86_64')
+                .withNetworkMode('host')
+                .withExtraHosts([
+                { host: 'host.docker.internal', ipAddress: 'host-gateway' },
+                { host: 'localhost', ipAddress: 'host-gateway' },
+            ])
+                .withName(containerName)
+                .withEnvironment({ RUST_LOG })
+                .withCommand(command({ ...args, port }))
+                .withWaitStrategy(Wait.forLogMessage(/RPC HTTP server started/))
+                .withLogConsumer((stream) => {
+                stream.on('data', (data) => {
+                    const message = data.toString();
+                    emitter.emit('message', message);
+                    emitter.emit('stdout', message);
+                    if (log)
+                        console.log(message);
+                    if (message.includes('shutting down'))
+                        promise.reject(new Error(`Failed to start: ${message}`));
+                });
+                stream.on('error', (error) => {
+                    if (log)
+                        console.error(error.message);
+                    emitter.emit('message', error.message);
+                    emitter.emit('stderr', error.message);
+                    promise.reject(new Error(`Failed to start: ${error.message}`));
+                });
+            })
+                .withStartupTimeout(10_000);
+            c.start()
+                .then((c) => {
+                container = c;
+                promise.resolve();
+            })
+                .catch(promise.reject);
+            return promise.promise;
+        },
+        async stop() {
+            if (!container)
+                return;
+            await container.stop();
+            container = undefined;
+        },
+    };
+});
+//# sourceMappingURL=Instance.js.map

package/dist/testcontainers/Instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instance.js","sourceRoot":"","sources":["../../src/testcontainers/Instance.ts"],"names":[],"mappings":"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"}

package/dist/testcontainers/index.d.ts

@@ -0,0 +1,2 @@
+export * as Instance from './Instance.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/testcontainers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testcontainers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA"}

package/dist/testcontainers/index.js

@@ -0,0 +1,2 @@
+export * as Instance from './Instance.js';
+//# sourceMappingURL=index.js.map

package/dist/testcontainers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testcontainers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prool",
   "description": "HTTP testing instances for Ethereum",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -16,6 +16,11 @@
       "src": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./testcontainers": {
+      "src": "./src/testcontainers/index.ts",
+      "types": "./dist/testcontainers/index.d.ts",
+      "default": "./dist/testcontainers/index.js"
     }
   },
   "dependencies": {

package/src/Instance.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from 'eventemitter3'
 
 export { alto } from './instances/alto.js'
 export { anvil } from './instances/anvil.js'
-export { tempo, tempoDocker } from './instances/tempo.js'
+export { tempo } from './instances/tempo.js'
 
 type EventTypes = {
   exit: [code: number | null, signal: NodeJS.Signals | null]

package/src/instances/tempo.ts

@@ -1,48 +1,60 @@
 import * as os from 'node:os'
 import * as path from 'node:path'
-import {
-  GenericContainer,
-  type StartedTestContainer,
-  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 +101,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 +136,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.
      */
@@ -161,118 +195,13 @@ export declare namespace tempo {
      */
     host?: string | undefined
     /**
-     * Port the server will listen on.
-     */
-    port?: number | undefined
-  }
-}
-
-/**
- * Defines a Tempo instance.
- *
- * @example
- * ```ts
- * const instance = Instance.tempoDocker({ port: 8545 })
- * await instance.start()
- * // ...
- * await instance.stop()
- * ```
- */
-export const tempoDocker = Instance.define(
-  (parameters?: tempoDocker.Parameters) => {
-    const {
-      containerName = `tempo.${crypto.randomUUID()}`,
-      image = 'ghcr.io/tempoxyz/tempo:latest',
-      log: log_,
-      ...args
-    } = parameters || {}
-
-    const log = (() => {
-      try {
-        return JSON.parse(log_ as string)
-      } catch {
-        return log_
-      }
-    })()
-    const RUST_LOG = log && typeof log !== 'boolean' ? log : ''
-
-    const name = 'tempo'
-    let container: StartedTestContainer | undefined
-
-    return {
-      _internal: {
-        args,
-      },
-      host: args.host ?? 'localhost',
-      name,
-      port: args.port ?? 8545,
-      async start({ port = args.port }, { emitter }) {
-        const promise = Promise.withResolvers<void>()
-
-        const c = new GenericContainer(image)
-          .withPlatform('linux/x86_64')
-          .withNetworkMode('host')
-          .withExtraHosts([
-            { host: 'host.docker.internal', ipAddress: 'host-gateway' },
-            { host: 'localhost', ipAddress: 'host-gateway' },
-          ])
-          .withName(containerName)
-          .withEnvironment({ RUST_LOG })
-          .withCommand(command({ ...parameters, port }))
-          .withWaitStrategy(Wait.forLogMessage(/RPC HTTP server started/))
-          .withLogConsumer((stream) => {
-            stream.on('data', (data) => {
-              const message = data.toString()
-              emitter.emit('message', message)
-              emitter.emit('stdout', message)
-              if (log) console.log(message)
-              if (message.includes('shutting down'))
-                promise.reject(new Error(`Failed to start: ${message}`))
-            })
-            stream.on('error', (error) => {
-              if (log) console.error(error.message)
-              emitter.emit('message', error.message)
-              emitter.emit('stderr', error.message)
-              promise.reject(new Error(`Failed to start: ${error.message}`))
-            })
-          })
-          .withStartupTimeout(10_000)
-
-        c.start()
-          .then((c) => {
-            container = c
-            promise.resolve()
-          })
-          .catch(promise.reject)
-
-        return promise.promise
-      },
-      async stop() {
-        if (!container) return
-        await container.stop()
-        container = undefined
-      },
-    }
-  },
-)
-
-export declare namespace tempoDocker {
-  export type Parameters = Omit<tempo.Parameters, 'binary'> & {
-    /**
-     * Name of the container.
+     * Derive dev accounts from a fixed mnemonic instead of random ones.
+     * @default "test test test test test test test test test test test junk"
      */
-    containerName?: string | undefined
-    /**
-     * Docker image to use.
-     */
-    image?: string | undefined
-    /**
-     * Host the server will listen on.
-     */
-    host?: string | undefined
+    mnemonic?: string | undefined
     /**
      * Port the server will listen on.
      */
     port?: number | undefined
-  }
+  } & Record<string, unknown>
 }

package/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,

package/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
+}

package/src/testcontainers/Instance.test.ts

@@ -0,0 +1,84 @@
+import getPort from 'get-port'
+import { Instance } from 'prool/testcontainers'
+import { afterEach, expect, test } from 'vitest'
+
+const instances: Instance.Instance[] = []
+
+const port = await getPort()
+
+const defineInstance = (parameters: Instance.tempo.Parameters = {}) => {
+  const instance = Instance.tempo({ port, ...parameters })
+  instances.push(instance)
+  return instance
+}
+
+afterEach(async () => {
+  for (const instance of instances) await instance.stop().catch(() => {})
+})
+
+test('default', async () => {
+  const messages: string[] = []
+  const stdouts: string[] = []
+
+  const instance = defineInstance()
+
+  instance.on('message', (m) => messages.push(m))
+  instance.on('stdout', (m) => stdouts.push(m))
+
+  expect(instance.messages.get()).toMatchInlineSnapshot('[]')
+
+  await instance.start()
+  expect(instance.status).toEqual('started')
+
+  expect(messages.join('')).toBeDefined()
+  expect(stdouts.join('')).toBeDefined()
+  expect(instance.messages.get().join('')).toBeDefined()
+
+  await instance.stop()
+  expect(instance.status).toEqual('stopped')
+
+  expect(messages.join('')).toBeDefined()
+  expect(stdouts.join('')).toBeDefined()
+  expect(instance.messages.get()).toMatchInlineSnapshot('[]')
+})
+
+test('behavior: instance errored (duplicate ports)', async () => {
+  const instance_1 = defineInstance({ port: 8546 })
+  const instance_2 = defineInstance({ port: 8546 })
+
+  await instance_1.start()
+  await expect(() => instance_2.start()).rejects.toThrowError('Failed to start')
+})
+
+test('behavior: start and stop multiple times', async () => {
+  const instance = defineInstance()
+
+  await instance.start()
+  await instance.stop()
+  await instance.start()
+  await instance.stop()
+  await instance.start()
+  await instance.stop()
+  await instance.start()
+  await instance.stop()
+})
+
+test('behavior: can subscribe to stdout', async () => {
+  const messages: string[] = []
+  const instance = defineInstance()
+  instance.on('stdout', (message) => messages.push(message))
+
+  await instance.start()
+  expect(messages.length).toBeGreaterThanOrEqual(1)
+})
+
+test('behavior: can subscribe to stderr', async () => {
+  const messages: string[] = []
+
+  const instance_1 = defineInstance({ port: 8546 })
+  const instance_2 = defineInstance({ port: 8546 })
+
+  await instance_1.start()
+  instance_2.on('stderr', (message) => messages.push(message))
+  await expect(instance_2.start()).rejects.toThrow('Failed to start')
+})