prool 0.0.25 → 0.1.1

package/src/instances/tempo.ts

@@ -0,0 +1,322 @@
+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 { 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',
+    ...toArgs(deepAssign(defaultParameters, rest), {
+      arraySeparator: null,
+    }),
+  ]
+}
+
+/**
+ * Defines a Tempo instance.
+ *
+ * @example
+ * ```ts
+ * const instance = Instance.tempo({ port: 8545 })
+ * await instance.start()
+ * // ...
+ * await instance.stop()
+ * ```
+ */
+export const tempo = Instance.define((parameters?: tempo.Parameters) => {
+  const { binary = 'tempo', 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'
+  const process = execa({ name })
+
+  return {
+    _internal: {
+      args,
+      get process() {
+        return process._internal.process
+      },
+    },
+    host: args.host ?? 'localhost',
+    name,
+    port: args.port ?? 8545,
+    async start({ port = args.port }, options) {
+      return await process.start(
+        ($) =>
+          $({
+            env: {
+              RUST_LOG,
+            },
+          })`${[binary, ...command({ ...args, port })]}`,
+        {
+          ...options,
+          // Resolve when the process is listening via "RPC HTTP server started" message.
+          resolver({ process, reject, resolve }) {
+            process.stdout.on('data', (data) => {
+              const message = data.toString()
+              if (log) console.log(message)
+              if (message.includes('RPC HTTP server started')) resolve()
+              if (message.includes('shutting down')) reject('shutting down')
+            })
+            process.stderr.on('data', (data) => {
+              const message = data.toString()
+              if (log) console.error(message)
+            })
+          },
+        },
+      )
+    },
+    async stop() {
+      await process.stop()
+    },
+  }
+})
+
+export declare namespace tempo {
+  export type Parameters = {
+    /**
+     * Path or alias to the Tempo binary.
+     */
+    binary?: string | undefined
+    /**
+     * 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.
+     */
+    faucet?:
+      | {
+          /**
+           * Target token addresses for the faucet to be funding with
+           */
+          addresses?: string[] | undefined
+          /**
+           * Amount for each faucet funding transaction
+           */
+          amount?: bigint | undefined
+          /**
+           * Faucet funding mnemonic
+           */
+          privateKey?: string | undefined
+        }
+      | undefined
+    /**
+     * Rust log level configuration (sets RUST_LOG environment variable).
+     * Can be a log level or a custom filter string.
+     */
+    log?:
+      | 'trace'
+      | 'debug'
+      | 'info'
+      | 'warn'
+      | 'error'
+      | (string & {})
+      | boolean
+      | undefined
+    /**
+     * 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>
+}
+
+/**
+ * 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({ ...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
+      },
+    }
+  },
+)
+
+export declare namespace tempoDocker {
+  export type Parameters = Omit<tempo.Parameters, 'binary'> & {
+    /**
+     * Name of the container.
+     */
+    containerName?: string | undefined
+    /**
+     * Docker image to use.
+     */
+    image?: string | undefined
+    /**
+     * Host the server will listen on.
+     */
+    host?: string | undefined
+    /**
+     * Port the server will listen on.
+     */
+    port?: number | undefined
+  }
+}

package/{utils.test.ts → 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,12 +45,24 @@ test.each([
     [{ foo: { barBaz: 'test' } }, { casing: 'snake' }],
     ['--foo.bar_baz', 'test'],
   ],
-] as [Parameters<typeof toArgs>, string[]][])(
-  'toArgs(%o) -> %o',
-  ([input, options], expected) => {
-    expect(toArgs(input, options)).toEqual(expected)
-  },
-)
+  [
+    [{ 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,
+], expected) => {
+  expect(toArgs(input, options)).toEqual(expected)
+})
 
 test.each([
   ['foo', '--foo'],

package/{utils.ts → src/internal/utils.ts}

@@ -30,7 +30,7 @@ export function extractPath(request: string): ExtractPathReturnType {
 }
 
 const ansiColorRegex =
-  // biome-ignore lint/suspicious/noControlCharactersInRegex: <explanation>
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: _
   /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g
 
 /**
@@ -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/{processes → src/processes}/execa.test.ts

@@ -1,8 +1,9 @@
 import { EventEmitter } from 'eventemitter3'
+import getPort from 'get-port'
 import { afterEach, expect, test } from 'vitest'
-import { type ExecaProcess, execa } from './execa.js'
+import { execa } from './execa.js'
 
-const processes: ExecaProcess[] = []
+const processes: execa.ReturnType[] = []
 function createProcess() {
   const process = execa({ name: 'foo' })
   processes.push(process)
@@ -82,14 +83,7 @@ test('start (error)', async () => {
         process.stderr.on('data', reject)
       },
     }),
-  ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    [Error: Failed to start process "foo": error: unexpected argument '--lol' found
-
-    Usage: anvil [OPTIONS] [COMMAND]
-
-    For more information, try '--help'.
-    ]
-  `)
+  ).rejects.toThrowError('Failed to start process "foo"')
   await expect(resolvers.message.promise).resolves.toBeDefined()
   await expect(resolvers.stderr.promise).resolves.toBeDefined()
 })
@@ -128,7 +122,8 @@ test('behavior: exit when status is starting', async () => {
   emitter.on('exit', resolvers.exit.resolve)
 
   // Invalid argument
-  await process.start(($) => $`anvil`, {
+  const port = await getPort()
+  await process.start(($) => $`anvil --port ${port}`, {
     emitter,
     status: 'starting',
     resolver({ process, resolve }) {

package/{processes → src/processes}/execa.ts

@@ -1,21 +1,20 @@
 import type { SignalConstants } from 'node:os'
-import { type ResultPromise, execa as exec } from 'execa'
-import type { InstanceStartOptions_internal } from '../instance.js'
-import { stripColors } from '../utils.js'
+import { execa as exec, type ResultPromise } from 'execa'
+import type * as Instance from '../Instance.js'
+import { stripColors } from '../internal/utils.js'
 
 export type Process_internal = ResultPromise<{ cleanup: true; reject: false }>
 
-export type ExecaStartOptions = InstanceStartOptions_internal & {
-  resolver(options: {
-    process: Process_internal
-    reject(data: string): Promise<void>
-    resolve(): void
-  }): void
-}
-
-export type ExecaParameters = { name: string }
+export type ExecaStartOptions =
+  Instance.define.InstanceStartOptions_internal & {
+    resolver(options: {
+      process: Process_internal
+      reject(data: string): Promise<void>
+      resolve(): void
+    }): void
+  }
 
-export type ExecaProcess = {
+export type Process = {
   _internal: {
     process: Process_internal
   }
@@ -26,9 +25,8 @@ export type ExecaProcess = {
   ): Promise<void>
   stop(signal?: keyof SignalConstants | number): Promise<void>
 }
-export type ExecaReturnType = ExecaProcess
 
-export function execa(parameters: ExecaParameters): ExecaReturnType {
+export function execa(parameters: execa.Parameters): execa.ReturnType {
   const { name } = parameters
 
   const errorMessages: string[] = []
@@ -112,3 +110,9 @@ export function execa(parameters: ExecaParameters): ExecaReturnType {
     },
   }
 }
+
+export declare namespace execa {
+  export type Parameters = { name: string }
+
+  export type ReturnType = Process
+}

package/src/processes/index.ts

@@ -0,0 +1 @@
+export * as execa from './execa.js'