tempo.ts 0.7.6 → 0.8.0

package/src/viem/Chain.test.ts

@@ -0,0 +1,168 @@
+import {
+  getTransaction,
+  prepareTransactionRequest,
+  sendTransactionSync,
+} from 'viem/actions'
+import { describe, expect, test, vi } from 'vitest'
+import { chain, client, clientWithAccount } from '../../test/viem/config.js'
+
+describe('chain.prepareTransactionRequest', () => {
+  test('behavior: sequential nonce keys for feePayer transactions', async () => {
+    const requests = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    expect((requests[0] as any)?.nonceKey).toBe(0n)
+    expect((requests[1] as any)?.nonceKey).toBeGreaterThan(0n)
+    expect((requests[2] as any)?.nonceKey).toBeGreaterThan(0n)
+  })
+
+  test('behavior: nonce key counter resets after event loop tick', async () => {
+    const requests1 = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    expect((requests1[0] as any)?.nonceKey).toBe(0n)
+    expect((requests1[1] as any)?.nonceKey).toBeGreaterThan(0n)
+
+    // Wait for microtask queue to flush
+    await new Promise((resolve) => queueMicrotask(() => resolve(undefined)))
+
+    const requests2 = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    // Counter should have reset
+    expect((requests2[0] as any)?.nonceKey).toBe(0n)
+    expect((requests2[1] as any)?.nonceKey).toBeGreaterThan(0n)
+  })
+
+  test('behavior: explicit nonceKey overrides counter', async () => {
+    const requests = await Promise.all([
+      chain.prepareTransactionRequest({
+        feePayer: true,
+        nonceKey: 42n,
+      } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({
+        feePayer: true,
+        nonceKey: 100n,
+      } as never),
+    ])
+
+    expect((requests[0] as any)?.nonceKey).toBe(42n)
+    expect((requests[1] as any)?.nonceKey).toBe(0n)
+    expect((requests[2] as any)?.nonceKey).toBe(100n)
+  })
+
+  test('behavior: default nonceKey when feePayer is not true', async () => {
+    const request = await chain.prepareTransactionRequest({} as never)
+    expect((request as any)?.nonceKey).toBe(0n)
+  })
+
+  test('behavior: nonce with sequential nonceKey', async () => {
+    const requests = await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never), // nonceKey: 0n
+      chain.prepareTransactionRequest({ feePayer: true } as never), // nonceKey: 1n
+      chain.prepareTransactionRequest({ feePayer: true } as never), // nonceKey: 2n
+    ])
+
+    // Note: 0n is falsy, so first request has nonce undefined
+    expect((requests[0] as any)?.nonce).toBe(undefined)
+    expect((requests[0] as any)?.nonceKey).toBe(0n)
+
+    // nonceKey >= 1n is truthy, so nonce is 0
+    expect((requests[1] as any)?.nonce).toBe(0)
+    expect((requests[1] as any)?.nonceKey).toBeGreaterThan(0n)
+
+    expect((requests[2] as any)?.nonce).toBe(0)
+    expect((requests[2] as any)?.nonceKey).toBeGreaterThan(0n)
+  })
+
+  test('behavior: explicit nonce is preserved', async () => {
+    const request = await chain.prepareTransactionRequest({
+      feePayer: true,
+      nonce: 123,
+    } as never)
+    expect((request as any)?.nonce).toBe(123)
+    expect((request as any)?.nonceKey).toBe(0n)
+  })
+
+  test('behavior: default nonceKey is 0n (falsy)', async () => {
+    const request = await chain.prepareTransactionRequest({} as never)
+    expect((request as any)?.nonceKey).toBe(0n)
+    expect((request as any)?.nonce).toBe(undefined)
+  })
+
+  test('behavior: resetScheduled optimization - only one microtask scheduled', async () => {
+    const queueMicrotaskSpy = vi.spyOn(globalThis, 'queueMicrotask')
+    const callCountBefore = queueMicrotaskSpy.mock.calls.length
+
+    // Prepare multiple transactions in parallel
+    await Promise.all([
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+      chain.prepareTransactionRequest({ feePayer: true } as never),
+    ])
+
+    const callCountAfter = queueMicrotaskSpy.mock.calls.length
+
+    // Only one microtask should have been scheduled for the reset
+    expect(callCountAfter - callCountBefore).toBe(1)
+
+    queueMicrotaskSpy.mockRestore()
+  })
+
+  describe('e2e', async () => {
+    test('behavior: prepareTransactionRequest', async () => {
+      const [request, request2, request3] = await Promise.all([
+        prepareTransactionRequest(client, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+        prepareTransactionRequest(client, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+        prepareTransactionRequest(client, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+      ])
+      expect(request.nonceKey).toBe(0n)
+      expect(request2.nonceKey).toBeGreaterThan(0n)
+      expect(request3.nonceKey).toBeGreaterThan(0n)
+    })
+
+    test('behavior: sendTransaction', async () => {
+      const receipts = await Promise.all([
+        sendTransactionSync(clientWithAccount, {
+          to: '0x0000000000000000000000000000000000000000',
+        }),
+        sendTransactionSync(clientWithAccount, {
+          to: '0x0000000000000000000000000000000000000001',
+        }),
+        sendTransactionSync(clientWithAccount, {
+          to: '0x0000000000000000000000000000000000000002',
+        }),
+      ])
+      const transactions = await Promise.all([
+        getTransaction(clientWithAccount, {
+          hash: receipts[0].transactionHash,
+        }),
+        getTransaction(clientWithAccount, {
+          hash: receipts[1].transactionHash,
+        }),
+        getTransaction(clientWithAccount, {
+          hash: receipts[2].transactionHash,
+        }),
+      ])
+      expect(transactions[0].nonceKey).toBe(0n)
+      expect(transactions[1].nonceKey).toBeGreaterThan(0n)
+      expect(transactions[2].nonceKey).toBeGreaterThan(0n)
+    })
+  })
+})

package/src/viem/Chain.ts

@@ -1,3 +1,4 @@
+import * as Hex from 'ox/Hex'
 import {
   defineTransaction,
   defineTransactionReceipt,
@@ -25,6 +26,25 @@ export type Chain<
       })
 
 function config<const chain extends Chain>(chain: chain) {
+  const nonceKeyManager = {
+    counter: 0,
+    resetScheduled: false,
+    reset() {
+      this.counter = 0
+      this.resetScheduled = false
+    },
+    get() {
+      if (!this.resetScheduled) {
+        this.resetScheduled = true
+        queueMicrotask(() => this.reset())
+      }
+      const count = this.counter
+      this.counter++
+      if (count === 0) return 0n
+      return Hex.toBigInt(Hex.random(6))
+    },
+  }
+
   return {
     blockTime: 1_000,
     contracts: {
@@ -66,6 +86,22 @@ function config<const chain extends Chain>(chain: chain) {
           ),
       }),
     },
+    async prepareTransactionRequest(r) {
+      const request = r as Transaction.TransactionRequest
+      const nonceKey = (() => {
+        if (typeof request.nonceKey !== 'undefined') return request.nonceKey
+        return nonceKeyManager.get()
+      })()
+
+      const nonce = (() => {
+        if (typeof request.nonce === 'number') return request.nonce
+        // TODO: remove this line once `eth_fillTransaction` supports nonce keys.
+        if (nonceKey) return 0
+        return undefined
+      })()
+
+      return { ...request, nonce, nonceKey } as unknown as typeof r
+    },
     serializers: {
       // TODO: casting to satisfy viem – viem v3 to have more flexible serializer type.
       transaction: ((transaction, signature) =>
@@ -88,7 +124,7 @@ function config<const chain extends Chain>(chain: chain) {
         )) as SerializeTransactionFn,
     },
     ...chain,
-  } as const
+  } as const satisfies viem_Chain
 }
 
 export function define<const chain extends viem_Chain>(

package/src/viem/Formatters.ts

@@ -12,6 +12,7 @@ import { parseAccount } from 'viem/accounts'
 import type { UnionOmit } from '../internal/types.js'
 import * as ox_Transaction from '../ox/Transaction.js'
 import * as ox_TransactionRequest from '../ox/TransactionRequest.js'
+import type { Account } from './Account.js'
 import type { GetFeeTokenParameter } from './internal/types.js'
 import {
   isTempo,
@@ -77,6 +78,7 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   action?: string | undefined,
 ): TransactionRequestRpc {
   const request = r as Request<chain>
+  const account = request.account as Account | undefined
 
   // Convert EIP-1559 transactions to AA transactions.
   if (request.type === 'eip1559') (request as any).type = 'aa'
@@ -91,7 +93,7 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   if (action)
     request.calls = request.calls ?? [
       {
-        to: r.to || undefined,
+        to: r.to || '0x0000000000000000000000000000000000000000',
         value: r.value,
         data: r.data,
       },
@@ -106,11 +108,10 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
       s: BigInt(auth.s!),
       yParity: Number(auth.yParity),
     })),
-    nonce: request.nonce ? BigInt(request.nonce) : undefined,
     type: 'aa',
   } as never)
 
-  if (action === 'estimateGas' || action === 'fillTransaction') {
+  if (action === 'estimateGas') {
     rpc.maxFeePerGas = undefined
     rpc.maxPriorityFeePerGas = undefined
   }
@@ -140,12 +141,12 @@ export function formatTransactionRequest<chain extends Chain | undefined>(
   }
 
   const [keyType, keyData] = (() => {
-    if (!r.account?.source) return [undefined, undefined]
-    if (r.account.source === 'webAuthn')
+    const type = account?.keyType || account?.source
+    if (!type) return [undefined, undefined]
+    if (type === 'webAuthn')
       // TODO: derive correct bytes size of key data based on webauthn create metadata.
       return ['webAuthn', `0x${'ff'.repeat(1400)}`]
-    if (['p256', 'secp256k1'].includes(r.account.source))
-      return [r.account.source, undefined]
+    if (['p256', 'secp256k1'].includes(type)) return [type, undefined]
     return [undefined, undefined]
   })()
 

package/src/viem/Storage.ts

@@ -1,6 +1,8 @@
+import { createStore, del, get, set } from 'idb-keyval'
 import * as Json from 'ox/Json'
 
 import type { MaybePromise } from '../internal/types.js'
+import { normalizeValue } from './internal/utils.js'
 
 export type Storage<
   schema extends Record<string, unknown> = Record<string, unknown>,
@@ -33,6 +35,26 @@ export namespace from {
   }
 }
 
+export function idb<schema extends Record<string, unknown>>() {
+  const store =
+    typeof indexedDB !== 'undefined'
+      ? createStore('tempo.ts', 'store')
+      : undefined
+  return from<schema>({
+    async getItem(name) {
+      const value = await get(name, store)
+      if (value === null) return null
+      return value
+    },
+    async removeItem(name) {
+      await del(name, store)
+    },
+    async setItem(name, value) {
+      await set(name, normalizeValue(value), store)
+    },
+  })
+}
+
 export function localStorage<schema extends Record<string, unknown>>(
   options: localStorage.Options = {},
 ) {

package/src/viem/TokenIds.ts

@@ -1 +1 @@
-export const linkingUsd = 0n
+export const pathUsd = 0n

package/src/viem/Transaction.ts

@@ -29,6 +29,7 @@ import {
   type TransactionType as viem_TransactionType,
 } from 'viem'
 import type { ExactPartial, OneOf, PartialBy } from '../internal/types.js'
+import type * as KeyAuthorization from '../ox/KeyAuthorization.js'
 import * as SignatureEnvelope from '../ox/SignatureEnvelope.js'
 import * as TxAA from '../ox/TransactionEnvelopeAA.js'
 import type * as ox_TransactionReceipt from '../ox/TransactionReceipt.js'
@@ -43,7 +44,11 @@ export type Transaction<
 >
 export type TransactionRpc<pending extends boolean = false> = OneOf<
   | viem_RpcTransaction<pending>
-  | (Omit<TransactionAA<Hex.Hex, Hex.Hex, pending, '0x76'>, 'signature'> & {
+  | (Omit<
+      TransactionAA<Hex.Hex, Hex.Hex, pending, '0x76'>,
+      'keyAuthorization' | 'signature'
+    > & {
+      keyAuthorization?: KeyAuthorization.Rpc | null | undefined
       signature: SignatureEnvelope.SignatureEnvelopeRpc
     })
 >
@@ -66,6 +71,7 @@ export type TransactionAA<
   chainId: index
   feeToken?: Address | undefined
   feePayerSignature?: viem_Signature | undefined
+  keyAuthorization?: KeyAuthorization.Signed<quantity, index> | null | undefined
   nonceKey?: quantity | undefined
   signature: SignatureEnvelope.SignatureEnvelope
   type: type
@@ -109,9 +115,13 @@ export type TransactionRequestAA<
   ExactPartial<FeeValuesEIP1559<quantity>> & {
     accessList?: AccessList | undefined
     authorizationList?: AuthorizationList<index, boolean> | undefined
+    keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
     calls?: readonly TxAA.Call<quantity>[] | undefined
     feePayer?: Account | true | undefined
     feeToken?: Address | bigint | undefined
+    nonceKey?: 'random' | quantity | undefined
+    validBefore?: index | undefined
+    validAfter?: index | undefined
   }
 
 export type TransactionSerializable = OneOf<
@@ -129,6 +139,7 @@ export type TransactionSerializableAA<
     chainId: number
     feeToken?: Address | bigint | undefined
     feePayerSignature?: viem_Signature | null | undefined
+    keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
     nonceKey?: quantity | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<quantity, index> | undefined
     validBefore?: index | undefined
@@ -151,6 +162,7 @@ export function getType(
     typeof transaction.calls !== 'undefined' ||
     typeof transaction.feePayer !== 'undefined' ||
     typeof transaction.feeToken !== 'undefined' ||
+    typeof transaction.nonceKey !== 'undefined' ||
     typeof transaction.signature !== 'undefined' ||
     typeof transaction.validBefore !== 'undefined' ||
     typeof transaction.validAfter !== 'undefined'
@@ -303,7 +315,7 @@ async function serializeAA(
       ? rest.calls
       : [
           {
-            to: rest.to || undefined,
+            to: rest.to || '0x0000000000000000000000000000000000000000',
             value: rest.value,
             data: rest.data,
           },

package/src/viem/WebAuthnP256.ts

@@ -117,15 +117,17 @@ export declare namespace createCredential {
 export async function getCredential(
   parameters: getCredential.Parameters,
 ): Promise<getCredential.ReturnValue> {
-  const { raw } = await WebAuthnP256.sign({
+  const { metadata, raw, signature } = await WebAuthnP256.sign({
     ...parameters,
     challenge: parameters.hash ?? '0x',
   })
   const publicKey = await parameters.getPublicKey(raw)
   return {
     id: raw.id,
+    metadata,
     publicKey,
     raw,
+    signature,
   }
 }
 
@@ -136,5 +138,9 @@ export declare namespace getCredential {
       credential: WebAuthnP256.P256Credential['raw'],
     ) => Promise<Hex.Hex>
   }
-  export type ReturnValue = P256Credential
+
+  export type ReturnValue = WebAuthnP256.sign.ReturnType & {
+    id: string
+    publicKey: Hex.Hex
+  }
 }