tempo.ts 0.5.3 → 0.6.0

package/src/ox/e2e.test.ts

@@ -13,6 +13,7 @@ import { client, fundAddress } from '../../test/viem/config.js'
 import { SignatureEnvelope } from './index.js'
 import * as Transaction from './Transaction.js'
 import * as TransactionEnvelopeAA from './TransactionEnvelopeAA.js'
+import * as TransactionReceipt from './TransactionReceipt.js'
 
 test('behavior: default (secp256k1)', async () => {
   const privateKey = Secp256k1.randomPrivateKey()
@@ -50,18 +51,21 @@ test('behavior: default (secp256k1)', async () => {
     signature: SignatureEnvelope.from(signature),
   })
 
-  const receipt = await client.request({
-    method: 'eth_sendRawTransactionSync',
-    params: [serialized_signed],
-  })
-
+  const receipt = (await client
+    .request({
+      method: 'eth_sendRawTransactionSync',
+      params: [serialized_signed],
+    })
+    .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
   expect(receipt).toBeDefined()
 
   {
-    const response = await client.request({
-      method: 'eth_getTransactionByHash',
-      params: [receipt.transactionHash],
-    })
+    const response = await client
+      .request({
+        method: 'eth_getTransactionByHash',
+        params: [receipt.transactionHash],
+      })
+      .then((tx) => Transaction.fromRpc(tx as any))
     if (!response) throw new Error()
 
     const {
@@ -69,14 +73,13 @@ test('behavior: default (secp256k1)', async () => {
       blockHash,
       chainId,
       hash,
-      // @ts-expect-error
       feeToken: _,
       from,
       nonce,
       maxFeePerGas,
       maxPriorityFeePerGas,
-      // @ts-expect-error
       signature,
+      transactionIndex,
       ...rest
     } = response
 
@@ -89,26 +92,27 @@ test('behavior: default (secp256k1)', async () => {
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(nonce).toBeDefined()
     expect(signature).toBeDefined()
+    expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
         "aaAuthorizationList": [],
         "accessList": [],
         "calls": [
           {
-            "data": null,
-            "input": "0x",
+            "data": "0x",
             "to": "0x0000000000000000000000000000000000000000",
-            "value": "0x0",
+            "value": 0n,
           },
         ],
+        "data": undefined,
         "feePayerSignature": null,
-        "gas": "0x186a0",
-        "gasPrice": "0x4a817c800",
-        "nonceKey": "0x0",
-        "transactionIndex": "0x1",
-        "type": "0x76",
+        "gas": 100000n,
+        "gasPrice": 20000000000n,
+        "nonceKey": 0n,
+        "type": "aa",
         "validAfter": null,
         "validBefore": null,
+        "value": 0n,
       }
     `)
   }
@@ -116,30 +120,34 @@ test('behavior: default (secp256k1)', async () => {
   const {
     blockNumber,
     blockHash,
-    // @ts-expect-error
+    feePayer,
     feeToken: _,
     from,
     logs,
     logsBloom,
     transactionHash,
+    transactionIndex,
     ...rest
   } = receipt
 
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
+  expect(feePayer).toBeDefined()
   expect(from).toBe(address)
   expect(logs).toBeDefined()
   expect(logsBloom).toBeDefined()
   expect(transactionHash).toBe(receipt.transactionHash)
+  expect(transactionIndex).toBeDefined()
   expect(rest).toMatchInlineSnapshot(`
     {
+      "blobGasPrice": undefined,
+      "blobGasUsed": undefined,
       "contractAddress": null,
-      "cumulativeGasUsed": "0x5c30",
-      "effectiveGasPrice": "0x4a817c800",
-      "gasUsed": "0x5c30",
-      "status": "0x1",
+      "cumulativeGasUsed": 23600n,
+      "effectiveGasPrice": 20000000000n,
+      "gasUsed": 23600n,
+      "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
-      "transactionIndex": "0x1",
       "type": "0x76",
     }
   `)
@@ -181,33 +189,36 @@ test('behavior: default (p256)', async () => {
     }),
   })
 
-  const receipt = await client.request({
-    method: 'eth_sendRawTransactionSync',
-    params: [serialized_signed],
-  })
+  const receipt = (await client
+    .request({
+      method: 'eth_sendRawTransactionSync',
+      params: [serialized_signed],
+    })
+    .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
 
   expect(receipt).toBeDefined()
 
   {
-    const response = await client.request({
-      method: 'eth_getTransactionByHash',
-      params: [receipt.transactionHash],
-    })
+    const response = await client
+      .request({
+        method: 'eth_getTransactionByHash',
+        params: [receipt.transactionHash],
+      })
+      .then((tx) => Transaction.fromRpc(tx as any))
     if (!response) throw new Error()
 
     const {
       blockNumber,
       blockHash,
       chainId,
-      // @ts-expect-error
       feeToken: _,
       from,
       hash,
       nonce,
       maxFeePerGas,
       maxPriorityFeePerGas,
-      // @ts-expect-error
       signature,
+      transactionIndex,
       ...rest
     } = response
 
@@ -220,26 +231,27 @@ test('behavior: default (p256)', async () => {
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(signature).toBeDefined()
+    expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
         "aaAuthorizationList": [],
         "accessList": [],
         "calls": [
           {
-            "data": null,
-            "input": "0x",
+            "data": "0x",
             "to": "0x0000000000000000000000000000000000000000",
-            "value": "0x0",
+            "value": 0n,
           },
         ],
+        "data": undefined,
         "feePayerSignature": null,
-        "gas": "0x186a0",
-        "gasPrice": "0x4a817c800",
-        "nonceKey": "0x0",
-        "transactionIndex": "0x1",
-        "type": "0x76",
+        "gas": 100000n,
+        "gasPrice": 20000000000n,
+        "nonceKey": 0n,
+        "type": "aa",
         "validAfter": null,
         "validBefore": null,
+        "value": 0n,
       }
     `)
   }
@@ -247,30 +259,34 @@ test('behavior: default (p256)', async () => {
   const {
     blockNumber,
     blockHash,
-    // @ts-expect-error
+    feePayer,
     feeToken: _,
     from,
     logs,
     logsBloom,
     transactionHash,
+    transactionIndex,
     ...rest
   } = receipt
 
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
+  expect(feePayer).toBeDefined()
   expect(from).toBe(address)
   expect(logs).toBeDefined()
   expect(logsBloom).toBeDefined()
   expect(transactionHash).toBe(receipt.transactionHash)
+  expect(transactionIndex).toBeDefined()
   expect(rest).toMatchInlineSnapshot(`
     {
+      "blobGasPrice": undefined,
+      "blobGasUsed": undefined,
       "contractAddress": null,
-      "cumulativeGasUsed": "0x6fb8",
-      "effectiveGasPrice": "0x4a817c800",
-      "gasUsed": "0x6fb8",
-      "status": "0x1",
+      "cumulativeGasUsed": 28600n,
+      "effectiveGasPrice": 20000000000n,
+      "gasUsed": 28600n,
+      "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
-      "transactionIndex": "0x1",
       "type": "0x76",
     }
   `)
@@ -311,18 +327,22 @@ test('behavior: default (p256 - webcrypto)', async () => {
     }),
   })
 
-  const receipt = await client.request({
-    method: 'eth_sendRawTransactionSync',
-    params: [serialized_signed],
-  })
+  const receipt = (await client
+    .request({
+      method: 'eth_sendRawTransactionSync',
+      params: [serialized_signed],
+    })
+    .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
 
   expect(receipt).toBeDefined()
 
   {
-    const response = await client.request({
-      method: 'eth_getTransactionByHash',
-      params: [receipt.transactionHash],
-    })
+    const response = await client
+      .request({
+        method: 'eth_getTransactionByHash',
+        params: [receipt.transactionHash],
+      })
+      .then((tx) => Transaction.fromRpc(tx as any))
     if (!response) throw new Error()
 
     const {
@@ -336,6 +356,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
       maxFeePerGas,
       maxPriorityFeePerGas,
       signature,
+      transactionIndex,
       ...rest
     } = response as any
 
@@ -348,26 +369,27 @@ test('behavior: default (p256 - webcrypto)', async () => {
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(signature).toBeDefined()
+    expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
         "aaAuthorizationList": [],
         "accessList": [],
         "calls": [
           {
-            "data": null,
-            "input": "0x",
+            "data": "0x",
             "to": "0x0000000000000000000000000000000000000000",
-            "value": "0x0",
+            "value": 0n,
           },
         ],
+        "data": undefined,
         "feePayerSignature": null,
-        "gas": "0x186a0",
-        "gasPrice": "0x4a817c800",
-        "nonceKey": "0x0",
-        "transactionIndex": "0x1",
-        "type": "0x76",
+        "gas": 100000n,
+        "gasPrice": 20000000000n,
+        "nonceKey": 0n,
+        "type": "aa",
         "validAfter": null,
         "validBefore": null,
+        "value": 0n,
       }
     `)
   }
@@ -375,30 +397,34 @@ test('behavior: default (p256 - webcrypto)', async () => {
   const {
     blockNumber,
     blockHash,
-    // @ts-expect-error
+    feePayer,
     feeToken: _,
     from,
     logs,
     logsBloom,
     transactionHash,
+    transactionIndex,
     ...rest
   } = receipt
 
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
+  expect(feePayer).toBeDefined()
   expect(from).toBeDefined()
   expect(logs).toBeDefined()
   expect(logsBloom).toBeDefined()
   expect(transactionHash).toBe(receipt.transactionHash)
+  expect(transactionIndex).toBeDefined()
   expect(rest).toMatchInlineSnapshot(`
     {
+      "blobGasPrice": undefined,
+      "blobGasUsed": undefined,
       "contractAddress": null,
-      "cumulativeGasUsed": "0x6fb8",
-      "effectiveGasPrice": "0x4a817c800",
-      "gasUsed": "0x6fb8",
-      "status": "0x1",
+      "cumulativeGasUsed": 28600n,
+      "effectiveGasPrice": 20000000000n,
+      "gasUsed": 28600n,
+      "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
-      "transactionIndex": "0x1",
       "type": "0x76",
     }
   `)
@@ -446,32 +472,35 @@ test('behavior: default (webauthn)', async () => {
     }),
   })
 
-  const receipt = await client.request({
-    method: 'eth_sendRawTransactionSync',
-    params: [serialized_signed],
-  })
+  const receipt = (await client
+    .request({
+      method: 'eth_sendRawTransactionSync',
+      params: [serialized_signed],
+    })
+    .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
 
   expect(receipt).toBeDefined()
 
   {
-    const response = await client.request({
-      method: 'eth_getTransactionByHash',
-      params: [receipt.transactionHash],
-    })
+    const response = await client
+      .request({
+        method: 'eth_getTransactionByHash',
+        params: [receipt.transactionHash],
+      })
+      .then((tx) => Transaction.fromRpc(tx as any))
     if (!response) throw new Error()
 
     const {
       blockNumber,
       blockHash,
       chainId,
-      // @ts-expect-error
       feeToken: _,
       from,
       hash,
       nonce,
       maxFeePerGas,
       maxPriorityFeePerGas,
-      // @ts-expect-error
+      transactionIndex,
       signature,
       ...rest
     } = response
@@ -485,26 +514,27 @@ test('behavior: default (webauthn)', async () => {
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(signature).toBeDefined()
+    expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
         "aaAuthorizationList": [],
         "accessList": [],
         "calls": [
           {
-            "data": null,
-            "input": "0x",
+            "data": "0x",
             "to": "0x0000000000000000000000000000000000000000",
-            "value": "0x0",
+            "value": 0n,
           },
         ],
+        "data": undefined,
         "feePayerSignature": null,
-        "gas": "0x186a0",
-        "gasPrice": "0x4a817c800",
-        "nonceKey": "0x0",
-        "transactionIndex": "0x1",
-        "type": "0x76",
+        "gas": 100000n,
+        "gasPrice": 20000000000n,
+        "nonceKey": 0n,
+        "type": "aa",
         "validAfter": null,
         "validBefore": null,
+        "value": 0n,
       }
     `)
   }
@@ -512,30 +542,35 @@ test('behavior: default (webauthn)', async () => {
   const {
     blockNumber,
     blockHash,
-    // @ts-expect-error
+    cumulativeGasUsed,
+    feePayer,
     feeToken: _,
     from,
     logs,
     logsBloom,
     transactionHash,
+    transactionIndex,
     ...rest
   } = receipt
 
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
+  expect(cumulativeGasUsed).toBeDefined()
+  expect(feePayer).toBeDefined()
   expect(from).toBe(address)
   expect(logs).toBeDefined()
   expect(logsBloom).toBeDefined()
   expect(transactionHash).toBe(receipt.transactionHash)
+  expect(transactionIndex).toBeDefined()
   expect(rest).toMatchInlineSnapshot(`
     {
+      "blobGasPrice": undefined,
+      "blobGasUsed": undefined,
       "contractAddress": null,
-      "cumulativeGasUsed": "0x79e8",
-      "effectiveGasPrice": "0x4a817c800",
-      "gasUsed": "0x79e8",
-      "status": "0x1",
+      "effectiveGasPrice": 20000000000n,
+      "gasUsed": 31208n,
+      "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
-      "transactionIndex": "0x1",
       "type": "0x76",
     }
   `)
@@ -607,16 +642,18 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
     },
   )
 
-  const receipt = await client.request({
-    method: 'eth_sendRawTransactionSync',
-    params: [serialized_signed],
-  })
+  const receipt = (await client
+    .request({
+      method: 'eth_sendRawTransactionSync',
+      params: [serialized_signed],
+    })
+    .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
 
   {
     const {
       blockNumber,
       blockHash,
-      // @ts-expect-error
+      feePayer,
       feeToken: _,
       from,
       logs,
@@ -628,6 +665,7 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
 
     expect(blockNumber).toBeDefined()
     expect(blockHash).toBeDefined()
+    expect(feePayer).toBe(feePayerAddress)
     expect(from).toBe(senderAddress)
     expect(logs).toBeDefined()
     expect(logsBloom).toBeDefined()
@@ -635,25 +673,26 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
     expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
+        "blobGasPrice": undefined,
+        "blobGasUsed": undefined,
         "contractAddress": null,
-        "cumulativeGasUsed": "0x5c30",
-        "effectiveGasPrice": "0x4a817c800",
-        "gasUsed": "0x5c30",
-        "status": "0x1",
+        "cumulativeGasUsed": 23600n,
+        "effectiveGasPrice": 20000000000n,
+        "gasUsed": 23600n,
+        "status": "success",
         "to": "0x0000000000000000000000000000000000000000",
         "type": "0x76",
       }
     `)
   }
 
-  const { feePayer, feeToken, from } = (await client
+  const { feeToken, from } = (await client
     .request({
       method: 'eth_getTransactionByHash',
       params: [receipt.transactionHash],
     })
     .then((tx) => Transaction.fromRpc(tx as any))) as any
 
-  expect(feePayer).toBe(feePayerAddress)
   expect(feeToken).toBe('0x20c0000000000000000000000000000000000001')
   expect(from).toBe(senderAddress)
 })

package/src/prool/Instance.ts

@@ -33,7 +33,7 @@ export const tempo = defineInstance((parameters: tempo.Parameters = {}) => {
   const { deadline = 3, gaslimit = 3000000000, maxTasks = 8 } = builder ?? {}
   const { blockTime = '1sec' } = dev ?? {}
   const {
-    address = '0x20c0000000000000000000000000000000000001',
+    addresses = ['0x20c0000000000000000000000000000000000001'],
     amount = '1000000000000',
     privateKey = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
   } = faucet ?? {}
@@ -89,6 +89,7 @@ export const tempo = defineInstance((parameters: tempo.Parameters = {}) => {
               --engine.disable-precompile-cache \
               --engine.legacy-state-root \
               --faucet.enabled \
+              --faucet.address ${addresses.join(' ')} \
               --http \
               ${toArgs({
                 ...args,
@@ -103,7 +104,6 @@ export const tempo = defineInstance((parameters: tempo.Parameters = {}) => {
                   blockTime,
                 },
                 faucet: {
-                  address,
                   amount,
                   privateKey,
                 },
@@ -201,9 +201,9 @@ export declare namespace tempo {
     faucet?:
       | {
           /**
-           * Target token address for the faucet to be funding with
+           * Target token addresses for the faucet to be funding with
            */
-          address?: string | undefined
+          addresses?: string[] | undefined
           /**
            * Amount for each faucet funding transaction
            */

package/src/viem/Actions/faucet.ts

@@ -87,6 +87,7 @@ export async function fundSync<chain extends Chain | undefined>(
   client: Client<Transport, chain>,
   parameters: fundSync.Parameters,
 ): Promise<fundSync.ReturnValue> {
+  const { timeout = 10_000 } = parameters
   const account = parseAccount(parameters.account)
   const hashes = await client.request<{
     Method: 'tempo_fundAddress'
@@ -97,7 +98,13 @@ export async function fundSync<chain extends Chain | undefined>(
     params: [account.address],
   })
   const receipts = await Promise.all(
-    hashes.map((hash) => waitForTransactionReceipt(client, { hash })),
+    hashes.map((hash) =>
+      waitForTransactionReceipt(client, {
+        hash,
+        checkReplacement: false,
+        timeout,
+      }),
+    ),
   )
   return receipts
 }
@@ -106,6 +113,8 @@ export declare namespace fundSync {
   export type Parameters = {
     /** Account to fund. */
     account: Account | Address
+    /** Timeout. */
+    timeout?: number | undefined
   }
 
   export type ReturnValue = readonly TransactionReceipt[]

package/src/viem/Chain.ts

@@ -1,5 +1,6 @@
 import {
   defineTransaction,
+  defineTransactionReceipt,
   defineTransactionRequest,
   type SerializeTransactionFn,
   type Chain as viem_Chain,
@@ -36,6 +37,9 @@ function config<const chain extends Chain>(chain: chain) {
       transaction: defineTransaction({
         format: Formatters.formatTransaction,
       }),
+      transactionReceipt: defineTransactionReceipt({
+        format: Formatters.formatTransactionReceipt,
+      }),
       transactionRequest: defineTransactionRequest({
         format: (
           ...[request, action]: Parameters<

package/src/viem/Formatters.ts

@@ -5,6 +5,7 @@ import {
   type Chain,
   type Account as viem_Account,
   formatTransaction as viem_formatTransaction,
+  formatTransactionReceipt as viem_formatTransactionReceipt,
   formatTransactionRequest as viem_formatTransactionRequest,
 } from 'viem'
 import { parseAccount } from 'viem/accounts'
@@ -15,14 +16,16 @@ import type { GetFeeTokenParameter } from './internal/types.js'
 import {
   isTempo,
   type Transaction,
+  type TransactionReceipt,
+  type TransactionReceiptRpc,
   type TransactionRequest,
   type TransactionRequestRpc,
   type TransactionRpc,
 } from './Transaction.js'
 
-export const formatTransaction = (
+export function formatTransaction(
   transaction: TransactionRpc,
-): Transaction<bigint, number, boolean> => {
+): Transaction<bigint, number, boolean> {
   if (!isTempo(transaction)) return viem_formatTransaction(transaction as never)
 
   const {
@@ -58,15 +61,21 @@ export const formatTransaction = (
   }
 }
 
+export function formatTransactionReceipt(
+  receipt: TransactionReceiptRpc,
+): TransactionReceipt {
+  return viem_formatTransactionReceipt(receipt as never)
+}
+
 type Request<chain extends Chain | undefined> = UnionOmit<
   TransactionRequest,
   'feeToken'
 > &
   GetFeeTokenParameter<chain> & { account?: viem_Account | undefined }
-export const formatTransactionRequest = <chain extends Chain | undefined>(
+export function formatTransactionRequest<chain extends Chain | undefined>(
   r: Request<chain>,
   action?: string | undefined,
-): TransactionRequestRpc => {
+): TransactionRequestRpc {
   const request = r as Request<chain>
 
   // Convert EIP-1559 transactions to AA transactions.