tempo.ts 0.0.0 → 0.0.1

package/src/ox/TransactionRequest.ts

@@ -0,0 +1,100 @@
+import type * as Authorization from 'ox/Authorization'
+import type * as Errors from 'ox/Errors'
+import type * as Calls from 'ox/erc7821/Calls'
+import * as Execute from 'ox/erc7821/Execute'
+import type * as Hex from 'ox/Hex'
+import * as ox_TransactionRequest from 'ox/TransactionRequest'
+import type { Compute } from '../internal/types.js'
+import * as TokenId from './TokenId.js'
+import * as Transaction from './Transaction.js'
+
+/** A Transaction Request that is generic to all transaction types, as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/4aca1d7a3e5aab24c8f6437131289ad386944eaa/src/schemas/transaction.yaml#L358-L423). */
+export type TransactionRequest<
+  bigintType = bigint,
+  numberType = number,
+  type extends string = string,
+> = Compute<
+  ox_TransactionRequest.TransactionRequest<bigintType, numberType, type> & {
+    calls?: readonly Calls.Call[] | undefined
+    feeToken?: TokenId.TokenIdOrAddress | undefined
+  }
+>
+
+/** RPC representation of a {@link ox#TransactionRequest.TransactionRequest}. */
+export type Rpc = TransactionRequest<Hex.Hex, Hex.Hex, string>
+
+/**
+ * Converts a {@link ox#TransactionRequest.TransactionRequest} to a {@link ox#TransactionRequest.Rpc}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Value } from 'ox'
+ * import { TransactionRequest } from 'ox/tempo'
+ *
+ * const request = TransactionRequest.toRpc({
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('0.01'),
+ * })
+ * ```
+ *
+ * @example
+ * ### Using with a Provider
+ *
+ * You can use {@link ox#Provider.(from:function)} to instantiate an EIP-1193 Provider and
+ * send a transaction to the Wallet using the `eth_sendTransaction` method.
+ *
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { Provider, Value } from 'ox'
+ * import { TransactionRequest } from 'ox/tempo'
+ *
+ * const provider = Provider.from(window.ethereum!)
+ *
+ * const request = TransactionRequest.toRpc({
+ *   feeToken: '0x20c0000000000000000000000000000000000000',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('0.01'),
+ * })
+ *
+ * const hash = await provider.request({ // [!code focus]
+ *   method: 'eth_sendTransaction', // [!code focus]
+ *   params: [request], // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * @param request - The request to convert.
+ * @returns An RPC request.
+ */
+export function toRpc(request: TransactionRequest): Rpc {
+  const request_rpc = ox_TransactionRequest.toRpc(request) as Rpc
+
+  request_rpc.calls = request.calls
+
+  if (typeof request.feeToken !== 'undefined')
+    request_rpc.feeToken = TokenId.toAddress(request.feeToken)
+
+  if (request.calls && request.from) {
+    delete request_rpc.to
+    delete request_rpc.value
+    delete request_rpc.data
+    request_rpc.to = request.from
+    request_rpc.data = Execute.encodeData(request.calls)
+  }
+
+  if (
+    request.calls ||
+    typeof request.feeToken !== 'undefined' ||
+    request.type === 'feeToken'
+  )
+    request_rpc.type = Transaction.toRpcType.feeToken
+
+  return request_rpc
+}
+
+export declare namespace toRpc {
+  export type ErrorType =
+    | Authorization.toRpcList.ErrorType
+    | Hex.fromNumber.ErrorType
+    | Errors.GlobalErrorType
+}

package/src/ox/index.ts

@@ -0,0 +1,4 @@
+export * as TokenId from './TokenId.js'
+export * as TokenRole from './TokenRole.js'
+export * as Transaction from './Transaction.js'
+export * as TransactionEnvelopeFeeToken from './TransactionEnvelopeFeeToken.js'

package/src/prool/Instance.test.ts

@@ -0,0 +1,43 @@
+import type { Instance as prool_Instance } from 'prool/instances'
+import { Instance } from 'tempo.ts/prool'
+import { afterEach, describe, expect, test } from 'vitest'
+
+const instances: prool_Instance[] = []
+
+const tempo = (parameters: Instance.tempo.Parameters = {}) => {
+  const instance = Instance.tempo({ ...parameters, port: 8888 })
+  instances.push(instance)
+  return instance
+}
+
+afterEach(async () => {
+  for (const instance of instances) await instance.stop().catch(() => {})
+})
+
+describe('tempo', () => {
+  test('default', async () => {
+    const messages: string[] = []
+    const stdouts: string[] = []
+
+    const instance = tempo()
+
+    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('[]')
+  })
+})

package/src/prool/Instance.ts

@@ -0,0 +1,190 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { toArgs } from 'prool'
+import { defineInstance } from 'prool/instances'
+import { execa } from 'prool/processes'
+
+/**
+ * Defines a Tempo instance.
+ *
+ * @example
+ * ```ts
+ * const instance = tempo()
+ * await instance.start()
+ * // ...
+ * await instance.stop()
+ * ```
+ */
+export const tempo = defineInstance((parameters: tempo.Parameters = {}) => {
+  const {
+    binary = 'tempo',
+    builder,
+    chain = path.resolve(import.meta.dirname, './internal/chain.json'),
+    consensusConfig = path.resolve(
+      import.meta.dirname,
+      './internal/consensus.toml',
+    ),
+    dev,
+    faucet,
+    ...args
+  } = parameters
+  const { deadline = 3, gaslimit = 3000000000, maxTasks = 8 } = builder ?? {}
+  const { blockTime = '2ms' } = dev ?? {}
+  const {
+    address = '0x20c0000000000000000000000000000000000000',
+    amount = 1000000000000000,
+    privateKey = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+  } = faucet ?? {}
+
+  const name = 'tempo'
+  const process = execa({ name })
+
+  const tmp = `./tmp/${crypto.randomUUID()}`
+
+  return {
+    _internal: {
+      args,
+      get process() {
+        return process._internal.process
+      },
+    },
+    host: args.host ?? 'localhost',
+    name,
+    port: args.port ?? 8545,
+    async start({ port = args.port }, options) {
+      try {
+        fs.rmSync(tmp, { recursive: true })
+      } catch {}
+      fs.mkdirSync(tmp, { recursive: true })
+      return await process.start(
+        ($) =>
+          $`${binary} node --http --dev --engine.disable-precompile-cache --faucet.enabled ${toArgs(
+            {
+              ...args,
+              builder: {
+                deadline,
+                gaslimit,
+                maxTasks,
+              },
+              chain,
+              consensusConfig,
+              datadir: `${tmp}/data`,
+              dev: {
+                blockTime,
+              },
+              faucet: {
+                address,
+                amount,
+                privateKey,
+              },
+              port: port! + 1,
+              http: {
+                addr: '0.0.0.0',
+                port: port!,
+              },
+              ws: {
+                port: port! + 2,
+              },
+              authrpc: {
+                port: port! + 3,
+              },
+            },
+          )}`,
+        {
+          ...options,
+          resolver({ process, reject, resolve }) {
+            process.stdout.on('data', (data) => {
+              const message = data.toString()
+              if (message.includes('shutting down')) reject(message)
+              if (message.includes('RPC HTTP server started')) resolve()
+            })
+            process.stderr.on('data', (data) => {
+              const message = data.toString()
+              reject(message)
+            })
+          },
+        },
+      )
+    },
+    async stop() {
+      try {
+        fs.rmSync(tmp, { recursive: true })
+      } catch {}
+      await process.stop()
+    },
+  }
+})
+
+export declare namespace tempo {
+  export type Parameters = {
+    /**
+     * Path or alias to the Tempo binary.
+     */
+    binary?: string | undefined
+    /**
+     * Builder options.
+     */
+    builder?:
+      | {
+          /**
+           * The deadline for when the payload builder job should resolve.
+           */
+          deadline?: number | undefined
+          /**
+           * Target gas limit for built blocks.
+           */
+          gaslimit?: bigint | undefined
+          /**
+           * Maximum number of tasks to spawn for building a payload.
+           */
+          maxTasks?: number | undefined
+        }
+      | undefined
+    /**
+     * Chain this node is running.
+     */
+    chain?: string | undefined
+    /**
+     * Consensus configuration for this node.
+     */
+    consensusConfig?: string | undefined
+    /**
+     * Development options.
+     */
+    dev?:
+      | {
+          /**
+           * Interval between blocks.
+           */
+          blockTime?: number | undefined
+        }
+      | undefined
+    /**
+     * Faucet options.
+     */
+    faucet?:
+      | {
+          /**
+           * Target token address for the faucet to be funding with
+           */
+          address?: string | undefined
+          /**
+           * Amount for each faucet funding transaction
+           */
+          amount?: bigint | undefined
+          /**
+           * Faucet funding mnemonic
+           */
+          privateKey?: string | undefined
+        }
+      | undefined
+    /**
+     * Host the server will listen on.
+     */
+    host?: string | undefined
+    /**
+     * Port the server will listen on.
+     */
+    port?: number | undefined
+  }
+}

package/src/prool/index.ts

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