prool 0.0.3 → 0.0.5

package/instance.ts

@@ -8,11 +8,11 @@ type EventTypes = {
   stdout: [message: string]
 }
 
-type InstanceStartOptions_internal = {
+export type InstanceStartOptions_internal = {
   emitter: EventEmitter<EventTypes>
   status: Instance['status']
 }
-type InstanceStopOptions_internal = {
+export type InstanceStopOptions_internal = {
   emitter: EventEmitter<EventTypes>
   status: Instance['status']
 }
@@ -30,9 +30,10 @@ export type DefineInstanceFn<
 > = (parameters: parameters) => Pick<Instance, 'host' | 'name' | 'port'> & {
   _internal?: _internal | undefined
   start(
-    options: InstanceStartOptions & InstanceStartOptions_internal,
+    options: InstanceStartOptions,
+    options_internal: InstanceStartOptions_internal,
   ): Promise<void>
-  stop(options: InstanceStopOptions_internal): Promise<void>
+  stop(options_internal: InstanceStopOptions_internal): Promise<void>
 }
 
 export type Instance<
@@ -75,16 +76,25 @@ export type Instance<
    * @example ["Listening on http://127.0.0.1", "Started successfully."]
    */
   messages: { clear(): void; get(): string[] }
+  /**
+   * Retarts the instance.
+   */
+  restart(): Promise<void>
   /**
    * Status of the instance.
    *
    * @default "idle"
    */
-  status: 'idle' | 'stopped' | 'starting' | 'started' | 'stopping'
+  status:
+    | 'idle'
+    | 'restarting'
+    | 'stopped'
+    | 'starting'
+    | 'started'
+    | 'stopping'
   /**
    * Starts the instance.
    *
-   * @param options - Options for starting the instance.
    * @returns A function to stop the instance.
    */
   start(): Promise<() => void>
@@ -147,8 +157,9 @@ export function defineInstance<
         ...fn(parameters),
         ...createParameters,
       }
-      const { messageBuffer = 20, timeout = 10_000 } = options
+      const { messageBuffer = 20, timeout } = options
 
+      let restartResolver = Promise.withResolvers<void>()
       let startResolver = Promise.withResolvers<() => void>()
       let stopResolver = Promise.withResolvers<void>()
 
@@ -156,6 +167,7 @@ export function defineInstance<
 
       let messages: string[] = []
       let status: Instance['status'] = 'idle'
+      let restarting = false
 
       function onExit() {
         status = 'stopped'
@@ -182,6 +194,7 @@ export function defineInstance<
         name,
         port,
         get status() {
+          if (restarting) return 'restarting'
           return status
         },
         async start() {
@@ -205,16 +218,20 @@ export function defineInstance<
           emitter.on('exit', onExit)
 
           status = 'starting'
-          start({
-            emitter,
-            port,
-            status: this.status,
-          })
+          start(
+            {
+              port,
+            },
+            {
+              emitter,
+              status: this.status,
+            },
+          )
             .then(() => {
               status = 'started'
 
               stopResolver = Promise.withResolvers<void>()
-              startResolver.resolve(this.stop)
+              startResolver.resolve(this.stop.bind(this))
             })
             .catch((error) => {
               status = 'idle'
@@ -262,6 +279,22 @@ export function defineInstance<
 
           return stopResolver.promise
         },
+        async restart() {
+          if (restarting) return restartResolver.promise
+
+          restarting = true
+
+          this.stop()
+            .then(() => this.start.bind(this)())
+            .then(() => restartResolver.resolve())
+            .catch(restartResolver.reject)
+            .finally(() => {
+              restartResolver = Promise.withResolvers<void>()
+              restarting = false
+            })
+
+          return restartResolver.promise
+        },
 
         addListener: emitter.addListener.bind(emitter),
         off: emitter.off.bind(emitter),

package/instances/anvil.test.ts

@@ -47,7 +47,7 @@ test('behavior: instance errored (duplicate ports)', async () => {
 
   await instance_1.start()
   await expect(() => instance_2.start()).rejects.toThrowError(
-    'Failed to start anvil',
+    'Failed to start process "anvil"',
   )
 })
 
@@ -81,7 +81,9 @@ test('behavior: can subscribe to stderr', async () => {
 
   await instance_1.start()
   instance_2.on('stderr', (message) => messages.push(message))
-  await expect(instance_2.start()).rejects.toThrow('Failed to start anvil')
+  await expect(instance_2.start()).rejects.toThrow(
+    'Failed to start process "anvil"',
+  )
 })
 
 test('behavior: starts anvil with custom options', async () => {
@@ -122,6 +124,6 @@ test('behavior: exit when status is starting', async () => {
   instance._internal.process.kill()
 
   await expect(promise).rejects.toThrowErrorMatchingInlineSnapshot(
-    '[Error: Failed to start anvil: exited.]',
+    '[Error: Failed to start process "anvil": exited.]',
   )
 })

package/instances/anvil.ts

@@ -1,6 +1,5 @@
-import { type ResultPromise, execa } from 'execa'
 import { defineInstance } from '../instance.js'
-import { stripColors } from '../utils.js'
+import { execa } from '../processes/execa.js'
 import { toArgs } from '../utils.js'
 
 export type AnvilParameters = {
@@ -259,64 +258,37 @@ export type AnvilParameters = {
 export const anvil = defineInstance((parameters?: AnvilParameters) => {
   const { binary = 'anvil', ...args } = parameters || {}
 
-  let process: ResultPromise<{ cleanup: true; reject: false }>
-
-  async function stop() {
-    const killed = process.kill()
-    if (!killed) throw new Error('Failed to stop anvil')
-    return new Promise((resolve) => process.on('close', resolve))
-  }
+  const name = 'anvil'
+  const process = execa({ name })
 
   return {
     _internal: {
       args,
       get process() {
-        return process
+        return process._internal.process
       },
     },
     host: args.host ?? 'localhost',
-    name: 'anvil',
+    name,
     port: args.port ?? 8545,
-    async start({ emitter, port = args.port, status }) {
-      const { promise, resolve, reject } = Promise.withResolvers<void>()
-
-      process = execa(binary, toArgs({ ...args, port }), {
-        cleanup: true,
-        reject: false,
-      })
-
-      process.stdout.on('data', (data) => {
-        const message = stripColors(data.toString())
-        emitter.emit('message', message)
-        emitter.emit('stdout', message)
-        if (message.includes('Listening on')) {
-          emitter.emit('listening')
-          resolve()
-        }
-      })
-      process.stderr.on('data', async (data) => {
-        const message = stripColors(data.toString())
-        emitter.emit('message', message)
-        emitter.emit('stderr', message)
-        await stop()
-        reject(new Error(`Failed to start anvil: ${data.toString()}`))
-      })
-      process.on('close', () => process.removeAllListeners())
-      process.on('exit', (code, signal) => {
-        emitter.emit('exit', code, signal)
-
-        if (!code) {
-          process.removeAllListeners()
-          if (status === 'starting')
-            reject(new Error('Failed to start anvil: exited.'))
-        }
-      })
-
-      return promise
+    async start({ port = args.port }, options) {
+      return await process.start(
+        ($) => $`${binary} ${toArgs({ ...args, port })}`,
+        {
+          ...options,
+          // Resolve when the process is listening via a "Listening on" message.
+          resolver({ process, reject, resolve }) {
+            process.stdout.on('data', (data) => {
+              const message = data.toString()
+              if (message.includes('Listening on')) resolve()
+            })
+            process.stderr.on('data', reject)
+          },
+        },
+      )
     },
     async stop() {
-      process.removeAllListeners()
-      await stop()
+      await process.stop()
     },
   }
 })

package/instances/stackup.test.ts

@@ -0,0 +1,106 @@
+import getPort from 'get-port'
+import { afterEach, beforeAll, expect, test } from 'vitest'
+
+import { stackupOptions } from '../../test/utils.js'
+import type { Instance } from '../instance.js'
+import { anvil } from './anvil.js'
+import { type StackupParameters, stackup } from './stackup.js'
+
+const instances: Instance[] = []
+
+const port = await getPort()
+
+const defineInstance = (parameters?: Partial<StackupParameters>) => {
+  const instance = stackup({
+    ...stackupOptions({ port }),
+    ...parameters,
+  })
+  instances.push(instance)
+  return instance
+}
+
+beforeAll(() => anvil({ port }).start())
+
+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: 1337,
+  })
+  const instance_2 = defineInstance({
+    port: 1337,
+  })
+
+  await instance_1.start()
+  await expect(() => instance_2.start()).rejects.toThrowError()
+})
+
+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 stderr', async () => {
+  const messages: string[] = []
+
+  const instance_1 = defineInstance({ port: 1337 })
+  const instance_2 = defineInstance({ port: 1337 })
+
+  await instance_1.start()
+  instance_2.on('stderr', (message) => messages.push(message))
+  await expect(instance_2.start()).rejects.toThrowError()
+})
+
+test('behavior: exit', async () => {
+  const instance = defineInstance()
+
+  let exitCode: number | null | undefined = undefined
+  instance.on('exit', (code) => {
+    exitCode = code
+  })
+
+  await instance.start()
+  expect(instance.status).toEqual('started')
+
+  instance._internal.process.kill()
+
+  await new Promise<void>((res) => setTimeout(res, 100))
+  expect(instance.status).toEqual('stopped')
+  expect(typeof exitCode !== 'undefined').toBeTruthy()
+})

package/instances/stackup.ts

@@ -0,0 +1,162 @@
+import { defineInstance } from '../instance.js'
+import { execa } from '../processes/execa.js'
+
+export type StackupParameters = {
+  /**
+   * The name of the native tracer to use during validation. This will be "bundlerCollectorTracer" if using builds from ERC-4337 execution client repo.
+   * Defaults to address of `privateKey`.
+   */
+  beneficiary?: string | undefined
+  /**
+   * Directory to store the embedded database.
+   * @default /tmp/stackup_bundler
+   */
+  dataDirectory?: string | undefined
+  /**
+   * RPC url to the execution client.
+   */
+  ethClientUrl: string
+  /**
+   * A boolean value for bundlers on an Arbitrum stack network to properly account for the L1 callData cost.
+   * @default false
+   */
+  isArbStackNetwork?: boolean | undefined
+  /**
+   * A boolean value for bundlers on an OP stack network to properly account for the L1 callData cost.
+   * @default false
+   */
+  isOpStackNetwork?: boolean | undefined
+  /**
+   * A boolean value for bundlers on a network that supports RIP-7212 precompile for secp256r1 signature verification.
+   * @default false
+   */
+  isRip7212Supported?: boolean | undefined
+  /**
+   * The maximum gas limit that can be submitted per UserOperation batch.
+   * @default 18_000_000
+   */
+  maxBatchGasLimit?: number | undefined
+  /**
+   * The maximum duration that a userOp can stay in the mempool before getting dropped.
+   * @default 180
+   */
+  maxOpTtlSeconds?: number | undefined
+  /**
+   * The maximum verificationGasLimit on a received UserOperation.
+   * @default 6_000_000
+   */
+  maxVerificationGas?: number | undefined
+  /**
+   * The maximum block range when looking up a User Operation with eth_getUserOperationReceipt or eth_getUserOperationByHash.
+   *
+   * Higher limits allow for fetching older User Operations but will result in higher request latency due to additional compute on the underlying node.
+   *
+   * @default 2_000
+   */
+  opLookupLimit?: number | undefined
+  /**
+   * Port to start the instance on.
+   */
+  port?: number | undefined
+  /**
+   * The private key for the EOA used to relay User Operation bundles to the EntryPoint.
+   */
+  privateKey: string
+  /**
+   * EntryPoint addresses to support. The first address is the preferred EntryPoint.
+   */
+  supportedEntryPoints?: string[]
+}
+
+/**
+ * Defines an Anvil instance.
+ *
+ * @example
+ * ```ts
+ * const instance = stackup({
+ *  ethClientUrl: 'http://localhost:8545',
+ *  port: 4337,
+ *  privateKey: '0x...'
+ * })
+ * await instance.start()
+ * // ...
+ * await instance.stop()
+ * ```
+ */
+export const stackup = defineInstance((parameters?: StackupParameters) => {
+  const args = (parameters || {}) as StackupParameters
+
+  const host = 'localhost'
+  const name = 'stackup'
+  const process = execa({ name })
+
+  return {
+    _internal: {
+      args,
+      get process() {
+        return process._internal.process
+      },
+    },
+    host,
+    name,
+    port: args.port ?? 4337,
+    async start({ port = args.port }, options) {
+      const args_ = [
+        '--net',
+        'host',
+        '--add-host',
+        'host.docker.internal:host-gateway',
+        '--add-host',
+        'localhost:host-gateway',
+        '-p',
+        `${port}:${port}`,
+        '-e',
+        `ERC4337_BUNDLER_PORT=${port}`,
+        ...Object.entries(args).flatMap(([key, value]) => {
+          if (key === 'port') return []
+          if (value === undefined) return []
+
+          if (key === 'ethClientUrl')
+            value = (value as string).replaceAll(
+              /127\.0\.0\.1|0\.0\.0\.0/g,
+              'host.docker.internal',
+            )
+          if (key === 'privateKey') value = (value as string).replace('0x', '')
+
+          return [
+            '-e',
+            `ERC4337_BUNDLER_${key
+              .replace(/([a-z])([A-Z])/g, '$1_$2')
+              .toUpperCase()}=${value}`,
+          ]
+        }),
+        'stackupwallet/stackup-bundler:latest',
+        '/app/stackup-bundler',
+        'start',
+        '--mode',
+        'private',
+      ]
+      return await process.start(($) => $`docker run ${args_}`, {
+        ...options,
+        resolver({ process, resolve, reject }) {
+          process.stderr.on('data', async (data) => {
+            const message = data.toString()
+            // For some reason, `stackup-bundler` logs to stderr. So we have to try
+            // and dissect what is an error, and what is not. 😅
+            if (message.includes('Set nextTxnTs to'))
+              setTimeout(() => resolve(), 100)
+            else if (
+              message
+                .toLowerCase()
+                .match(/panic|error|connection refused|address already in use/)
+            )
+              reject(data)
+          })
+        },
+      })
+    },
+    async stop() {
+      await process.stop()
+    },
+  }
+})

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prool",
-  "description": "",
-  "version": "0.0.3",
+  "description": "HTTP testing instances for Ethereum",
+  "version": "0.0.5",
   "type": "module",
   "module": "_lib/exports/index.mjs",
   "types": "_lib/exports/index.d.ts",
@@ -15,6 +15,10 @@
       "types": "./_lib/exports/index.d.ts",
       "default": "./_lib/exports/index.js"
     },
+    "./processes": {
+      "types": "./_lib/exports/processes.d.ts",
+      "default": "./_lib/exports/processes.js"
+    },
     "./instances": {
       "types": "./_lib/exports/instances.d.ts",
       "default": "./_lib/exports/instances.js"