tempo.ts 0.8.3 → 0.10.0

package/src/viem/Transaction.ts

@@ -7,10 +7,8 @@ import {
   type AccessList,
   type Account,
   type Address,
-  type AuthorizationList,
   type FeeValuesEIP1559,
   type ParseTransactionReturnType,
-  type SignedAuthorizationList,
   type TransactionBase,
   type TransactionRequestBase,
   type TransactionSerializableBase,
@@ -29,9 +27,10 @@ import {
   type TransactionType as viem_TransactionType,
 } from 'viem'
 import type { ExactPartial, OneOf, PartialBy } from '../internal/types.js'
+import type * as AuthorizationTempo from '../ox/AuthorizationTempo.js'
 import type * as KeyAuthorization from '../ox/KeyAuthorization.js'
 import * as SignatureEnvelope from '../ox/SignatureEnvelope.js'
-import * as TxAA from '../ox/TransactionEnvelopeAA.js'
+import * as TxTempo from '../ox/TransactionEnvelopeTempo.js'
 import type * as ox_TransactionReceipt from '../ox/TransactionReceipt.js'
 
 export type Transaction<
@@ -40,24 +39,25 @@ export type Transaction<
   pending extends boolean = false,
 > = OneOf<
   | viem_Transaction<bigintType, numberType, pending>
-  | TransactionAA<bigintType, numberType, pending>
+  | TransactionTempo<bigintType, numberType, pending>
 >
 export type TransactionRpc<pending extends boolean = false> = OneOf<
   | viem_RpcTransaction<pending>
   | (Omit<
-      TransactionAA<Hex.Hex, Hex.Hex, pending, '0x76'>,
-      'keyAuthorization' | 'signature'
+      TransactionTempo<Hex.Hex, Hex.Hex, pending, '0x76'>,
+      'authorizationList' | 'keyAuthorization' | 'signature'
     > & {
+      authorizationList?: AuthorizationTempo.ListRpc | undefined
       keyAuthorization?: KeyAuthorization.Rpc | null | undefined
       signature: SignatureEnvelope.SignatureEnvelopeRpc
     })
 >
 
-export type TransactionAA<
+export type TransactionTempo<
   quantity = bigint,
   index = number,
   isPending extends boolean = boolean,
-  type = 'aa',
+  type = 'tempo',
 > = PartialBy<
   Omit<
     TransactionBase<quantity, index, isPending>,
@@ -66,8 +66,8 @@ export type TransactionAA<
   'r' | 's' | 'v' | 'yParity'
 > & {
   accessList: AccessList
-  authorizationList?: SignedAuthorizationList | undefined
-  calls: readonly TxAA.Call<quantity>[]
+  authorizationList?: AuthorizationTempo.ListSigned<quantity, index> | undefined
+  calls: readonly TxTempo.Call<quantity>[]
   chainId: index
   feeToken?: Address | undefined
   feePayerSignature?: viem_Signature | undefined
@@ -84,10 +84,10 @@ export type TransactionRequest<
   numberType = number,
 > = OneOf<
   | viem_TransactionRequest<bigintType, numberType>
-  | TransactionRequestAA<bigintType, numberType>
+  | TransactionRequestTempo<bigintType, numberType>
 >
 export type TransactionRequestRpc = OneOf<
-  viem_RpcTransactionRequest | TransactionRequestAA<Hex.Hex, Hex.Hex, '0x76'>
+  viem_RpcTransactionRequest | TransactionRequestTempo<Hex.Hex, Hex.Hex, '0x76'>
 >
 
 export type TransactionReceipt<
@@ -107,16 +107,15 @@ export type TransactionReceiptRpc = TransactionReceipt<
   ox_TransactionReceipt.RpcType
 >
 
-export type TransactionRequestAA<
+export type TransactionRequestTempo<
   quantity = bigint,
   index = number,
-  type = 'aa',
+  type = 'tempo',
 > = TransactionRequestBase<quantity, index, type> &
   ExactPartial<FeeValuesEIP1559<quantity>> & {
     accessList?: AccessList | undefined
-    authorizationList?: AuthorizationList<index, boolean> | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
-    calls?: readonly TxAA.Call<quantity>[] | undefined
+    calls?: readonly TxTempo.Call<quantity>[] | undefined
     feePayer?: Account | true | undefined
     feeToken?: Address | bigint | undefined
     nonceKey?: 'random' | quantity | undefined
@@ -125,17 +124,16 @@ export type TransactionRequestAA<
   }
 
 export type TransactionSerializable = OneOf<
-  viem_TransactionSerializable | TransactionSerializableAA
+  viem_TransactionSerializable | TransactionSerializableTempo
 >
 
-export type TransactionSerializableAA<
+export type TransactionSerializableTempo<
   quantity = bigint,
   index = number,
 > = TransactionSerializableBase<quantity, index> &
   ExactPartial<FeeValuesEIP1559<quantity>> & {
     accessList?: AccessList | undefined
-    authorizationList?: SignedAuthorizationList | undefined
-    calls: readonly TxAA.Call<quantity>[]
+    calls: readonly TxTempo.Call<quantity>[]
     chainId: number
     feeToken?: Address | bigint | undefined
     feePayerSignature?: viem_Signature | null | undefined
@@ -144,16 +142,16 @@ export type TransactionSerializableAA<
     signature?: SignatureEnvelope.SignatureEnvelope<quantity, index> | undefined
     validBefore?: index | undefined
     validAfter?: index | undefined
-    type?: 'aa' | undefined
+    type?: 'tempo' | undefined
   }
 
 export type TransactionSerialized<
   type extends TransactionType = TransactionType,
-> = viem_TransactionSerialized<type> | TransactionSerializedAA
+> = viem_TransactionSerialized<type> | TransactionSerializedTempo
 
-export type TransactionSerializedAA = `0x76${string}`
+export type TransactionSerializedTempo = `0x76${string}`
 
-export type TransactionType = viem_TransactionType | 'aa'
+export type TransactionType = viem_TransactionType | 'tempo'
 
 export function getType(
   transaction: Record<string, unknown>,
@@ -167,7 +165,7 @@ export function getType(
     typeof transaction.validBefore !== 'undefined' ||
     typeof transaction.validAfter !== 'undefined'
   )
-    return 'aa' as never
+    return 'tempo' as never
   if (transaction.type) return transaction.type as never
   return viem_getTransactionType(transaction) as never
 }
@@ -175,7 +173,7 @@ export function getType(
 export function isTempo(transaction: Record<string, unknown>) {
   try {
     const type = getType(transaction)
-    return type === 'aa'
+    return type === 'tempo'
   } catch {
     return false
   }
@@ -191,7 +189,7 @@ export function deserialize<
         ? Hex.slice(serializedTransaction, -26, -6)
         : undefined
     return {
-      ...deserializeAA(serializedTransaction as `0x76${string}`),
+      ...deserializeTempo(serializedTransaction as `0x76${string}`),
       from,
     } as never
   }
@@ -202,8 +200,8 @@ export declare namespace deserialize {
   export type ReturnValue<
     serialized extends
       TransactionSerializedGeneric = TransactionSerializedGeneric,
-  > = serialized extends TransactionSerializedAA
-    ? TransactionSerializableAA
+  > = serialized extends TransactionSerializedTempo
+    ? TransactionSerializableTempo
     : ParseTransactionReturnType<serialized>
 }
 
@@ -236,8 +234,11 @@ export async function serialize(
   }
 
   const type = getType(transaction)
-  if (type === 'aa')
-    return serializeAA(transaction as TransactionSerializableAA, signature)
+  if (type === 'tempo')
+    return serializeTempo(
+      transaction as TransactionSerializableTempo,
+      signature,
+    )
 
   throw new Error('Unsupported transaction type')
 }
@@ -246,19 +247,14 @@ export async function serialize(
 // Internal
 
 /** @internal */
-function deserializeAA(
-  serializedTransaction: TransactionSerializedAA,
-): TransactionSerializableAA {
-  const { authorizationList, feePayerSignature, nonce, ...tx } =
-    TxAA.deserialize(serializedTransaction)
+function deserializeTempo(
+  serializedTransaction: TransactionSerializedTempo,
+): TransactionSerializableTempo {
+  const { feePayerSignature, nonce, ...tx } = TxTempo.deserialize(
+    serializedTransaction,
+  )
   return {
     ...tx,
-    authorizationList: authorizationList?.map((auth) => ({
-      ...auth,
-      nonce: Number(auth.nonce ?? 0n),
-      r: Hex.fromNumber(auth.r, { size: 32 }),
-      s: Hex.fromNumber(auth.s, { size: 32 }),
-    })),
     nonce: Number(nonce ?? 0n),
     feePayerSignature: feePayerSignature
       ? {
@@ -267,12 +263,12 @@ function deserializeAA(
           yParity: feePayerSignature.yParity,
         }
       : feePayerSignature,
-  } satisfies TransactionSerializableAA
+  } satisfies TransactionSerializableTempo
 }
 
 /** @internal */
-async function serializeAA(
-  transaction: TransactionSerializableAA & {
+async function serializeTempo(
+  transaction: TransactionSerializableTempo & {
     feePayer?: Account | true | undefined
     from?: Address | undefined
   },
@@ -290,24 +286,10 @@ async function serializeAA(
     return undefined
   })()
 
-  const {
-    authorizationList,
-    chainId,
-    feePayer,
-    feePayerSignature,
-    nonce,
-    ...rest
-  } = transaction
+  const { chainId, feePayer, feePayerSignature, nonce, ...rest } = transaction
 
   const transaction_ox = {
     ...rest,
-    authorizationList: authorizationList?.map((auth) => ({
-      ...auth,
-      nonce: BigInt(auth.nonce),
-      r: BigInt(auth.r!),
-      s: BigInt(auth.s!),
-      yParity: Number(auth.yParity),
-    })),
     calls: rest.calls?.length
       ? rest.calls
       : [
@@ -327,12 +309,12 @@ async function serializeAA(
       : feePayer
         ? null
         : undefined,
-    type: 'aa',
+    type: 'tempo',
     ...(nonce ? { nonce: BigInt(nonce) } : {}),
-  } satisfies TxAA.TransactionEnvelopeAA
+  } satisfies TxTempo.TransactionEnvelopeTempo
 
   if (signature && typeof transaction.feePayer === 'object') {
-    const tx = TxAA.from(transaction_ox, {
+    const tx = TxTempo.from(transaction_ox, {
       signature,
     })
 
@@ -340,13 +322,13 @@ async function serializeAA(
       if (transaction.from) return transaction.from
       if (signature.type === 'secp256k1')
         return Secp256k1.recoverAddress({
-          payload: TxAA.getSignPayload(tx),
+          payload: TxTempo.getSignPayload(tx),
           signature: signature.signature,
         })
       throw new Error('Unable to extract sender from transaction or signature.')
     })()
 
-    const hash = TxAA.getFeePayerSignPayload(tx, {
+    const hash = TxTempo.getFeePayerSignPayload(tx, {
       sender,
     })
 
@@ -354,13 +336,13 @@ async function serializeAA(
       hash,
     })
 
-    return TxAA.serialize(tx, {
+    return TxTempo.serialize(tx, {
       feePayerSignature: Signature.from(feePayerSignature),
     })
   }
 
   if (feePayer === true) {
-    const serialized = TxAA.serialize(transaction_ox, {
+    const serialized = TxTempo.serialize(transaction_ox, {
       feePayerSignature: null,
       signature,
     })
@@ -372,7 +354,7 @@ async function serializeAA(
     return serialized
   }
 
-  return TxAA.serialize(
+  return TxTempo.serialize(
     // If we have specified a fee payer, the user will not be signing over the fee token.
     // Defer the fee token signing to the fee payer.
     { ...transaction_ox, ...(feePayer ? { feeToken: undefined } : {}) },

package/src/viem/e2e.test.ts

@@ -68,9 +68,8 @@ describe('sendTransaction', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "calls": [
             {
               "data": "0xdeadbeef",
@@ -83,7 +82,7 @@ describe('sendTransaction', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -145,15 +144,14 @@ describe('sendTransaction', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "data": undefined,
           "feePayerSignature": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -210,9 +208,8 @@ describe('sendTransaction', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -224,7 +221,7 @@ describe('sendTransaction', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -325,9 +322,8 @@ describe('sendTransaction', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "calls": [
             {
               "data": "0xdeadbeef",
@@ -340,7 +336,7 @@ describe('sendTransaction', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -410,15 +406,14 @@ describe('sendTransaction', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "data": undefined,
           "feePayerSignature": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -478,9 +473,8 @@ describe('sendTransaction', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -492,7 +486,7 @@ describe('sendTransaction', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -608,9 +602,8 @@ describe('sendTransaction', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "calls": [
             {
               "data": "0xdeadbeef",
@@ -624,7 +617,7 @@ describe('sendTransaction', () => {
           "gas": 29012n,
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -814,9 +807,8 @@ describe('sendTransaction', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "calls": [
             {
               "data": "0xdeadbeef",
@@ -829,7 +821,7 @@ describe('sendTransaction', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -903,15 +895,14 @@ describe('sendTransaction', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "data": undefined,
           "feePayerSignature": undefined,
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -975,9 +966,8 @@ describe('sendTransaction', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -989,7 +979,7 @@ describe('sendTransaction', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -1153,9 +1143,8 @@ describe('signTransaction', () => {
     expect(transactionIndex).toBeDefined()
     expect(transaction2).toMatchInlineSnapshot(`
       {
-        "aaAuthorizationList": [],
         "accessList": [],
-        "authorizationList": undefined,
+        "authorizationList": [],
         "calls": [
           {
             "data": "0xdeadbeef",
@@ -1168,7 +1157,7 @@ describe('signTransaction', () => {
         "gas": 24002n,
         "maxFeePerBlobGas": undefined,
         "to": null,
-        "type": "aa",
+        "type": "tempo",
         "typeHex": "0x76",
         "v": undefined,
         "validAfter": null,
@@ -1326,9 +1315,8 @@ describe('relay', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "calls": [
             {
               "data": "0xe789744400000000000000000000000020c0000000000000000000000000000000000001",
@@ -1340,7 +1328,7 @@ describe('relay', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -1457,9 +1445,8 @@ describe('relay', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "calls": [
             {
               "data": "0xe789744400000000000000000000000020c0000000000000000000000000000000000001",
@@ -1471,7 +1458,7 @@ describe('relay', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,
@@ -1569,9 +1556,8 @@ describe('relay', () => {
       expect(transactionIndex).toBeDefined()
       expect(transaction).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
-          "authorizationList": undefined,
+          "authorizationList": [],
           "calls": [
             {
               "data": "0xe789744400000000000000000000000020c0000000000000000000000000000000000001",
@@ -1583,7 +1569,7 @@ describe('relay', () => {
           "feeToken": "0x20c0000000000000000000000000000000000001",
           "maxFeePerBlobGas": undefined,
           "to": null,
-          "type": "aa",
+          "type": "tempo",
           "typeHex": "0x76",
           "v": undefined,
           "validAfter": null,

package/src/viem/internal/types.ts

@@ -11,7 +11,7 @@ import type {
   UnionPick,
 } from '../../internal/types.js'
 import type * as TokenId from '../../ox/TokenId.js'
-import type { TransactionRequestAA } from '../Transaction.js'
+import type { TransactionRequestTempo } from '../Transaction.js'
 
 export type GetAccountParameter<
   account extends Account | undefined = Account | undefined,
@@ -63,4 +63,4 @@ export type WriteParameters<
   | 'throwOnReceiptRevert'
 > &
   GetFeeTokenParameter<chain> &
-  UnionPick<TransactionRequestAA, 'feePayer'>
+  UnionPick<TransactionRequestTempo, 'feePayer'>