tempo.ts 0.11.1 → 0.12.1

package/src/viem/Addresses.ts

@@ -1,9 +0,0 @@
-export const accountImplementation =
-  '0x7702c00000000000000000000000000000000000'
-export const accountRegistrar = '0x7702ac0000000000000000000000000000000000'
-export const feeManager = '0xfeec000000000000000000000000000000000000'
-export const nonceManager = '0x4e4F4E4345000000000000000000000000000000'
-export const pathUsd = '0x20c0000000000000000000000000000000000000'
-export const stablecoinExchange = '0xdec0000000000000000000000000000000000000'
-export const tip20Factory = '0x20fc000000000000000000000000000000000000'
-export const tip403Registry = '0x403c000000000000000000000000000000000000'

package/src/viem/Chain.bench-d.ts

@@ -1,12 +0,0 @@
-import { attest } from '@ark/attest'
-import { createClient, http } from 'viem'
-import { test } from 'vitest'
-import { tempo } from '../chains.js'
-
-test('decorator', () => {
-  createClient({
-    chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' }),
-    transport: http('https://cloudflare-eth.com'),
-  })
-  attest.instantiations([62236, 'instantiations'])
-})

package/src/viem/Chain.test.ts

@@ -1,168 +0,0 @@
-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(undefined)
-    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(undefined)
-    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(undefined)
-    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(undefined)
-    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(undefined)
-  })
-
-  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(undefined)
-
-    // 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(undefined)
-  })
-
-  test('behavior: default nonceKey is 0n (falsy)', async () => {
-    const request = await chain.prepareTransactionRequest({} as never)
-    expect((request as any)?.nonceKey).toBe(undefined)
-    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(undefined)
-      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,157 +0,0 @@
-import * as Hex from 'ox/Hex'
-import { TokenId } from 'ox/tempo'
-import {
-  defineTransaction,
-  defineTransactionReceipt,
-  defineTransactionRequest,
-  type SerializeTransactionFn,
-  type Chain as viem_Chain,
-} from 'viem'
-import type { IsUndefined } from '../internal/types.js'
-import * as Formatters from './Formatters.js'
-import * as Transaction from './Transaction.js'
-
-export type Chain<
-  feeToken extends TokenId.TokenIdOrAddress | null | undefined =
-    | TokenId.TokenIdOrAddress
-    | null
-    | undefined,
-> = viem_Chain &
-  (IsUndefined<feeToken> extends true
-    ? {
-        feeToken?: TokenId.TokenIdOrAddress | null | undefined
-      }
-    : {
-        feeToken: feeToken
-      })
-
-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,
-    formatters: {
-      transaction: defineTransaction({
-        exclude: ['aaAuthorizationList' as never],
-        format: Formatters.formatTransaction,
-      }),
-      transactionReceipt: defineTransactionReceipt({
-        format: Formatters.formatTransactionReceipt,
-      }),
-      transactionRequest: defineTransactionRequest({
-        format: (
-          ...[request, action]: Parameters<
-            typeof Formatters.formatTransactionRequest<chain>
-          >
-        ) =>
-          Formatters.formatTransactionRequest<chain>(
-            {
-              ...request,
-
-              // Note: if we have marked the transaction as intended to be paid
-              // by a fee payer (feePayer: true), we will not infer the fee token
-              // as the fee payer will choose their fee token.
-              ...(request.feePayer !== true &&
-              (action === 'estimateGas' ||
-                action === 'fillTransaction' ||
-                action === 'sendTransaction')
-                ? {
-                    feeToken: request.feeToken ?? chain.feeToken,
-                  }
-                : {}),
-            },
-            action,
-          ),
-      }),
-    },
-    async prepareTransactionRequest(r) {
-      const request = r as Transaction.TransactionRequest
-      const nonceKey = (() => {
-        if (typeof request.nonceKey !== 'undefined') return request.nonceKey
-        const nonceKey = nonceKeyManager.get()
-        if (nonceKey === 0n) return undefined
-        return nonceKey
-      })()
-
-      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) =>
-        Transaction.serialize(
-          {
-            ...transaction,
-            // If we have marked the transaction as intended to be paid
-            // by a fee payer (feePayer: true), we will not infer the fee token
-            // as the fee payer will choose their fee token.
-            ...((transaction as { feePayer?: unknown }).feePayer !== true
-              ? {
-                  feeToken:
-                    (transaction as { feeToken?: unknown }).feeToken ??
-                    chain.feeToken ??
-                    undefined,
-                }
-              : {}),
-          } as never,
-          signature,
-        )) as SerializeTransactionFn,
-    },
-    ...chain,
-  } as const satisfies viem_Chain
-}
-
-export function define<const chain extends viem_Chain>(
-  chain: chain,
-): define.ReturnValue<chain> {
-  return Object.assign(
-    (properties = {}) => config({ ...chain, ...properties }),
-    { id: chain.id },
-  ) as never
-}
-
-export { TokenId }
-
-export declare namespace define {
-  type Properties = {
-    /**
-     * Fee token to set for mutable actions.
-     *
-     * Pass `null` to opt-in to protocol preferences.
-     *
-     * @example '0x20c0000000000000000000000000000000000001'
-     * @example 1n
-     * @example null
-     */
-    feeToken?: TokenId.TokenIdOrAddress | null | undefined
-  }
-
-  type ReturnValue<chain extends viem_Chain> = (<
-    properties extends define.Properties | undefined,
-  >(
-    properties?: properties | undefined,
-  ) => ReturnType<typeof config<chain & properties>>) & { id: chain['id'] }
-}

package/src/viem/Decorator.bench-d.ts

@@ -1,11 +0,0 @@
-import { attest } from '@ark/attest'
-import { createClient, http } from 'viem'
-import { test } from 'vitest'
-import { decorator } from './Decorator.js'
-
-test('decorator', () => {
-  createClient({
-    transport: http('https://cloudflare-eth.com'),
-  }).extend(decorator())
-  attest.instantiations([40758, 'instantiations'])
-})

package/src/viem/Decorator.test.ts

@@ -1,39 +0,0 @@
-import { tempoLocal } from 'tempo.ts/chains'
-import { tempoActions } from 'tempo.ts/viem'
-import { createClient, http } from 'viem'
-import { describe, expect, test } from 'vitest'
-
-describe('decorator', () => {
-  const client2 = createClient({
-    chain: tempoLocal({ feeToken: 1n }),
-    transport: http(),
-  }).extend(tempoActions())
-
-  test('default', async () => {
-    expect(Object.keys(client2)).toMatchInlineSnapshot(`
-      [
-        "account",
-        "batch",
-        "cacheTime",
-        "ccipRead",
-        "chain",
-        "key",
-        "name",
-        "pollingInterval",
-        "request",
-        "transport",
-        "type",
-        "uid",
-        "extend",
-        "verifyHash",
-        "amm",
-        "dex",
-        "faucet",
-        "fee",
-        "policy",
-        "reward",
-        "token",
-      ]
-    `)
-  })
-})