tempo.ts 0.8.3 → 0.10.0

package/src/ox/e2e.test.ts

@@ -1,5 +1,6 @@
 import {
   Address,
+  Hex,
   P256,
   Secp256k1,
   Value,
@@ -10,9 +11,13 @@ import { getTransactionCount } from 'viem/actions'
 import { beforeEach, describe, expect, test } from 'vitest'
 import { chainId } from '../../test/config.js'
 import { client, fundAddress } from '../../test/viem/config.js'
-import { KeyAuthorization, SignatureEnvelope } from './index.js'
+import {
+  AuthorizationTempo,
+  KeyAuthorization,
+  SignatureEnvelope,
+} from './index.js'
 import * as Transaction from './Transaction.js'
-import * as TransactionEnvelopeAA from './TransactionEnvelopeAA.js'
+import * as TransactionEnvelopeTempo from './TransactionEnvelopeTempo.js'
 import * as TransactionReceipt from './TransactionReceipt.js'
 
 test('behavior: default (secp256k1)', async () => {
@@ -28,7 +33,7 @@ test('behavior: default (secp256k1)', async () => {
     blockTag: 'pending',
   })
 
-  const transaction = TransactionEnvelopeAA.from({
+  const transaction = TransactionEnvelopeTempo.from({
     calls: [
       {
         to: '0x0000000000000000000000000000000000000000',
@@ -43,11 +48,11 @@ test('behavior: default (secp256k1)', async () => {
   })
 
   const signature = Secp256k1.sign({
-    payload: TransactionEnvelopeAA.getSignPayload(transaction),
+    payload: TransactionEnvelopeTempo.getSignPayload(transaction),
     privateKey,
   })
 
-  const serialized_signed = TransactionEnvelopeAA.serialize(transaction, {
+  const serialized_signed = TransactionEnvelopeTempo.serialize(transaction, {
     signature: SignatureEnvelope.from(signature),
   })
 
@@ -96,8 +101,8 @@ test('behavior: default (secp256k1)', async () => {
     expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
-        "aaAuthorizationList": [],
         "accessList": [],
+        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -110,7 +115,7 @@ test('behavior: default (secp256k1)', async () => {
         "gas": 100000n,
         "gasPrice": 20000000000n,
         "nonceKey": 0n,
-        "type": "aa",
+        "type": "tempo",
         "validAfter": null,
         "validBefore": null,
         "value": 0n,
@@ -154,6 +159,73 @@ test('behavior: default (secp256k1)', async () => {
   `)
 })
 
+test('behavior: authorizationList (secp256k1)', async () => {
+  const privateKey = Secp256k1.randomPrivateKey()
+  const address = Address.fromPublicKey(Secp256k1.getPublicKey({ privateKey }))
+
+  await fundAddress(client, {
+    address,
+  })
+
+  const nonce = await getTransactionCount(client, {
+    address,
+    blockTag: 'pending',
+  })
+
+  const authorization = AuthorizationTempo.from({
+    address: '0x0000000000000000000000000000000000000001',
+    chainId: 0,
+    nonce: BigInt(nonce + 1),
+  })
+
+  const authorizationSigned = AuthorizationTempo.from(authorization, {
+    signature: SignatureEnvelope.from(
+      Secp256k1.sign({
+        payload: AuthorizationTempo.getSignPayload(authorization),
+        privateKey,
+      }),
+    ),
+  })
+
+  const transaction = TransactionEnvelopeTempo.from({
+    authorizationList: [authorizationSigned],
+    calls: [
+      {
+        to: '0x0000000000000000000000000000000000000000',
+      },
+    ],
+    chainId,
+    feeToken: '0x20c0000000000000000000000000000000000001',
+    nonce: BigInt(nonce),
+    gas: 100_000n,
+    maxFeePerGas: Value.fromGwei('20'),
+    maxPriorityFeePerGas: Value.fromGwei('10'),
+  })
+
+  const signature = Secp256k1.sign({
+    payload: TransactionEnvelopeTempo.getSignPayload(transaction),
+    privateKey,
+  })
+
+  const serialized_signed = TransactionEnvelopeTempo.serialize(transaction, {
+    signature: SignatureEnvelope.from(signature),
+  })
+
+  const receipt = (await client
+    .request({
+      method: 'eth_sendRawTransactionSync',
+      params: [serialized_signed],
+    })
+    .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+  expect(receipt).toBeDefined()
+
+  const code = await client.request({
+    method: 'eth_getCode',
+    params: [address, 'latest'],
+  })
+  expect(Hex.slice(code, 3)).toBe('0x0000000000000000000000000000000000000001')
+})
+
 test('behavior: default (p256)', async () => {
   const privateKey = P256.randomPrivateKey()
   const publicKey = P256.getPublicKey({ privateKey })
@@ -163,7 +235,7 @@ test('behavior: default (p256)', async () => {
     address,
   })
 
-  const transaction = TransactionEnvelopeAA.from({
+  const transaction = TransactionEnvelopeTempo.from({
     calls: [
       {
         to: '0x0000000000000000000000000000000000000000',
@@ -177,12 +249,12 @@ test('behavior: default (p256)', async () => {
   })
 
   const signature = P256.sign({
-    payload: TransactionEnvelopeAA.getSignPayload(transaction),
+    payload: TransactionEnvelopeTempo.getSignPayload(transaction),
     privateKey,
     hash: false,
   })
 
-  const serialized_signed = TransactionEnvelopeAA.serialize(transaction, {
+  const serialized_signed = TransactionEnvelopeTempo.serialize(transaction, {
     signature: SignatureEnvelope.from({
       signature,
       publicKey,
@@ -236,8 +308,8 @@ test('behavior: default (p256)', async () => {
     expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
-        "aaAuthorizationList": [],
         "accessList": [],
+        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -250,7 +322,7 @@ test('behavior: default (p256)', async () => {
         "gas": 100000n,
         "gasPrice": 20000000000n,
         "nonceKey": 0n,
-        "type": "aa",
+        "type": "tempo",
         "validAfter": null,
         "validBefore": null,
         "value": 0n,
@@ -302,7 +374,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
     address,
   })
 
-  const transaction = TransactionEnvelopeAA.from({
+  const transaction = TransactionEnvelopeTempo.from({
     calls: [
       {
         to: '0x0000000000000000000000000000000000000000',
@@ -316,11 +388,11 @@ test('behavior: default (p256 - webcrypto)', async () => {
   })
 
   const signature = await WebCryptoP256.sign({
-    payload: TransactionEnvelopeAA.getSignPayload(transaction),
+    payload: TransactionEnvelopeTempo.getSignPayload(transaction),
     privateKey: keyPair.privateKey,
   })
 
-  const serialized_signed = TransactionEnvelopeAA.serialize(transaction, {
+  const serialized_signed = TransactionEnvelopeTempo.serialize(transaction, {
     signature: SignatureEnvelope.from({
       signature,
       publicKey: keyPair.publicKey,
@@ -375,8 +447,8 @@ test('behavior: default (p256 - webcrypto)', async () => {
     expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
-        "aaAuthorizationList": [],
         "accessList": [],
+        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -389,7 +461,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
         "gas": 100000n,
         "gasPrice": 20000000000n,
         "nonceKey": 0n,
-        "type": "aa",
+        "type": "tempo",
         "validAfter": null,
         "validBefore": null,
         "value": 0n,
@@ -442,7 +514,7 @@ test('behavior: default (webauthn)', async () => {
     address,
   })
 
-  const transaction = TransactionEnvelopeAA.from({
+  const transaction = TransactionEnvelopeTempo.from({
     calls: [
       {
         to: '0x0000000000000000000000000000000000000000',
@@ -456,7 +528,7 @@ test('behavior: default (webauthn)', async () => {
   })
 
   const { metadata, payload } = WebAuthnP256.getSignPayload({
-    challenge: TransactionEnvelopeAA.getSignPayload(transaction),
+    challenge: TransactionEnvelopeTempo.getSignPayload(transaction),
     rpId: 'localhost',
     origin: 'http://localhost',
   })
@@ -467,7 +539,7 @@ test('behavior: default (webauthn)', async () => {
     hash: true,
   })
 
-  const serialized_signed = TransactionEnvelopeAA.serialize(transaction, {
+  const serialized_signed = TransactionEnvelopeTempo.serialize(transaction, {
     signature: SignatureEnvelope.from({
       signature,
       publicKey,
@@ -521,8 +593,8 @@ test('behavior: default (webauthn)', async () => {
     expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
-        "aaAuthorizationList": [],
         "accessList": [],
+        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -535,7 +607,7 @@ test('behavior: default (webauthn)', async () => {
         "gas": 100000n,
         "gasPrice": 20000000000n,
         "nonceKey": 0n,
-        "type": "aa",
+        "type": "tempo",
         "validAfter": null,
         "validBefore": null,
         "value": 0n,
@@ -603,7 +675,7 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
   //////////////////////////////////////////////////////////////////
   // Sender flow
 
-  const transaction = TransactionEnvelopeAA.from({
+  const transaction = TransactionEnvelopeTempo.from({
     calls: [{ to: '0x0000000000000000000000000000000000000000', value: 0n }],
     chainId,
     feePayerSignature: null,
@@ -614,32 +686,32 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
   })
 
   const signature = Secp256k1.sign({
-    payload: TransactionEnvelopeAA.getSignPayload(transaction),
+    payload: TransactionEnvelopeTempo.getSignPayload(transaction),
     // unfunded PK
     privateKey: senderPrivateKey,
   })
 
-  const transaction_signed = TransactionEnvelopeAA.from(transaction, {
+  const transaction_signed = TransactionEnvelopeTempo.from(transaction, {
     signature: SignatureEnvelope.from(signature),
   })
 
   //////////////////////////////////////////////////////////////////
   // Fee payer flow
 
-  const transaction_feePayer = TransactionEnvelopeAA.from({
+  const transaction_feePayer = TransactionEnvelopeTempo.from({
     ...transaction_signed,
     feeToken: '0x20c0000000000000000000000000000000000001',
   })
 
   const feePayerSignature = Secp256k1.sign({
-    payload: TransactionEnvelopeAA.getFeePayerSignPayload(
+    payload: TransactionEnvelopeTempo.getFeePayerSignPayload(
       transaction_feePayer,
       { sender: senderAddress },
     ),
     privateKey: feePayerPrivateKey,
   })
 
-  const serialized_signed = TransactionEnvelopeAA.serialize(
+  const serialized_signed = TransactionEnvelopeTempo.serialize(
     transaction_feePayer,
     {
       feePayerSignature,
@@ -745,7 +817,7 @@ describe('behavior: keyAuthorization', () => {
       blockTag: 'pending',
     })
 
-    const transaction = TransactionEnvelopeAA.from({
+    const transaction = TransactionEnvelopeTempo.from({
       calls: [
         {
           to: '0x0000000000000000000000000000000000000000',
@@ -761,11 +833,11 @@ describe('behavior: keyAuthorization', () => {
     })
 
     const signature = Secp256k1.sign({
-      payload: TransactionEnvelopeAA.getSignPayload(transaction),
+      payload: TransactionEnvelopeTempo.getSignPayload(transaction),
       privateKey: access.privateKey,
     })
 
-    const serialized_signed = TransactionEnvelopeAA.serialize(transaction, {
+    const serialized_signed = TransactionEnvelopeTempo.serialize(transaction, {
       signature: SignatureEnvelope.from({
         userAddress: root.address,
         inner: SignatureEnvelope.from(signature),
@@ -818,8 +890,8 @@ describe('behavior: keyAuthorization', () => {
       expect(transactionIndex).toBeDefined()
       expect(rest).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
+          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -832,7 +904,7 @@ describe('behavior: keyAuthorization', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "gas": 100000n,
           "nonceKey": 0n,
-          "type": "aa",
+          "type": "tempo",
           "validAfter": null,
           "validBefore": null,
           "value": 0n,
@@ -883,7 +955,7 @@ describe('behavior: keyAuthorization', () => {
         blockTag: 'pending',
       })
 
-      const transaction = TransactionEnvelopeAA.from({
+      const transaction = TransactionEnvelopeTempo.from({
         calls: [
           {
             to: '0x0000000000000000000000000000000000000000',
@@ -898,17 +970,20 @@ describe('behavior: keyAuthorization', () => {
       })
 
       const signature = Secp256k1.sign({
-        payload: TransactionEnvelopeAA.getSignPayload(transaction),
+        payload: TransactionEnvelopeTempo.getSignPayload(transaction),
         privateKey: access.privateKey,
       })
 
-      const serialized_signed = TransactionEnvelopeAA.serialize(transaction, {
-        signature: SignatureEnvelope.from({
-          userAddress: root.address,
-          inner: SignatureEnvelope.from(signature),
-          type: 'keychain',
-        }),
-      })
+      const serialized_signed = TransactionEnvelopeTempo.serialize(
+        transaction,
+        {
+          signature: SignatureEnvelope.from({
+            userAddress: root.address,
+            inner: SignatureEnvelope.from(signature),
+            type: 'keychain',
+          }),
+        },
+      )
 
       const receipt = await client.request({
         method: 'eth_sendRawTransactionSync',
@@ -949,7 +1024,7 @@ describe('behavior: keyAuthorization', () => {
       blockTag: 'pending',
     })
 
-    const transaction = TransactionEnvelopeAA.from({
+    const transaction = TransactionEnvelopeTempo.from({
       calls: [
         {
           to: '0x0000000000000000000000000000000000000000',
@@ -965,11 +1040,11 @@ describe('behavior: keyAuthorization', () => {
     })
 
     const signature = P256.sign({
-      payload: TransactionEnvelopeAA.getSignPayload(transaction),
+      payload: TransactionEnvelopeTempo.getSignPayload(transaction),
       privateKey: access.privateKey,
     })
 
-    const serialized_signed = TransactionEnvelopeAA.serialize(transaction, {
+    const serialized_signed = TransactionEnvelopeTempo.serialize(transaction, {
       signature: SignatureEnvelope.from({
         userAddress: root.address,
         inner: SignatureEnvelope.from({
@@ -1028,8 +1103,8 @@ describe('behavior: keyAuthorization', () => {
       expect(transactionIndex).toBeDefined()
       expect(rest).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
+          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -1042,7 +1117,7 @@ describe('behavior: keyAuthorization', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "gas": 100000n,
           "nonceKey": 0n,
-          "type": "aa",
+          "type": "tempo",
           "validAfter": null,
           "validBefore": null,
           "value": 0n,
@@ -1093,7 +1168,7 @@ describe('behavior: keyAuthorization', () => {
         blockTag: 'pending',
       })
 
-      const transaction = TransactionEnvelopeAA.from({
+      const transaction = TransactionEnvelopeTempo.from({
         calls: [
           {
             to: '0x0000000000000000000000000000000000000000',
@@ -1108,22 +1183,25 @@ describe('behavior: keyAuthorization', () => {
       })
 
       const signature = P256.sign({
-        payload: TransactionEnvelopeAA.getSignPayload(transaction),
+        payload: TransactionEnvelopeTempo.getSignPayload(transaction),
         privateKey: access.privateKey,
       })
 
-      const serialized_signed = TransactionEnvelopeAA.serialize(transaction, {
-        signature: SignatureEnvelope.from({
-          userAddress: root.address,
-          inner: SignatureEnvelope.from({
-            prehash: false,
-            publicKey: access.publicKey,
-            signature,
-            type: 'p256',
+      const serialized_signed = TransactionEnvelopeTempo.serialize(
+        transaction,
+        {
+          signature: SignatureEnvelope.from({
+            userAddress: root.address,
+            inner: SignatureEnvelope.from({
+              prehash: false,
+              publicKey: access.publicKey,
+              signature,
+              type: 'p256',
+            }),
+            type: 'keychain',
           }),
-          type: 'keychain',
-        }),
-      })
+        },
+      )
 
       const receipt = await client.request({
         method: 'eth_sendRawTransactionSync',
@@ -1162,7 +1240,7 @@ describe('behavior: keyAuthorization', () => {
       blockTag: 'pending',
     })
 
-    const transaction = TransactionEnvelopeAA.from({
+    const transaction = TransactionEnvelopeTempo.from({
       calls: [
         {
           to: '0x0000000000000000000000000000000000000000',
@@ -1178,11 +1256,11 @@ describe('behavior: keyAuthorization', () => {
     })
 
     const signature = await WebCryptoP256.sign({
-      payload: TransactionEnvelopeAA.getSignPayload(transaction),
+      payload: TransactionEnvelopeTempo.getSignPayload(transaction),
       privateKey: keyPair.privateKey,
     })
 
-    const serialized_signed = TransactionEnvelopeAA.serialize(transaction, {
+    const serialized_signed = TransactionEnvelopeTempo.serialize(transaction, {
       signature: SignatureEnvelope.from({
         userAddress: root.address,
         inner: SignatureEnvelope.from({
@@ -1240,8 +1318,8 @@ describe('behavior: keyAuthorization', () => {
       expect(transactionIndex).toBeDefined()
       expect(rest).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
+          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -1254,7 +1332,7 @@ describe('behavior: keyAuthorization', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "gas": 100000n,
           "nonceKey": 0n,
-          "type": "aa",
+          "type": "tempo",
           "validAfter": null,
           "validBefore": null,
           "value": 0n,
@@ -1269,7 +1347,7 @@ describe('behavior: keyAuthorization', () => {
         blockTag: 'pending',
       })
 
-      const transaction = TransactionEnvelopeAA.from({
+      const transaction = TransactionEnvelopeTempo.from({
         calls: [
           {
             to: '0x0000000000000000000000000000000000000000',
@@ -1284,22 +1362,25 @@ describe('behavior: keyAuthorization', () => {
       })
 
       const signature = await WebCryptoP256.sign({
-        payload: TransactionEnvelopeAA.getSignPayload(transaction),
+        payload: TransactionEnvelopeTempo.getSignPayload(transaction),
         privateKey: keyPair.privateKey,
       })
 
-      const serialized_signed = TransactionEnvelopeAA.serialize(transaction, {
-        signature: SignatureEnvelope.from({
-          userAddress: root.address,
-          inner: SignatureEnvelope.from({
-            prehash: true,
-            publicKey: access.publicKey,
-            signature,
-            type: 'p256',
+      const serialized_signed = TransactionEnvelopeTempo.serialize(
+        transaction,
+        {
+          signature: SignatureEnvelope.from({
+            userAddress: root.address,
+            inner: SignatureEnvelope.from({
+              prehash: true,
+              publicKey: access.publicKey,
+              signature,
+              type: 'p256',
+            }),
+            type: 'keychain',
           }),
-          type: 'keychain',
-        }),
-      })
+        },
+      )
 
       const receipt = await client.request({
         method: 'eth_sendRawTransactionSync',

package/src/ox/index.ts

@@ -1,3 +1,4 @@
+export * as AuthorizationTempo from './AuthorizationTempo.js'
 export * as KeyAuthorization from './KeyAuthorization.js'
 export * as Order from './Order.js'
 export * as OrdersFilters from './OrdersFilters.js'
@@ -9,4 +10,4 @@ export * as Tick from './Tick.js'
 export * as TokenId from './TokenId.js'
 export * as TokenRole from './TokenRole.js'
 export * as Transaction from './Transaction.js'
-export * as TransactionEnvelopeAA from './TransactionEnvelopeAA.js'
+export * as TransactionEnvelopeTempo from './TransactionEnvelopeTempo.js'

package/src/viem/Chain.ts

@@ -55,6 +55,7 @@ function config<const chain extends Chain>(chain: chain) {
     },
     formatters: {
       transaction: defineTransaction({
+        exclude: ['aaAuthorizationList' as never],
         format: Formatters.formatTransaction,
       }),
       transactionReceipt: defineTransactionReceipt({

package/src/viem/Formatters.ts

@@ -34,17 +34,11 @@ export function formatTransaction(
     gasPrice: _,
     nonce,
     ...tx
-  } = ox_Transaction.fromRpc(transaction as never) as ox_Transaction.AA
+  } = ox_Transaction.fromRpc(transaction as never) as ox_Transaction.Tempo
 
   return {
     ...tx,
     accessList: tx.accessList!,
-    authorizationList: tx.authorizationList?.map((auth) => ({
-      ...auth,
-      nonce: Number(auth.nonce),
-      r: Hex.fromNumber(auth.r, { size: 32 }),
-      s: Hex.fromNumber(auth.s, { size: 32 }),
-    })),
     feePayerSignature: feePayerSignature
       ? {
           r: Hex.fromNumber(feePayerSignature.r, { size: 32 }),
@@ -58,7 +52,7 @@ export function formatTransaction(
       ox_Transaction.toRpcType[
         tx.type as keyof typeof ox_Transaction.toRpcType
       ],
-    type: tx.type as 'aa',
+    type: tx.type as 'tempo',
   }
 }
 
@@ -84,8 +78,8 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
     ? parseAccount<Account | viem_Account | Address>(request.account)
     : undefined
 
-  // Convert EIP-1559 transactions to AA transactions.
-  if (request.type === 'eip1559') (request as any).type = 'aa'
+  // Convert EIP-1559 transactions to Tempo transactions.
+  if (request.type === 'eip1559') (request as any).type = 'tempo'
 
   // If the request is not a Tempo transaction, route to Viem formatter.
   if (!isTempo(request))
@@ -105,14 +99,7 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
 
   const rpc = ox_TransactionRequest.toRpc({
     ...request,
-    authorizationList: request.authorizationList?.map((auth) => ({
-      ...auth,
-      nonce: BigInt(auth.nonce),
-      r: BigInt(auth.r!),
-      s: BigInt(auth.s!),
-      yParity: Number(auth.yParity),
-    })),
-    type: 'aa',
+    type: 'tempo',
   } as never)
 
   if (action === 'estimateGas') {
@@ -134,7 +121,7 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
     rpc.type = undefined
   }
 
-  // We rely on `calls` for AA transactions.
+  // We rely on `calls` for Tempo transactions.
   // However, `calls` may not be supported by JSON-RPC accounts (wallets) yet,
   // so we will not remove the `data`, `to`, and `value` fields to make it
   // compatible with the base transaction structure.