mppx 0.4.8 → 0.4.10

package/src/tempo/server/Session.test.ts

@@ -4,7 +4,10 @@ import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import { type Address, createClient, type Hex } from 'viem'
 import { waitForTransactionReceipt } from 'viem/actions'
 import { Addresses } from 'viem/tempo'
-import { beforeAll, beforeEach, describe, expect, test } from 'vitest'
+import { beforeAll, beforeEach, describe, expect, expectTypeOf, test } from 'vp/test'
+import { nodeEnv } from '~test/config.js'
+
+const isLocalnet = nodeEnv === 'localnet'
 import {
   deployEscrow,
   requestCloseChannel,
@@ -13,12 +16,12 @@ import {
   topUpChannel,
 } from '~test/tempo/session.js'
 import { accounts, asset, chain, client, fundAccount, http } from '~test/tempo/viem.js'
+
 import {
   ChannelClosedError,
   ChannelNotFoundError,
   InsufficientBalanceError,
   InvalidSignatureError,
-  VerificationFailedError,
 } from '../../Errors.js'
 import * as Store from '../../Store.js'
 import {
@@ -32,6 +35,7 @@ import { signVoucher } from '../session/Voucher.js'
 import { charge, session, settle } from './Session.js'
 
 const payer = accounts[2]
+const recipientAccount = accounts[0]
 const recipient = accounts[0].address
 const currency = asset
 
@@ -39,12 +43,13 @@ let escrowContract: Address
 let saltCounter = 0
 
 beforeAll(async () => {
+  if (!isLocalnet) return
   escrowContract = await deployEscrow()
   await fundAccount({ address: payer.address, token: Addresses.pathUsd })
   await fundAccount({ address: payer.address, token: currency })
 })
 
-describe('session', () => {
+describe.runIf(isLocalnet)('session', () => {
   let rawStore: Store.Store
   let store: ChannelStore.ChannelStore
 
@@ -57,7 +62,7 @@ describe('session', () => {
     return session({
       store: rawStore,
       getClient: () => client,
-      account: recipient,
+      account: recipientAccount,
       currency,
       escrowContract,
       chainId: chain.id,
@@ -617,7 +622,47 @@ describe('session', () => {
       ).rejects.toThrow(InvalidSignatureError)
     })
 
-    test('rejects exact replay of already-verified voucher (non-increasing)', async () => {
+    test('accepts exact replay of already-verified voucher as idempotent', async () => {
+      const { channelId, serializedTransaction } = await createSignedOpenTransaction(10000000n)
+      const server = createServer()
+      await openServerChannel(server, channelId, serializedTransaction)
+
+      const payload = {
+        action: 'voucher' as const,
+        channelId,
+        cumulativeAmount: '2000000',
+        signature: await signTestVoucher(channelId, 2000000n),
+      }
+
+      await server.verify({
+        credential: {
+          challenge: makeChallenge({ id: 'challenge-2', channelId }),
+          payload,
+        },
+        request: makeRequest(),
+      })
+
+      const channelAfterFirstAccept = await store.getChannel(channelId)
+
+      const replayReceipt = (await server.verify({
+        credential: {
+          challenge: makeChallenge({ id: 'challenge-3', channelId }),
+          payload,
+        },
+        request: makeRequest(),
+      })) as SessionReceipt
+
+      expect(replayReceipt.status).toBe('success')
+      expect(replayReceipt.acceptedCumulative).toBe('2000000')
+      expect(replayReceipt.spent).toBe(channelAfterFirstAccept!.spent.toString())
+      expect(replayReceipt.units).toBe(channelAfterFirstAccept!.units)
+
+      const channelAfterReplay = await store.getChannel(channelId)
+      expect(channelAfterReplay).toEqual(channelAfterFirstAccept)
+      expect(channelAfterReplay!.highestVoucherAmount).toBe(2000000n)
+    })
+
+    test('rejects exact replay with invalid signature', async () => {
       const { channelId, serializedTransaction } = await createSignedOpenTransaction(10000000n)
       const server = createServer()
       await openServerChannel(server, channelId, serializedTransaction)
@@ -641,11 +686,14 @@ describe('session', () => {
         server.verify({
           credential: {
             challenge: makeChallenge({ id: 'challenge-3', channelId }),
-            payload,
+            payload: {
+              ...payload,
+              signature: `0x${'ab'.repeat(65)}` as Hex,
+            },
           },
           request: makeRequest(),
         }),
-      ).rejects.toThrow(VerificationFailedError)
+      ).rejects.toThrow(InvalidSignatureError)
     })
 
     test('rejects replayed voucher at settled amount after on-chain settlement', async () => {
@@ -1190,27 +1238,29 @@ describe('session', () => {
       expect(ch!.finalized).toBe(true)
     })
 
-    test('close throws when client has no account', async () => {
-      const { channelId, serializedTransaction } = await createSignedOpenTransaction(10000000n)
-      const server = createServer({
-        getClient: () => createClient({ chain, transport: http() }),
-      })
-      await openServerChannel(server, channelId, serializedTransaction)
-
-      await expect(
-        server.verify({
-          credential: {
-            challenge: makeChallenge({ id: 'challenge-2', channelId }),
-            payload: {
-              action: 'close' as const,
-              channelId,
-              cumulativeAmount: '1000000',
-              signature: await signTestVoucher(channelId, 1000000n),
-            },
-          },
-          request: makeRequest(),
-        }),
-      ).rejects.toThrow('Cannot close channel: no account available')
+    test('session() throws at initialization when no account provided', () => {
+      expect(() =>
+        session({
+          store: rawStore,
+          getClient: () => client,
+          account: recipient as Address,
+          currency,
+          escrowContract,
+          chainId: chain.id,
+        } as session.Parameters),
+      ).toThrow('tempo.session() requires an `account`')
+    })
+
+    test('session() throws at initialization with no account at all', () => {
+      expect(() =>
+        session({
+          store: rawStore,
+          getClient: () => client,
+          currency,
+          escrowContract,
+          chainId: chain.id,
+        } as session.Parameters),
+      ).toThrow('tempo.session() requires an `account`')
     })
   })
 
@@ -2207,6 +2257,7 @@ describe('monotonicity and TOCTOU (unit tests)', () => {
 })
 
 describe('session default currency resolution', () => {
+  const mockAccount = accounts[0]
   const mockClient = createClient({ transport: http('http://localhost:1') })
   const mockMainnetClient = createClient({
     chain: {
@@ -2231,7 +2282,7 @@ describe('session default currency resolution', () => {
     const server = session({
       store: Store.memory(),
       getClient: () => mockClient,
-      account: '0x0000000000000000000000000000000000000001',
+      account: mockAccount,
       escrowContract: '0x0000000000000000000000000000000000000002',
     } as session.Parameters)
     expect(server.defaults?.currency).toBe('0x20C000000000000000000000b9537d11c60E8b50')
@@ -2241,7 +2292,7 @@ describe('session default currency resolution', () => {
     const server = session({
       store: Store.memory(),
       getClient: () => mockClient,
-      account: '0x0000000000000000000000000000000000000001',
+      account: mockAccount,
       escrowContract: '0x0000000000000000000000000000000000000002',
       testnet: true,
     } as session.Parameters)
@@ -2252,7 +2303,7 @@ describe('session default currency resolution', () => {
     const server = session({
       store: Store.memory(),
       getClient: () => mockClient,
-      account: '0x0000000000000000000000000000000000000001',
+      account: mockAccount,
       escrowContract: '0x0000000000000000000000000000000000000002',
       chainId: 69420,
     } as session.Parameters)
@@ -2263,7 +2314,7 @@ describe('session default currency resolution', () => {
     const server = session({
       store: Store.memory(),
       getClient: () => mockClient,
-      account: '0x0000000000000000000000000000000000000001',
+      account: mockAccount,
       currency: '0xcustom',
       escrowContract: '0x0000000000000000000000000000000000000002',
       chainId: 4217,
@@ -2276,7 +2327,7 @@ describe('session default currency resolution', () => {
     const server = session({
       store: Store.memory(),
       getClient: () => mockClient,
-      account: '0x0000000000000000000000000000000000000001',
+      account: mockAccount,
       escrowContract: '0x0000000000000000000000000000000000000002',
       chainId: 42431,
     } as session.Parameters)
@@ -2289,7 +2340,7 @@ describe('session default currency resolution', () => {
         tempo_server.session({
           store: Store.memory(),
           getClient: () => mockMainnetClient,
-          account: '0x0000000000000000000000000000000000000001',
+          account: mockAccount,
           escrowContract: '0x0000000000000000000000000000000000000002',
           chainId: 4217,
           testnet: false,
@@ -2316,7 +2367,7 @@ describe('session default currency resolution', () => {
         tempo_server.session({
           store: Store.memory(),
           getClient: () => mockTestnetClient,
-          account: '0x0000000000000000000000000000000000000001',
+          account: mockAccount,
           escrowContract: '0x0000000000000000000000000000000000000002',
           testnet: true,
         }),
@@ -2343,7 +2394,7 @@ describe('session default currency resolution', () => {
         tempo_server.session({
           store: Store.memory(),
           getClient: () => mockTestnetClient,
-          account: '0x0000000000000000000000000000000000000001',
+          account: mockAccount,
           escrowContract: '0x0000000000000000000000000000000000000002',
           chainId: 69420,
         }),
@@ -2369,7 +2420,7 @@ describe('session default currency resolution', () => {
         tempo_server.session({
           store: Store.memory(),
           getClient: () => mockClient,
-          account: '0x0000000000000000000000000000000000000001',
+          account: mockAccount,
           currency: '0xcustom',
           escrowContract: '0x0000000000000000000000000000000000000002',
           chainId: 4217,

package/src/tempo/server/Session.ts

@@ -18,6 +18,7 @@ import {
   type Client as viem_Client,
 } from 'viem'
 import { tempo as tempo_chain } from 'viem/chains'
+
 import {
   AmountExceedsDepositError,
   BadRequestError,
@@ -100,6 +101,11 @@ export function session<const parameters extends session.Parameters>(p?: paramet
 
   const { account, recipient, feePayer, feePayerUrl } = Account.resolve(parameters)
 
+  if (!account)
+    throw new Error(
+      'tempo.session() requires an `account` (viem Account, e.g. privateKeyToAccount("0x...")). An address string is not sufficient — the server needs a signing account for on-chain channel close and settlement.',
+    )
+
   const getClient = Client.getResolver({
     chain: tempo_chain,
     feePayerUrl,
@@ -461,19 +467,12 @@ async function verifyAndAcceptVoucher(parameters: {
     throw new AmountExceedsDepositError({ reason: 'voucher amount exceeds on-chain deposit' })
   }
 
-  if (voucher.cumulativeAmount <= channel.highestVoucherAmount) {
+  if (voucher.cumulativeAmount < channel.highestVoucherAmount) {
     throw new VerificationFailedError({
       reason: 'voucher cumulativeAmount must be strictly greater than highest accepted voucher',
     })
   }
 
-  const delta = voucher.cumulativeAmount - channel.highestVoucherAmount
-  if (delta < minVoucherDelta) {
-    throw new DeltaTooSmallError({
-      reason: `voucher delta ${delta} below minimum ${minVoucherDelta}`,
-    })
-  }
-
   const isValid = await verifyVoucher(
     methodDetails.escrowContract,
     methodDetails.chainId,
@@ -485,6 +484,25 @@ async function verifyAndAcceptVoucher(parameters: {
     throw new InvalidSignatureError({ reason: 'invalid voucher signature' })
   }
 
+  // Idempotent replay: equal cumulative voucher is accepted without
+  // advancing channel state or charging additional value.
+  if (voucher.cumulativeAmount === channel.highestVoucherAmount) {
+    return createSessionReceipt({
+      challengeId: challenge.id,
+      channelId,
+      acceptedCumulative: channel.highestVoucherAmount,
+      spent: channel.spent,
+      units: channel.units,
+    })
+  }
+
+  const delta = voucher.cumulativeAmount - channel.highestVoucherAmount
+  if (delta < minVoucherDelta) {
+    throw new DeltaTooSmallError({
+      reason: `voucher delta ${delta} below minimum ${minVoucherDelta}`,
+    })
+  }
+
   const updated = await store.updateChannel(channelId, (current) => {
     if (!current) throw new ChannelNotFoundError({ reason: 'channel not found' })
     if (voucher.cumulativeAmount > current.highestVoucherAmount) {

package/src/tempo/server/Sse.test.ts

@@ -1,5 +1,6 @@
 import type { Address, Hex } from 'viem'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
+
 import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import type * as ChannelStore from '../session/ChannelStore.js'
 import { serve, toResponse } from '../session/Sse.js'

package/src/tempo/server/internal/transport.test.ts

@@ -1,6 +1,7 @@
 import { Challenge, Credential } from 'mppx'
 import type { Address, Hex } from 'viem'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
+
 import * as Store from '../../../Store.js'
 import { chainId, escrowContract as escrowContractDefaults } from '../../internal/defaults.js'
 import * as ChannelStore from '../../session/ChannelStore.js'
@@ -291,6 +292,29 @@ describe('sse transport', () => {
     expect(response.headers.get('Payment-Receipt')).toBeTruthy()
   })
 
+  test('respondReceipt with 204 management response keeps null body and receipt', async () => {
+    const store = memoryStore()
+    await seedChannel(store, 10000000n)
+    const transport = sse({ store })
+
+    transport.getCredential(makeAuthorizedRequest())
+
+    const managementResponse = new Response(null, { status: 204 })
+    const response = transport.respondReceipt({
+      receipt: makeReceipt(),
+      response: managementResponse,
+      challengeId,
+    })
+
+    expect(response.status).toBe(204)
+    expect(await response.text()).toBe('')
+    expect(response.headers.get('Payment-Receipt')).toBeTruthy()
+
+    const channel = await store.getChannel(channelId)
+    expect(channel!.spent).toBe(0n)
+    expect(channel!.units).toBe(0)
+  })
+
   test('poll: true strips waitForUpdate from store', async () => {
     const store = memoryStore()
     ;(store as any).waitForUpdate = async () => {}

package/src/tempo/server/internal/transport.ts

@@ -100,6 +100,13 @@ export function sse(options: sse.Options & { store: ChannelStore.ChannelStore })
       const ctx = contextMap.get(challengeId)
       if (ctx) {
         contextMap.delete(challengeId)
+
+        // Null-body statuses (e.g. 204 from management actions) cannot carry a
+        // response body per Fetch/HTTP semantics.
+        if (isNullBodyStatus(baseResponse.status)) {
+          return baseResponse
+        }
+
         const stream = new ReadableStream<Uint8Array>({
           async start(controller) {
             // deduction completes before consumer reads
@@ -191,3 +198,7 @@ function isAsyncGeneratorFunction(
 function isAsyncIterable(value: unknown): value is AsyncIterable<string> {
   return value !== null && typeof value === 'object' && Symbol.asyncIterator in (value as object)
 }
+
+function isNullBodyStatus(status: number): boolean {
+  return [101, 204, 205, 304].includes(status)
+}

package/src/tempo/session/Chain.test.ts

@@ -1,7 +1,8 @@
 import { type Address, encodeFunctionData, erc20Abi, type Hex } from 'viem'
 import { waitForTransactionReceipt } from 'viem/actions'
 import { Addresses, Transaction } from 'viem/tempo'
-import { beforeAll, describe, expect, test } from 'vitest'
+import { beforeAll, describe, expect, test } from 'vp/test'
+import { nodeEnv } from '~test/config.js'
 import {
   closeChannelOnChain,
   deployEscrow,
@@ -11,6 +12,7 @@ import {
   topUpChannel,
 } from '~test/tempo/session.js'
 import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'
+
 import {
   broadcastOpenTransaction,
   broadcastTopUpTransaction,
@@ -21,6 +23,8 @@ import {
 } from './Chain.js'
 import { signVoucher } from './Voucher.js'
 
+const isLocalnet = nodeEnv === 'localnet'
+
 const UINT128_MAX = 2n ** 128n - 1n
 
 describe('assertUint128 (via settleOnChain / closeOnChain)', () => {
@@ -69,7 +73,7 @@ describe('assertUint128 (via settleOnChain / closeOnChain)', () => {
   })
 })
 
-describe('on-chain', () => {
+describe.runIf(isLocalnet)('on-chain', () => {
   const payer = accounts[2]
   const recipient = accounts[0].address
   const currency = asset

package/src/tempo/session/Chain.ts

@@ -19,6 +19,7 @@ import {
   writeContract,
 } from 'viem/actions'
 import { Transaction } from 'viem/tempo'
+
 import { BadRequestError, ChannelClosedError, VerificationFailedError } from '../../Errors.js'
 import * as TempoAddress from '../internal/address.js'
 import * as defaults from '../internal/defaults.js'
@@ -131,7 +132,7 @@ export async function closeOnChain(
   const resolved = account ?? client.account
   if (!resolved)
     throw new Error(
-      'Cannot close channel: no account available. Provide an `account` in the session config or a `getClient` that returns an account-bearing client.',
+      'Cannot close channel: no account available. Pass an `account` (viem Account, e.g. privateKeyToAccount("0x...")) to tempo.session(), or provide a `getClient` that returns an account-bearing client.',
     )
   const args = [voucher.channelId, voucher.cumulativeAmount, voucher.signature] as const
   if (feePayer) {

package/src/tempo/session/Channel.test.ts

@@ -1,5 +1,6 @@
 import { AbiParameters, Hash } from 'ox'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
+
 import * as Channel from './Channel.js'
 
 describe('computeId', () => {

package/src/tempo/session/ChannelStore.test.ts

@@ -1,5 +1,6 @@
 import type { Address, Hex } from 'viem'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
+
 import * as Store from '../../Store.js'
 import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import * as ChannelStore from './ChannelStore.js'

package/src/tempo/session/ChannelStore.ts

@@ -1,4 +1,5 @@
 import type { Address, Hex } from 'viem'
+
 import type * as Store from '../../Store.js'
 import type { SignedVoucher } from './Types.js'
 

package/src/tempo/session/Receipt.test.ts

@@ -1,5 +1,6 @@
 import type { Hex } from 'viem'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
+
 import {
   createSessionReceipt,
   deserializeSessionReceipt,

package/src/tempo/session/Receipt.ts

@@ -1,5 +1,6 @@
 import { Base64 } from 'ox'
 import type { Hex } from 'viem'
+
 import type { SessionReceipt } from './Types.js'
 
 /**

package/src/tempo/session/Sse.fuzz.test.ts

@@ -0,0 +1,138 @@
+import * as fc from 'fast-check'
+import { describe, expect, test } from 'vp/test'
+
+import * as Sse from './Sse.js'
+
+function createChunkedResponse(chunks: Uint8Array[]): Response {
+  let index = 0
+  const stream = new ReadableStream<Uint8Array>({
+    pull(controller) {
+      if (index < chunks.length) {
+        controller.enqueue(chunks[index]!)
+        index++
+      } else {
+        controller.close()
+      }
+    },
+  })
+  return new Response(stream, {
+    headers: { 'Content-Type': 'text/event-stream' },
+  })
+}
+
+function splitAtPositions(str: string, positions: number[]): Uint8Array[] {
+  const encoder = new TextEncoder()
+  const sorted = [...new Set([0, ...positions, str.length])]
+    .filter((p) => p >= 0 && p <= str.length)
+    .sort((a, b) => a - b)
+  const chunks: Uint8Array[] = []
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const chunk = str.slice(sorted[i], sorted[i + 1])
+    if (chunk.length > 0) chunks.push(encoder.encode(chunk))
+  }
+  return chunks
+}
+
+async function collectData(response: Response): Promise<string[]> {
+  const results: string[] = []
+  for await (const data of Sse.iterateData(response)) {
+    results.push(data)
+  }
+  return results
+}
+
+describe('parseEvent', () => {
+  test('never throws on arbitrary message-type input', () => {
+    fc.assert(
+      fc.property(fc.string(), (input) => {
+        const result = Sse.parseEvent(input)
+        if (result !== null) {
+          expect(result.type).toBe('message')
+          expect(typeof result.data).toBe('string')
+        }
+      }),
+      { numRuns: 10_000 },
+    )
+  })
+
+  test('parseEvent with valid SSE format', () => {
+    const sseMessageArb = fc
+      .array(
+        fc.string().filter((s) => !s.includes('\n')),
+        { minLength: 1, maxLength: 5 },
+      )
+      .map((lines) => lines.map((l) => `data: ${l}`).join('\n'))
+
+    fc.assert(
+      fc.property(sseMessageArb, (raw) => {
+        const result = Sse.parseEvent(raw)
+        expect(result).not.toBeNull()
+        expect(result!.type).toBe('message')
+        const expectedData = raw
+          .split('\n')
+          .map((l) => l.slice(6))
+          .join('\n')
+        expect(result!.data).toBe(expectedData)
+      }),
+      { numRuns: 5_000 },
+    )
+  })
+})
+
+describe('iterateData', () => {
+  const sseEventArb = fc
+    .array(
+      fc.string().filter((s) => !s.includes('\n\n') && !s.includes('\n')),
+      { minLength: 1, maxLength: 3 },
+    )
+    .map((lines) => lines.map((l) => `data: ${l}`).join('\n'))
+
+  const sseStreamArb = fc
+    .array(sseEventArb, { minLength: 1, maxLength: 5 })
+    .map((events) => events.join('\n\n') + '\n\n')
+
+  test('chunk boundary invariance', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        sseStreamArb,
+        fc.array(fc.nat(), { minLength: 1, maxLength: 10 }),
+        async (stream, positions) => {
+          const encoder = new TextEncoder()
+
+          const singleChunk = createChunkedResponse([encoder.encode(stream)])
+          const singleResult = await collectData(singleChunk)
+
+          const boundedPositions = positions.map((p) => p % (stream.length + 1))
+          const chunks = splitAtPositions(stream, boundedPositions)
+          const multiChunk = createChunkedResponse(chunks)
+          const multiResult = await collectData(multiChunk)
+
+          expect(multiResult).toEqual(singleResult)
+        },
+      ),
+      { numRuns: 1_000 },
+    )
+  })
+
+  test('iterateData never throws on arbitrary chunked input', async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        fc.array(fc.uint8Array({ minLength: 1, maxLength: 100 }), {
+          minLength: 1,
+          maxLength: 5,
+        }),
+        async (chunks) => {
+          const response = createChunkedResponse(chunks)
+          const results: string[] = []
+          for await (const data of Sse.iterateData(response)) {
+            results.push(data)
+          }
+          for (const item of results) {
+            expect(typeof item).toBe('string')
+          }
+        },
+      ),
+      { numRuns: 5_000 },
+    )
+  })
+})

package/src/tempo/session/Sse.test.ts

@@ -1,5 +1,6 @@
 import type { Address, Hex } from 'viem'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
+
 import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import type * as ChannelStore from './ChannelStore.js'
 import { formatNeedVoucherEvent, formatReceiptEvent, parseEvent, serve } from './Sse.js'

package/src/tempo/session/Sse.ts

@@ -7,6 +7,7 @@
  * building HTTP responses from the stream.
  */
 import type { Hex } from 'viem'
+
 import * as Credential from '../../Credential.js'
 import * as ChannelStore from './ChannelStore.js'
 import { createSessionReceipt } from './Receipt.js'

package/src/tempo/session/Voucher.test.ts

@@ -1,6 +1,7 @@
 import { createClient, http } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
+
 import { parseVoucherFromPayload, signVoucher, verifyVoucher } from './Voucher.js'
 
 const account = privateKeyToAccount(

package/src/tempo/session/Voucher.ts

@@ -3,6 +3,7 @@ import { SignatureEnvelope } from 'ox/tempo'
 import type { Account, Client, Hex } from 'viem'
 import { recoverTypedDataAddress } from 'viem'
 import { signTypedData } from 'viem/actions'
+
 import * as TempoAddress from '../internal/address.js'
 import type { SignedVoucher, Voucher } from './Types.js'