tempo.ts 0.9.0 → 0.10.0

package/src/ox/Transaction.ts

@@ -1,11 +1,11 @@
 import type * as AccessList from 'ox/AccessList'
 import type * as Address from 'ox/Address'
-import type * as Authorization from 'ox/Authorization'
 import type * as Errors from 'ox/Errors'
 import * as Hex from 'ox/Hex'
 import * as Signature from 'ox/Signature'
 import * as ox_Transaction from 'ox/Transaction'
 import type { Compute, OneOf, UnionCompute } from '../internal/types.js'
+import * as AuthorizationTempo from './AuthorizationTempo.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 import type { Call } from './TransactionEnvelopeTempo.js'
@@ -49,7 +49,7 @@ export type Tempo<
     accessList: AccessList.AccessList
     /** EIP-7702 Authorization list for the transaction. */
     authorizationList?:
-      | Authorization.ListSigned<bigintType, numberType>
+      | AuthorizationTempo.ListSigned<bigintType, numberType>
       | undefined
     /** Array of calls to execute. */
     calls: readonly Call<bigintType>[]
@@ -95,8 +95,9 @@ export type Tempo<
 export type TempoRpc<pending extends boolean = false> = Compute<
   Omit<
     Tempo<pending, Hex.Hex, Hex.Hex, ToRpcType['tempo']>,
-    'calls' | 'keyAuthorization' | 'signature'
+    'authorizationList' | 'calls' | 'keyAuthorization' | 'signature'
   > & {
+    aaAuthorizationList?: AuthorizationTempo.ListRpc | undefined
     calls:
       | readonly {
           input?: Hex.Hex | undefined
@@ -191,6 +192,12 @@ export function fromRpc<
 
   transaction_.type = fromRpcType[transaction.type as keyof typeof fromRpcType]
 
+  if (transaction.aaAuthorizationList) {
+    transaction_.authorizationList = AuthorizationTempo.fromRpcList(
+      transaction.aaAuthorizationList,
+    )
+    delete (transaction_ as any).aaAuthorizationList
+  }
   if (transaction.calls)
     transaction_.calls = transaction.calls.map((call) => ({
       to: call.to,
@@ -285,6 +292,10 @@ export function toRpc<pending extends boolean = false>(
 
   rpc.type = toRpcType[transaction.type as keyof typeof toRpcType]
 
+  if (transaction.authorizationList)
+    rpc.aaAuthorizationList = AuthorizationTempo.toRpcList(
+      transaction.authorizationList as AuthorizationTempo.ListSigned,
+    )
   if (transaction.calls)
     rpc.calls = transaction.calls.map((call) => ({
       to: call.to,

package/src/ox/TransactionEnvelopeTempo.test.ts

@@ -1,5 +1,6 @@
 import { Hex, P256, Rlp, Secp256k1, Value, WebAuthnP256 } from 'ox'
 import { describe, expect, test } from 'vitest'
+import * as AuthorizationTempo from './AuthorizationTempo.js'
 import { SignatureEnvelope } from './index.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
 import * as TransactionEnvelopeTempo from './TransactionEnvelopeTempo.js'
@@ -294,6 +295,58 @@ describe('deserialize', () => {
     )
   })
 
+  test('authorizationList', () => {
+    const authorizationList = [
+      AuthorizationTempo.from({
+        address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+        chainId: 1,
+        nonce: 40n,
+        signature: SignatureEnvelope.from({
+          r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+          s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+          yParity: 0,
+        }),
+      }),
+      AuthorizationTempo.from({
+        address: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+        chainId: 1,
+        nonce: 55n,
+        signature: SignatureEnvelope.from({
+          r: 12345678901234567890n,
+          s: 98765432109876543210n,
+          yParity: 1,
+        }),
+      }),
+    ] as const
+
+    const transaction_authorizationList = TransactionEnvelopeTempo.from({
+      ...transaction,
+      authorizationList,
+    })
+
+    const serialized = TransactionEnvelopeTempo.serialize(
+      transaction_authorizationList,
+    )
+    expect(TransactionEnvelopeTempo.deserialize(serialized)).toEqual(
+      transaction_authorizationList,
+    )
+  })
+
+  test('authorizationList (empty)', () => {
+    const transaction_authorizationList = TransactionEnvelopeTempo.from({
+      ...transaction,
+      authorizationList: [],
+    })
+
+    const serialized = TransactionEnvelopeTempo.serialize(
+      transaction_authorizationList,
+    )
+    const deserialized = TransactionEnvelopeTempo.deserialize(serialized)
+
+    // Empty authorizationList should be undefined after deserialization
+    expect(deserialized.authorizationList).toBeUndefined()
+  })
+
   describe('signature', () => {
     test('secp256k1', () => {
       const signature = Secp256k1.sign({
@@ -496,7 +549,7 @@ describe('deserialize', () => {
         [TransactionEnvelope.InvalidSerializedError: Invalid serialized transaction of type "tempo" was provided.
 
         Serialized Transaction: "0x76c0"
-        Missing Attributes: chainId, maxPriorityFeePerGas, maxFeePerGas, gas, calls, accessList, keyAuthorization, nonceKey, nonce, validBefore, validAfter, feeToken, feePayerSignatureOrSender]
+        Missing Attributes: authorizationList, chainId, maxPriorityFeePerGas, maxFeePerGas, gas, calls, accessList, keyAuthorization, nonceKey, nonce, validBefore, validAfter, feeToken, feePayerSignatureOrSender]
       `)
     })
 
@@ -509,7 +562,7 @@ describe('deserialize', () => {
         [TransactionEnvelope.InvalidSerializedError: Invalid serialized transaction of type "tempo" was provided.
 
         Serialized Transaction: "0x76c20001"
-        Missing Attributes: maxFeePerGas, gas, calls, accessList, keyAuthorization, nonceKey, nonce, validBefore, validAfter, feeToken, feePayerSignatureOrSender]
+        Missing Attributes: authorizationList, maxFeePerGas, gas, calls, accessList, keyAuthorization, nonceKey, nonce, validBefore, validAfter, feeToken, feePayerSignatureOrSender]
       `)
     })
 
@@ -936,6 +989,123 @@ describe('serialize', () => {
     expect(deserialized.keyAuthorization).toEqual(keyAuthorization)
   })
 
+  test('authorizationList (secp256k1)', () => {
+    const authorizationList = [
+      AuthorizationTempo.from({
+        address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+        chainId: 1,
+        nonce: 40n,
+        signature: SignatureEnvelope.from({
+          r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+          s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+          yParity: 0,
+        }),
+      }),
+      AuthorizationTempo.from({
+        address: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+        chainId: 1,
+        nonce: 55n,
+        signature: SignatureEnvelope.from({
+          r: 12345678901234567890n,
+          s: 98765432109876543210n,
+          yParity: 1,
+        }),
+      }),
+    ] as const
+
+    const transaction = TransactionEnvelopeTempo.from({
+      chainId: 1,
+      calls: [{ to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8' }],
+      nonce: 0n,
+      authorizationList,
+    })
+
+    const serialized = TransactionEnvelopeTempo.serialize(transaction)
+    expect(serialized).toMatchInlineSnapshot(
+      `"0x76f8de01808080d8d79470997970c51812dc3a010c7d01b50e0d17dc79c88080c0808080808080f8b8f85a0194be95c3f554e9fc85ec51be69a3d807a0d55bcf2c28b8416e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81bf85a019470997970c51812dc3a010c7d01b50e0d17dc79c837b841000000000000000000000000000000000000000000000000ab54a98ceb1f0ad20000000000000000000000000000000000000000000000055aa54d38e5267eea1c"`,
+    )
+
+    const deserialized = TransactionEnvelopeTempo.deserialize(serialized)
+    expect(deserialized.authorizationList).toEqual(authorizationList)
+  })
+
+  test('authorizationList (multiple types)', () => {
+    const privateKey = P256.randomPrivateKey()
+    const publicKey = P256.getPublicKey({ privateKey })
+
+    const authorization1 = AuthorizationTempo.from({
+      address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+      chainId: 1,
+      nonce: 40n,
+    })
+    const secp256k1Signature = Secp256k1.sign({
+      payload: AuthorizationTempo.getSignPayload(authorization1),
+      privateKey,
+    })
+
+    const authorization2 = AuthorizationTempo.from({
+      address: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+      chainId: 1,
+      nonce: 55n,
+    })
+    const p256Signature = P256.sign({
+      payload: AuthorizationTempo.getSignPayload(authorization2),
+      privateKey,
+    })
+
+    const authorizationList = [
+      AuthorizationTempo.from(authorization1, {
+        signature: SignatureEnvelope.from({ signature: secp256k1Signature }),
+      }),
+      AuthorizationTempo.from(authorization2, {
+        signature: SignatureEnvelope.from({
+          signature: p256Signature,
+          publicKey,
+          prehash: true,
+        }),
+      }),
+    ]
+
+    const transaction = TransactionEnvelopeTempo.from({
+      chainId: 1,
+      calls: [{ to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8' }],
+      nonce: 0n,
+      authorizationList,
+    })
+
+    const serialized = TransactionEnvelopeTempo.serialize(transaction)
+    const deserialized = TransactionEnvelopeTempo.deserialize(serialized)
+
+    expect(deserialized.authorizationList).toHaveLength(2)
+    expect(deserialized.authorizationList?.[0]?.address).toBe(
+      '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+    )
+    expect(deserialized.authorizationList?.[0]?.signature?.type).toBe(
+      'secp256k1',
+    )
+    expect(deserialized.authorizationList?.[1]?.address).toBe(
+      '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+    )
+    expect(deserialized.authorizationList?.[1]?.signature?.type).toBe('p256')
+  })
+
+  test('authorizationList (empty)', () => {
+    const transaction = TransactionEnvelopeTempo.from({
+      chainId: 1,
+      calls: [{ to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8' }],
+      nonce: 0n,
+      authorizationList: [],
+    })
+
+    const serialized = TransactionEnvelopeTempo.serialize(transaction)
+    expect(serialized).toMatchInlineSnapshot(
+      `"0x76e501808080d8d79470997970c51812dc3a010c7d01b50e0d17dc79c88080c0808080808080c0"`,
+    )
+
+    const deserialized = TransactionEnvelopeTempo.deserialize(serialized)
+    expect(deserialized.authorizationList).toBeUndefined()
+  })
+
   describe('with signature', () => {
     test('secp256k1', () => {
       const transaction = TransactionEnvelopeTempo.from({

package/src/ox/TransactionEnvelopeTempo.ts

@@ -1,6 +1,5 @@
 import * as AccessList from 'ox/AccessList'
 import * as Address from 'ox/Address'
-import type * as Authorization from 'ox/Authorization'
 import * as Errors from 'ox/Errors'
 import * as Hash from 'ox/Hash'
 import * as Hex from 'ox/Hex'
@@ -14,6 +13,7 @@ import type {
   PartialBy,
   UnionPartialBy,
 } from '../internal/types.js'
+import * as AuthorizationTempo from './AuthorizationTempo.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 import * as TokenId from './TokenId.js'
@@ -39,9 +39,9 @@ export type TransactionEnvelopeTempo<
   {
     /** EIP-2930 Access List. */
     accessList?: AccessList.AccessList | undefined
-    /** EIP-7702 Authorization list for the transaction. */
+    /** EIP-7702 (Tempo) Authorization list for the transaction. */
     authorizationList?:
-      | Authorization.ListSigned<bigintType, numberType>
+      | AuthorizationTempo.ListSigned<bigintType, numberType>
       | undefined
     /** Array of calls to execute. */
     calls: readonly Call<bigintType>[]
@@ -226,7 +226,7 @@ export function deserialize(
     validAfter,
     feeToken,
     feePayerSignatureOrSender,
-    _authorizationList, // TODO: add
+    authorizationList,
     keyAuthorizationOrSignature,
     maybeSignature,
   ] = transactionArray as readonly Hex.Hex[]
@@ -247,6 +247,7 @@ export function deserialize(
   )
     throw new TransactionEnvelope.InvalidSerializedError({
       attributes: {
+        authorizationList,
         chainId,
         maxPriorityFeePerGas,
         maxFeePerGas,
@@ -307,6 +308,11 @@ export function deserialize(
   if (accessList?.length !== 0 && accessList !== '0x')
     transaction.accessList = AccessList.fromTupleList(accessList as never)
 
+  if (authorizationList?.length !== 0 && authorizationList !== '0x')
+    transaction.authorizationList = AuthorizationTempo.fromTupleList(
+      authorizationList as never,
+    )
+
   if (
     feePayerSignatureOrSender !== '0x' &&
     feePayerSignatureOrSender !== undefined
@@ -543,6 +549,7 @@ export function serialize(
 ): Serialized {
   const {
     accessList,
+    authorizationList,
     calls,
     chainId,
     feeToken,
@@ -561,6 +568,9 @@ export function serialize(
   const accessTupleList = AccessList.toTupleList(accessList)
   const signature = options.signature || envelope.signature
 
+  const authorizationTupleList =
+    AuthorizationTempo.toTupleList(authorizationList)
+
   // Encode calls as RLP list of [to, value, data] tuples
   const callsTupleList = calls.map((call) => [
     call.to ?? '0x',
@@ -594,7 +604,7 @@ export function serialize(
       ? TokenId.toAddress(feeToken)
       : '0x',
     feePayerSignatureOrSender,
-    [], // TODO: authList
+    authorizationTupleList,
     ...(keyAuthorization ? [KeyAuthorization.toTuple(keyAuthorization)] : []),
     ...(signature
       ? [SignatureEnvelope.serialize(SignatureEnvelope.from(signature))]

package/src/ox/TransactionRequest.ts

@@ -1,8 +1,8 @@
-import type * as Authorization from 'ox/Authorization'
 import type * as Errors from 'ox/Errors'
 import * as Hex from 'ox/Hex'
 import * as ox_TransactionRequest from 'ox/TransactionRequest'
 import type { Compute } from '../internal/types.js'
+import * as AuthorizationTempo from './AuthorizationTempo.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
 import * as TokenId from './TokenId.js'
 import * as Transaction from './Transaction.js'
@@ -16,7 +16,13 @@ export type TransactionRequest<
   numberType = number,
   type extends string = string,
 > = Compute<
-  ox_TransactionRequest.TransactionRequest<bigintType, numberType, type> & {
+  Omit<
+    ox_TransactionRequest.TransactionRequest<bigintType, numberType, type>,
+    'authorizationList'
+  > & {
+    authorizationList?:
+      | AuthorizationTempo.ListSigned<bigintType, numberType>
+      | undefined
     calls?: readonly Call<bigintType>[] | undefined
     keyAuthorization?: KeyAuthorization.KeyAuthorization<true> | undefined
     keyData?: Hex.Hex | undefined
@@ -31,8 +37,9 @@ export type TransactionRequest<
 /** RPC representation of a {@link ox#TransactionRequest.TransactionRequest}. */
 export type Rpc = Omit<
   TransactionRequest<Hex.Hex, Hex.Hex, string>,
-  'keyAuthorization'
+  'authorizationList' | 'keyAuthorization'
 > & {
+  authorizationList?: AuthorizationTempo.ListRpc | undefined
   keyAuthorization?: KeyAuthorization.Rpc | undefined
   nonceKey?: Hex.Hex | undefined
 }
@@ -81,8 +88,15 @@ export type Rpc = Omit<
  * @returns An RPC request.
  */
 export function toRpc(request: TransactionRequest): Rpc {
-  const request_rpc = ox_TransactionRequest.toRpc(request) as Rpc
+  const request_rpc = ox_TransactionRequest.toRpc({
+    ...request,
+    authorizationList: undefined,
+  }) as Rpc
 
+  if (request.authorizationList)
+    request_rpc.authorizationList = AuthorizationTempo.toRpcList(
+      request.authorizationList,
+    )
   if (request.calls)
     request_rpc.calls = request.calls.map((call) => ({
       to: call.to ?? '0x',
@@ -127,7 +141,7 @@ export function toRpc(request: TransactionRequest): Rpc {
 
 export declare namespace toRpc {
   export type ErrorType =
-    | Authorization.toRpcList.ErrorType
+    | AuthorizationTempo.toRpcList.ErrorType
     | Hex.fromNumber.ErrorType
     | Errors.GlobalErrorType
 }

package/src/ox/e2e.test.ts

@@ -1,5 +1,6 @@
 import {
   Address,
+  Hex,
   P256,
   Secp256k1,
   Value,
@@ -10,7 +11,11 @@ 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 TransactionEnvelopeTempo from './TransactionEnvelopeTempo.js'
 import * as TransactionReceipt from './TransactionReceipt.js'
@@ -96,8 +101,8 @@ test('behavior: default (secp256k1)', async () => {
     expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
-        "aaAuthorizationList": [],
         "accessList": [],
+        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -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 })
@@ -236,8 +308,8 @@ test('behavior: default (p256)', async () => {
     expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
-        "aaAuthorizationList": [],
         "accessList": [],
+        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -375,8 +447,8 @@ test('behavior: default (p256 - webcrypto)', async () => {
     expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
-        "aaAuthorizationList": [],
         "accessList": [],
+        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -521,8 +593,8 @@ test('behavior: default (webauthn)', async () => {
     expect(transactionIndex).toBeDefined()
     expect(rest).toMatchInlineSnapshot(`
       {
-        "aaAuthorizationList": [],
         "accessList": [],
+        "authorizationList": [],
         "calls": [
           {
             "data": "0x",
@@ -818,8 +890,8 @@ describe('behavior: keyAuthorization', () => {
       expect(transactionIndex).toBeDefined()
       expect(rest).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
+          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -1031,8 +1103,8 @@ describe('behavior: keyAuthorization', () => {
       expect(transactionIndex).toBeDefined()
       expect(rest).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
+          "authorizationList": [],
           "calls": [
             {
               "data": "0x",
@@ -1246,8 +1318,8 @@ describe('behavior: keyAuthorization', () => {
       expect(transactionIndex).toBeDefined()
       expect(rest).toMatchInlineSnapshot(`
         {
-          "aaAuthorizationList": [],
           "accessList": [],
+          "authorizationList": [],
           "calls": [
             {
               "data": "0x",

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'

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

@@ -39,12 +39,6 @@ export function formatTransaction(
   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 }),
@@ -105,13 +99,6 @@ 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: 'tempo',
   } as never)