prool 0.0.14 → 0.0.16

package/instances/silius.test.ts

@@ -0,0 +1,108 @@
+import getPort from 'get-port'
+import { afterEach, beforeAll, expect, test } from 'vitest'
+
+import { siliusOptions } from '../../test/utils.js'
+import type { Instance } from '../instance.js'
+import { anvil } from './anvil.js'
+import { silius } from './silius.js'
+
+const instances: Instance[] = []
+
+const port = await getPort()
+
+const defineInstance = (parameters?: Partial<{}>) => {
+  const instance = silius({
+    ...siliusOptions({ 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: 1338 })
+  const instance_2 = defineInstance({ port: 1338 })
+
+  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()
+  const { promise, resolve } = Promise.withResolvers<void>()
+
+  let exitCode: number | null | undefined = undefined
+  instance.on('exit', (code) => {
+    exitCode = code
+    resolve()
+  })
+
+  await instance.start()
+  expect(instance.status).toEqual('started')
+
+  instance._internal.process.kill()
+
+  await promise
+  expect(instance.status).toEqual('stopped')
+  expect(typeof exitCode !== 'undefined').toBeTruthy()
+})

package/instances/silius.ts

@@ -0,0 +1,347 @@
+import { platform } from 'node:os'
+
+import { rmSync } from 'node:fs'
+import { defineInstance } from '../instance.js'
+import { execa } from '../processes/execa.js'
+import { toArgs } from '../utils.js'
+
+export type SiliusParameters = {
+  /**
+   * The bundler beneficiary address.
+   */
+  beneficiary?: string | undefined
+  /**
+   * The bundle interval in seconds.
+   * @default 10
+   */
+  bundleInterval?: number | undefined
+  bundler?:
+    | {
+        /**
+         * Bundler gRPC address to listen on.
+         * @default '127.0.0.1'
+         */
+        addr?: string | undefined
+        /**
+         * Bundler gRPC port to listen on.
+         * @default 3003
+         */
+        port?: number | undefined
+      }
+    | undefined
+  /**
+   * The chain id.
+   * @default 1
+   */
+  chain?: number | undefined
+  /**
+   * Path to the data directory.
+   */
+  dataDir?: string | undefined
+  discovery?:
+    | {
+        /**
+         * The udp4 port to broadcast to peers in order to reach back for discovery.
+         * @default 9000
+         */
+        port?: number | undefined
+      }
+    | undefined
+  /**
+   * Indicates whether the access list is enabled.
+   */
+  enableAccessList?: boolean | undefined
+  /**
+   * Indicates whether the P2P mode is enabled.
+   */
+  enableP2p?: boolean | undefined
+  /**
+   * Indicates whether the metrics are enabled.
+   */
+  enableMetrics?: boolean | undefined
+  /**
+   * The entry points for the bundler.
+   */
+  entryPoints?: string[] | undefined
+  /**
+   * RPC URL of the execution client.
+   */
+  ethClientAddress?: string | undefined
+  /**
+   * Ethereum execution client proxy HTTP RPC endpoint.
+   */
+  ethClientProxyAddress?: string | undefined
+  http?:
+    | {
+        /**
+         * HTTP address to listen on.
+         * @default '127.0.0.1'
+         */
+        addr?: string | undefined
+        /**
+         * Configures the HTTP RPC API modules
+         * @default 'eth'
+         */
+        api?: string[] | undefined
+        /**
+         * Configures the allowed CORS domains.
+         * @default '*'
+         */
+        corsdomain?: string[] | undefined
+        /**
+         * HTTP port to listen on.
+         * @default 3000
+         */
+        port?: number | undefined
+      }
+    | undefined
+  /**
+   * Maximum gas for verification.
+   * @default 5000000
+   */
+  maxVerificationGas?: bigint | undefined
+  metrics?:
+    | {
+        /**
+         * Metrics address to listen on.
+         * @default '127.0.0.1'
+         */
+        addr?: string | undefined
+        /**
+         * Metrics port to listen on.
+         * @default 3030
+         */
+        port?: number | undefined
+      }
+    | undefined
+  /**
+   * Minimum balance for the beneficiary account.
+   * @default 100000000000000000 wei
+   */
+  minBalance?: bigint | undefined
+  /**
+   * Minimum priority fee per gas.
+   * @default 0
+   */
+  minPriorityFeePerGas?: bigint | undefined
+  /**
+   * Minimum stake required for entities.
+   * @default 1
+   */
+  minStake?: number | undefined
+  /**
+   * Path to the mnemonic file.
+   */
+  mnemonicPath: string | undefined
+  /**
+   * The path to the file where the p2p private key is stored.
+   */
+  nodekey?: string | undefined
+  /**
+   * The path to the file where the p2p enr is stored.
+   */
+  nodeenr?: string | undefined
+  p2p?:
+    | {
+        /**
+         * Sets the p2p listen address
+         * @default '0.0.0.0'
+         */
+        addr?: string | undefined
+        /**
+         * The ipv4 address to broadcast to peers about which address we are listening on.
+         */
+        baddr?: string | undefined
+        /**
+         * The tcp4 port to boardcast to peers in order to reach back for discovery.
+         * @default 9000
+         */
+        bport?: number | undefined
+      }
+    | undefined
+  /**
+   * Poll interval event filters and pending transactions in milliseconds.
+   * @default 500
+   */
+  pollInterval?: number | undefined
+  /**
+   * Port to start the instance on.
+   */
+  port?: number | undefined
+  /**
+   * Sets the send bundle mode.
+   * @default "ethereum-client"
+   */
+  sendBundleMode?: string | undefined
+  uopool?:
+    | {
+        /**
+         * UoPool gRPC address to listen on.
+         * @default '127.0.0.1'
+         */
+        addr?: string | undefined
+        /**
+         * UoPool gRPC port to listen on.
+         * @default 3002
+         */
+        port?: number | undefined
+      }
+    | undefined
+  /**
+   * Sets the UoPool mode.
+   */
+  uopoolMode?: string | undefined
+  /**
+   * Sets the verbosity level.
+   * @default 2
+   */
+  verbosity?: number | undefined
+  /**
+   * Addresses of whitelisted entities.
+   */
+  whitelist?: string[] | undefined
+  ws?:
+    | {
+        /**
+         * WS address to listen on.
+         * @default '127.0.0.1'
+         */
+        addr?: string | undefined
+        /**
+         * Configures the HTTP RPC API modules
+         * @default 'eth'
+         */
+        api?: string[] | undefined
+        /**
+         * Configures the allowed WS origins.
+         * @default '*'
+         */
+        origins?: string[] | undefined
+        /**
+         * WS port to listen on.
+         * @default 3001
+         */
+        port?: number | undefined
+      }
+    | undefined
+}
+
+/**
+ * Defines an Anvil instance.
+ *
+ * @example
+ * ```ts
+ * const instance = silius({
+ *  port: 4337,
+ * })
+ * await instance.start()
+ * // ...
+ * await instance.stop()
+ * ```
+ */
+export const silius = defineInstance((parameters?: SiliusParameters) => {
+  const args = (parameters || {}) as SiliusParameters
+  const { dataDir = '.local', mnemonicPath, port: _, ...rest } = args
+
+  const host = 'localhost'
+  const name = 'silius'
+  const process = execa({ name })
+  let port = args.port ?? 4000
+
+  return {
+    _internal: {
+      args,
+      get process() {
+        return process._internal.process
+      },
+    },
+    host,
+    name,
+    port,
+    async start({ port: port_ = port }, options) {
+      port = port_
+
+      const args_ = [
+        ...(platform() === 'linux' ? ['--net', 'host'] : []),
+        '--add-host',
+        'host.docker.internal:host-gateway',
+        '--add-host',
+        'localhost:host-gateway',
+        '-p',
+        `${port}:${port}`,
+        '-v',
+        `${mnemonicPath}:/data/silius/mnemonic`,
+        '-v',
+        `./${dataDir}/${port_}/db:/data/silius/db`,
+        'ghcr.io/silius-rs/silius:latest',
+        'node',
+        '--datadir',
+        'data/silius',
+        '--mnemonic-file',
+        'data/silius/mnemonic',
+        '--http',
+        '--ws',
+        ...toArgs({
+          ...rest,
+          beneficiary:
+            rest.beneficiary ?? '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+          bundler: {
+            ...rest.bundler,
+            addr: rest.bundler?.addr ?? '0.0.0.0',
+          },
+          entryPoints: rest.entryPoints ?? [
+            '0x0000000071727De22E5E9d8BAf0edAc6f37da032',
+          ],
+          ethClientAddress: rest.ethClientAddress?.replaceAll(
+            /127\.0\.0\.1|0\.0\.0\.0/g,
+            'host.docker.internal',
+          ),
+          ethClientProxyAddress: rest.ethClientProxyAddress?.replaceAll(
+            /127\.0\.0\.1|0\.0\.0\.0/g,
+            'host.docker.internal',
+          ),
+          http: {
+            ...rest.http,
+            addr: rest.http?.addr ?? '0.0.0.0',
+            api: rest.http?.api ?? ['eth', 'debug', 'web3'],
+            port,
+          },
+          metrics: {
+            ...rest.metrics,
+            addr: rest.metrics?.addr ?? '0.0.0.0',
+          },
+          uopool: {
+            ...rest.uopool,
+            addr: rest.uopool?.addr ?? '0.0.0.0',
+          },
+          ws: {
+            ...rest.ws,
+            addr: rest.ws?.addr ?? '0.0.0.0',
+            api: rest.ws?.api ?? ['eth', 'debug', 'web3'],
+            port: rest.ws?.port ?? 4001,
+          },
+        } satisfies Partial<SiliusParameters>),
+      ]
+
+      return await process.start(($) => $`docker run ${args_}`, {
+        ...options,
+        resolver({ process, resolve, reject }) {
+          process.stdout.on('data', (data) => {
+            const message = data.toString()
+            if (message.includes('Started bundler JSON-RPC server')) resolve()
+          })
+          process.stderr.on('data', (data) => {
+            if (data.toString().includes('WARNING')) return
+            reject(data)
+          })
+        },
+      })
+    },
+    async stop() {
+      try {
+        rmSync(`${dataDir}/${port}`, { recursive: true, force: true })
+      } catch {}
+      await process.stop()
+    },
+  }
+})

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prool",
   "description": "HTTP testing instances for Ethereum",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "type": "module",
   "module": "_lib/exports/index.mjs",
   "types": "_lib/exports/index.d.ts",

package/pool.test.ts

@@ -115,25 +115,29 @@ describe.each([
     expect(pool.size).toEqual(0)
   })
 
-  test('restart', async () => {
-    pool = definePool({
-      instance,
-    })
-
-    const instance_1 = await pool.start(1)
-    const instance_2 = await pool.start(2)
-    const instance_3 = await pool.start(3)
-
-    expect(instance_1.status).toBe('started')
-    expect(instance_2.status).toBe('started')
-    expect(instance_3.status).toBe('started')
-    expect(pool.size).toEqual(3)
-
-    const promise_1 = pool.restart(1)
-    expect(instance_1.status).toBe('restarting')
-    await promise_1
-    expect(instance_1.status).toBe('started')
-  })
+  test(
+    'restart',
+    async () => {
+      pool = definePool({
+        instance,
+      })
+
+      const instance_1 = await pool.start(1)
+      const instance_2 = await pool.start(2)
+      const instance_3 = await pool.start(3)
+
+      expect(instance_1.status).toBe('started')
+      expect(instance_2.status).toBe('started')
+      expect(instance_3.status).toBe('started')
+      expect(pool.size).toEqual(3)
+
+      const promise_1 = pool.restart(1)
+      expect(instance_1.status).toBe('restarting')
+      await promise_1
+      expect(instance_1.status).toBe('started')
+    },
+    { timeout: 10_000 },
+  )
 
   test('start > stop > start', async () => {
     pool = definePool({

package/server.test.ts

@@ -1,8 +1,13 @@
 import getPort from 'get-port'
 import { beforeAll, describe, expect, test } from 'vitest'
 import { type MessageEvent, WebSocket } from 'ws'
-import { altoOptions, rundlerOptions, stackupOptions } from '../test/utils.js'
-import { rundler } from './exports/instances.js'
+import {
+  altoOptions,
+  rundlerOptions,
+  siliusOptions,
+  stackupOptions,
+} from '../test/utils.js'
+import { rundler, silius } from './exports/instances.js'
 import { alto } from './instances/alto.js'
 import { anvil } from './instances/anvil.js'
 import { stackup } from './instances/stackup.js'
@@ -470,6 +475,45 @@ describe("instance: 'rundler'", () => {
   })
 })
 
+describe("instance: 'silius'", () => {
+  test(
+    'request: /{id}',
+    async () => {
+      const server = createServer({
+        instance: silius(siliusOptions({ port })),
+      })
+
+      const stop = await server.start()
+      const { port: port_2 } = server.address()!
+      const response = await fetch(`http://localhost:${port_2}/1`, {
+        body: JSON.stringify({
+          method: 'eth_supportedEntryPoints',
+          params: [],
+          id: 0,
+          jsonrpc: '2.0',
+        }),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        method: 'POST',
+      })
+      expect(response.status).toBe(200)
+      expect(await response.json()).toMatchInlineSnapshot(`
+      {
+        "id": 0,
+        "jsonrpc": "2.0",
+        "result": [
+          "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
+        ],
+      }
+    `)
+
+      await stop()
+    },
+    { timeout: 10_000 },
+  )
+})
+
 test('404', async () => {
   const server = createServer({
     instance: anvil(),