mppx 0.8.15 → 0.8.18

package/src/tempo/session/client/Session.test.ts

@@ -1,1355 +0,0 @@
-import { type Address, createClient, custom, decodeFunctionData, encodeFunctionResult } from 'viem'
-import { privateKeyToAccount } from 'viem/accounts'
-import { Account as TempoAccount, Secp256k1, Transaction } from 'viem/tempo'
-import { describe, expect, test, vi } from 'vp/test'
-
-import { serialize as serializeChallenge, type Challenge } from '../../../Challenge.js'
-import * as Fetch from '../../../client/internal/Fetch.js'
-import * as MethodChallenge from '../../../client/internal/MethodChallenge.js'
-import * as Constants from '../../../Constants.js'
-import * as Credential from '../../../Credential.js'
-import * as z from '../../../zod.js'
-import * as AutoSwap from '../../internal/auto-swap.js'
-import * as Methods from '../../Methods.js'
-import * as Channel from '../precompile/Channel.js'
-import { escrowAbi } from '../precompile/escrow.abi.js'
-import { tip20ChannelEscrow } from '../precompile/Protocol.js'
-import * as Types from '../precompile/Protocol.js'
-import * as Voucher from '../precompile/Voucher.js'
-import { channelKey, createChannelStore } from './ChannelStore.js'
-import { session } from './Session.js'
-
-const account = privateKeyToAccount(
-  '0xac0974bec39a17e36ba6a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
-)
-const chainId = 42431
-const client = createClient({
-  account,
-  chain: { id: chainId } as never,
-  transport: custom({
-    async request(args) {
-      if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-      if (args.method === 'eth_getTransactionCount') return '0x0'
-      if (args.method === 'eth_estimateGas') return '0x5208'
-      if (args.method === 'eth_maxPriorityFeePerGas') return '0x1'
-      if (args.method === 'eth_getBlockByNumber') return { baseFeePerGas: '0x1' }
-      if (args.method === 'eth_call')
-        return encodeFunctionResult({
-          abi: escrowAbi,
-          functionName: 'getChannelState',
-          result: { settled: 0n, deposit: 1_000n, closeRequestedAt: 0 },
-        })
-      throw new Error(`unexpected rpc request: ${args.method}`)
-    },
-  }),
-})
-
-const descriptor = {
-  payer: account.address,
-  payee: '0x0000000000000000000000000000000000000002' as Address,
-  operator: '0x0000000000000000000000000000000000000000' as Address,
-  token: '0x0000000000000000000000000000000000000003' as Address,
-  salt: `0x${'11'.repeat(32)}` as `0x${string}`,
-  authorizedSigner: account.address,
-  expiringNonceHash: `0x${'22'.repeat(32)}` as `0x${string}`,
-} satisfies Channel.ChannelDescriptor
-
-type SessionChallenge = Challenge<
-  z.output<typeof Methods.session.schema.request>,
-  typeof Methods.session.intent,
-  typeof Methods.session.name
->
-
-const defaultChannelKey = channelKey({
-  chainId,
-  escrow: tip20ChannelEscrow,
-  payee: descriptor.payee,
-  token: descriptor.token,
-})
-
-function makeChallenge(overrides: Partial<SessionChallenge['request']> = {}): SessionChallenge {
-  const request: SessionChallenge['request'] = {
-    amount: '100',
-    currency: descriptor.token,
-    recipient: descriptor.payee,
-    unitType: 'request',
-    methodDetails: { chainId, escrowContract: tip20ChannelEscrow },
-  }
-
-  return {
-    id: 'test-id',
-    realm: 'test.com',
-    method: 'tempo',
-    intent: 'session',
-    request: Object.assign(request, overrides),
-  }
-}
-
-function makeSessionChallenge(
-  overrides: Partial<SessionChallenge['request']> = {},
-): SessionChallenge {
-  return makeChallenge({
-    ...overrides,
-    methodDetails: {
-      chainId,
-      escrowContract: tip20ChannelEscrow,
-      sessionProtocol: Constants.SessionProtocols.v2,
-      ...overrides.methodDetails,
-    },
-  })
-}
-
-function paymentRequired(challenge: SessionChallenge, headers?: HeadersInit): Response {
-  const responseHeaders = new Headers(headers)
-  responseHeaders.set(Constants.Headers.wwwAuthenticate, serializeChallenge(challenge))
-  return new Response(null, {
-    headers: responseHeaders,
-    status: 402,
-  })
-}
-
-function withSnapshot(
-  payload: Types.SessionCredentialPayload,
-  acceptedCumulative?: string,
-): SessionChallenge {
-  if (payload.action !== 'open') throw new Error('expected open credential')
-  return {
-    ...makeSessionChallenge({
-      methodDetails: {
-        chainId,
-        escrowContract: tip20ChannelEscrow,
-        sessionProtocol: Constants.SessionProtocols.v2,
-        sessionSnapshot: {
-          acceptedCumulative: acceptedCumulative ?? payload.cumulativeAmount,
-          chainId,
-          channelId: payload.channelId,
-          deposit: '1000',
-          descriptor: payload.descriptor,
-          escrow: tip20ChannelEscrow,
-          requiredCumulative: '200',
-          settled: '0',
-          spent: payload.cumulativeAmount,
-        },
-      },
-    }),
-    id: 'replacement-id',
-  }
-}
-
-function makeSessionMethod(
-  channelStore = createChannelStore(),
-  parameters: Partial<session.Parameters> = {},
-) {
-  return session({
-    account,
-    channelStore,
-    decimals: 0,
-    getClient: () => client,
-    maxDeposit: '1000',
-    ...parameters,
-  })
-}
-
-function makeSessionFetch(
-  fetch: typeof globalThis.fetch,
-  channelStore = createChannelStore(),
-  maxPaymentRetries?: number,
-) {
-  return Fetch.from({
-    fetch,
-    maxPaymentRetries,
-    methods: [makeSessionMethod(channelStore)],
-  })
-}
-
-function deserialize(credential: string) {
-  return Credential.deserialize(credential).payload as Types.SessionCredentialPayload
-}
-
-function deserializeCredential(credential: string) {
-  return Credential.deserialize<Types.SessionCredentialPayload>(credential)
-}
-
-function openArgs(payload: Types.SessionCredentialPayload) {
-  if (payload.action !== 'open') throw new Error('expected open payload')
-  const transaction = Transaction.deserialize(payload.transaction)
-  if (!('calls' in transaction)) throw new Error('expected tempo calls')
-  const calls = transaction.calls as readonly { to?: Address; data?: `0x${string}` }[]
-  const call = calls[0]!
-  const decoded = decodeFunctionData({ abi: escrowAbi, data: call.data! })
-  if (decoded.functionName !== 'open') throw new Error('expected open call')
-  return decoded.args
-}
-
-function openDeposit(payload: Types.SessionCredentialPayload): bigint {
-  return openArgs(payload)[3]
-}
-
-function transactionCalls(payload: Types.SessionCredentialPayload) {
-  if (payload.action !== 'open' && payload.action !== 'topUp')
-    throw new Error('expected transaction payload')
-  const transaction = Transaction.deserialize(payload.transaction)
-  if (!('calls' in transaction)) throw new Error('expected tempo calls')
-  return transaction.calls as readonly { to?: Address; data?: `0x${string}` }[]
-}
-
-describe('precompile client session', () => {
-  test('handles only TIP-1034 session challenges', () => {
-    const method = session({ account, getClient: () => client })
-
-    expect(
-      method.canHandleChallenge?.({
-        challenge: makeChallenge({
-          methodDetails: {
-            chainId,
-            escrowContract: tip20ChannelEscrow,
-            sessionProtocol: Constants.SessionProtocols.v2,
-          },
-        }),
-      }),
-    ).toBe(true)
-    expect(method.canHandleChallenge?.({ challenge: makeChallenge() })).toBe(false)
-    expect(
-      method.canHandleChallenge?.({
-        challenge: makeChallenge({
-          methodDetails: {
-            chainId,
-            escrowContract: tip20ChannelEscrow,
-            sessionProtocol: Constants.SessionProtocols.v1,
-          },
-        }),
-      }),
-    ).toBe(false)
-  })
-
-  test('drives paid SSE responses with a supplied credential', async () => {
-    const challenge = makeChallenge({
-      suggestedDeposit: '100',
-      methodDetails: {
-        chainId,
-        escrowContract: tip20ChannelEscrow,
-        sessionProtocol: Constants.SessionProtocols.v2,
-      },
-    })
-    const channelStore = createChannelStore()
-    const parameters = {
-      account,
-      channelStore,
-      decimals: 0,
-      getClient: () => client,
-      maxDeposit: '300',
-    } as const
-    // The response handler must follow the credential selected by `onChallenge`.
-    const externalCredential = await session(parameters).createCredential({
-      challenge,
-      context: {},
-    })
-    let useExternalCredential = true
-    const actions: Types.SessionCredentialPayload['action'][] = []
-    const rawFetch: typeof globalThis.fetch = async (_input, init) => {
-      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
-      if (!authorization)
-        return new Response(null, {
-          status: 402,
-          headers: { [Constants.Headers.wwwAuthenticate]: serializeChallenge(challenge) },
-        })
-
-      const payload = deserialize(authorization)
-      actions.push(payload.action)
-      if (init?.method === 'POST' || payload.action === 'open')
-        return new Response(null, { status: 204 })
-      if (payload.action !== 'voucher') throw new Error('expected voucher')
-
-      const receipt = Types.createSessionReceipt({
-        acceptedCumulative: 200n,
-        challengeId: challenge.id,
-        channelId: payload.channelId,
-        spent: 200n,
-      })
-      return new Response(
-        [
-          Types.formatMessageEvent('first'),
-          Types.formatNeedVoucherEvent({
-            acceptedCumulative: '100',
-            channelId: payload.channelId,
-            deposit: '100',
-            requiredCumulative: '200',
-          }),
-          Types.formatMessageEvent('second'),
-          Types.formatReceiptEvent(receipt),
-        ].join(''),
-        { headers: { 'content-type': 'text/event-stream' } },
-      )
-    }
-    const fetch = Fetch.from({
-      fetch: rawFetch,
-      methods: [session(parameters)],
-      async onChallenge() {
-        if (!useExternalCredential) return undefined
-        useExternalCredential = false
-        return externalCredential
-      },
-    })
-
-    const response = await fetch('https://example.com/stream', {
-      headers: { accept: 'text/event-stream' },
-    })
-
-    expect(response.headers.get('content-type')).toBe('text/event-stream')
-    expect(await response.text()).toBe(
-      `${Types.formatMessageEvent('first')}${Types.formatMessageEvent('second')}`,
-    )
-    expect(actions).toEqual(['open', 'topUp', 'voucher', 'voucher'])
-  })
-
-  test('tops up before signing plain HTTP vouchers through Fetch.from', async () => {
-    const challenge = makeChallenge({
-      suggestedDeposit: '100',
-      methodDetails: {
-        chainId,
-        escrowContract: tip20ChannelEscrow,
-        sessionProtocol: Constants.SessionProtocols.v2,
-      },
-    })
-    const actions: Types.SessionCredentialPayload['action'][] = []
-    const paidRequests: {
-      body: BodyInit | null
-      header: string | null
-      method: string | undefined
-    }[] = []
-    const vouchers: string[] = []
-    let opened: Extract<Types.SessionCredentialPayload, { action: 'open' }> | undefined
-    const paymentRequired = () =>
-      new Response(null, {
-        status: 402,
-        headers: { [Constants.Headers.wwwAuthenticate]: serializeChallenge(challenge) },
-      })
-    const rawFetch: typeof globalThis.fetch = async (_input, init) => {
-      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
-      if (!authorization) return paymentRequired()
-
-      const payload = deserialize(authorization)
-      actions.push(payload.action)
-      if (payload.action === 'open') {
-        opened = payload
-        return new Response('opened')
-      }
-      if (payload.action === 'topUp') return new Response(null, { status: 204 })
-      if (payload.action !== 'voucher' || !opened) throw new Error('expected open voucher')
-      vouchers.push(authorization)
-      if (vouchers.length === 1) return paymentRequired()
-
-      paidRequests.push({
-        body: init?.body ?? null,
-        header: new Headers(init?.headers).get('x-test'),
-        method: init?.method,
-      })
-      return new Response('paid')
-    }
-    const fetch = Fetch.from({
-      fetch: rawFetch,
-      methods: [
-        session({
-          account,
-          decimals: 0,
-          getClient: () => client,
-          maxDeposit: '300',
-        }),
-      ],
-    })
-
-    expect(await (await fetch('https://example.com/resource')).text()).toBe('opened')
-    const response = await fetch('https://example.com/resource', {
-      body: 'request-body',
-      headers: { 'x-test': 'preserved' },
-      method: 'POST',
-    })
-
-    expect(await response.text()).toBe('paid')
-    expect(actions).toEqual(['open', 'topUp', 'voucher', 'voucher'])
-    expect(new Set(vouchers).size).toBe(1)
-    expect(paidRequests).toEqual([{ body: 'request-body', header: 'preserved', method: 'POST' }])
-  })
-
-  test('retries an open rejected by a replacement challenge', async () => {
-    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
-    const replacement = { ...challenge, id: 'replacement-id' }
-    const channelStore = createChannelStore()
-    const actions: Types.SessionCredentialPayload['action'][] = []
-    let paidRequests = 0
-    const fetch = makeSessionFetch(async (_input, init) => {
-      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
-      if (!authorization) return paymentRequired(challenge)
-      actions.push(deserialize(authorization).action)
-      if (++paidRequests === 1) return paymentRequired(replacement)
-      return new Response('rejected', { status: 500 })
-    }, channelStore)
-
-    expect((await fetch('https://example.com/resource')).status).toBe(500)
-    expect(actions).toEqual(['open', 'open'])
-    expect(await channelStore.get(defaultChannelKey)).toBeUndefined()
-  })
-
-  test('retries an open after the paid request throws', async () => {
-    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
-    const actions: Types.SessionCredentialPayload['action'][] = []
-    const fetch = makeSessionFetch(async (_input, init) => {
-      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
-      if (!authorization) return paymentRequired(challenge)
-      actions.push(deserialize(authorization).action)
-      throw new Error('paid request failed')
-    })
-
-    await expect(fetch('https://example.com/resource')).rejects.toThrow('paid request failed')
-    await expect(fetch('https://example.com/resource')).rejects.toThrow('paid request failed')
-    expect(actions).toEqual(['open', 'open'])
-  })
-
-  test('keeps an open acknowledged by a payment receipt', async () => {
-    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
-    const channelStore = createChannelStore()
-    const actions: Types.SessionCredentialPayload['action'][] = []
-    const credentials: string[] = []
-    let paidRequests = 0
-    const fetch = makeSessionFetch(async (_input, init) => {
-      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
-      if (!authorization) return paymentRequired(challenge)
-      const payload = deserialize(authorization)
-      actions.push(payload.action)
-      credentials.push(authorization)
-      if (++paidRequests === 1) return paymentRequired(challenge)
-      if (paidRequests > 2) return new Response('rejected', { status: 500 })
-      return paymentRequired(challenge, {
-        [Constants.Headers.paymentReceipt]: Types.serializeSessionReceipt(
-          Types.createSessionReceipt({
-            acceptedCumulative: 100n,
-            challengeId: challenge.id,
-            channelId: payload.channelId,
-            spent: 100n,
-          }),
-        ),
-      })
-    }, channelStore)
-
-    expect((await fetch('https://example.com/resource')).status).toBe(500)
-    expect(actions).toEqual(['open', 'open', 'voucher'])
-    expect(credentials[0]).toBe(credentials[1])
-    expect(await channelStore.get(defaultChannelKey)).toMatchObject({ opened: true })
-  })
-
-  test.each([
-    [
-      'keeps an open acknowledged by the final session snapshot',
-      undefined,
-      ['open', 'voucher'],
-      true,
-    ],
-    [
-      'fails closed on malformed acknowledgement snapshots without leaking the open lock',
-      'not-a-number',
-      ['open', 'open'],
-      undefined,
-    ],
-  ])('%s', async (_name, acceptedCumulative, expectedActions, expectedOpened) => {
-    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
-    const channelStore = createChannelStore()
-    const actions: Types.SessionCredentialPayload['action'][] = []
-    let paidRequests = 0
-    const fetch = makeSessionFetch(
-      async (_input, init) => {
-        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
-        if (!authorization) return paymentRequired(challenge)
-        const payload = deserialize(authorization)
-        actions.push(payload.action)
-        if (++paidRequests > 1) return new Response('rejected', { status: 500 })
-        return paymentRequired(withSnapshot(payload, acceptedCumulative))
-      },
-      channelStore,
-      1,
-    )
-
-    expect((await fetch('https://example.com/resource')).status).toBe(402)
-    expect((await fetch('https://example.com/resource')).status).toBe(500)
-    expect(actions).toEqual(expectedActions)
-    expect((await channelStore.get(defaultChannelKey))?.opened).toBe(expectedOpened)
-  })
-
-  test('keeps an acknowledged open when challenge ordering throws', async () => {
-    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
-    const channelStore = createChannelStore()
-    const actions: Types.SessionCredentialPayload['action'][] = []
-    let ordered = 0
-    let paidRequests = 0
-    const fetch = Fetch.from({
-      fetch: async (_input, init) => {
-        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
-        if (!authorization) return paymentRequired(challenge)
-        const payload = deserialize(authorization)
-        actions.push(payload.action)
-        if (++paidRequests > 1) return new Response('paid')
-        return paymentRequired(withSnapshot(payload))
-      },
-      methods: [makeSessionMethod(channelStore)],
-      orderChallenges(candidates) {
-        if (++ordered === 2) throw new Error('ordering failed')
-        return candidates
-      },
-    })
-
-    await expect(fetch('https://example.com/resource')).rejects.toThrow('ordering failed')
-    expect(await (await fetch('https://example.com/resource')).text()).toBe('paid')
-    expect(actions).toEqual(['open', 'voucher'])
-    expect(await channelStore.get(defaultChannelKey)).toMatchObject({ opened: true })
-  })
-
-  test('serializes concurrent opens against the committed channel', async () => {
-    const challenge = makeSessionChallenge()
-    const channelStore = createChannelStore()
-    const actions: Types.SessionCredentialPayload['action'][] = []
-    const vouchers: bigint[] = []
-    const firstGate = Promise.withResolvers<void>()
-    const firstRequest = Promise.withResolvers<void>()
-    const waitersReady = Promise.withResolvers<void>()
-    let credentialPlans = 0
-    const fetch = Fetch.from({
-      fetch: async (input, init) => {
-        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
-        if (!authorization) return paymentRequired(challenge)
-        const payload = deserialize(authorization)
-        actions.push(payload.action)
-        if (payload.action === 'topUp') return new Response(null, { status: 204 })
-        if (payload.action === 'voucher') vouchers.push(BigInt(payload.cumulativeAmount))
-        if (input.toString().endsWith('/first')) {
-          firstRequest.resolve()
-          await firstGate.promise
-          return new Response('paid')
-        }
-        return new Response('rejected', { status: 500 })
-      },
-      methods: [
-        makeSessionMethod(channelStore, {
-          resolveAccount() {
-            if (++credentialPlans === 3) waitersReady.resolve()
-            return account
-          },
-        }),
-      ],
-    })
-
-    const first = fetch('https://example.com/first')
-    await firstRequest.promise
-    const second = fetch('https://example.com/second')
-    const third = fetch('https://example.com/third')
-    await waitersReady.promise
-    firstGate.resolve()
-
-    expect((await first).status).toBe(200)
-    expect((await second).status).toBe(500)
-    expect((await third).status).toBe(500)
-    expect(actions).toEqual(['open', 'topUp', 'voucher', 'topUp', 'voucher'])
-    expect(vouchers).toEqual([200n, 300n])
-    expect(await channelStore.get(defaultChannelKey)).toMatchObject({ opened: true })
-  })
-
-  test('replaces a stored channel owned by another account', async () => {
-    const channelStore = createChannelStore()
-    const foreign = '0x0000000000000000000000000000000000000004' as Address
-    await channelStore.set({
-      chainId,
-      channelId: `0x${'44'.repeat(32)}`,
-      cumulativeAmount: 100n,
-      deposit: 100n,
-      descriptor: { ...descriptor, authorizedSigner: foreign, payer: foreign },
-      escrow: tip20ChannelEscrow,
-      opened: true,
-    })
-    const actions: Types.SessionCredentialPayload['action'][] = []
-    const challenge = makeSessionChallenge({ suggestedDeposit: '1000' })
-    const fetch = makeSessionFetch(async (_input, init) => {
-      const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
-      if (!authorization) return paymentRequired(challenge)
-      actions.push(deserialize(authorization).action)
-      return new Response('paid')
-    }, channelStore)
-
-    expect(await (await fetch('https://example.com/resource')).text()).toBe('paid')
-    expect(await (await fetch('https://example.com/resource')).text()).toBe('paid')
-    expect(actions).toEqual(['open', 'voucher'])
-    expect(await channelStore.get(defaultChannelKey)).toMatchObject({
-      descriptor: { authorizedSigner: account.address, payer: account.address },
-      opened: true,
-    })
-  })
-
-  test('uses a matching server snapshot deposit when checking headroom', async () => {
-    const channelStore = createChannelStore()
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-    await channelStore.set({
-      chainId,
-      channelId,
-      cumulativeAmount: 100n,
-      deposit: 100n,
-      descriptor,
-      escrow: tip20ChannelEscrow,
-      opened: true,
-    })
-    const challenge = makeChallenge({
-      methodDetails: {
-        chainId,
-        escrowContract: tip20ChannelEscrow,
-        sessionProtocol: Constants.SessionProtocols.v2,
-        sessionSnapshot: {
-          acceptedCumulative: '100',
-          chainId,
-          channelId,
-          deposit: '200',
-          descriptor,
-          escrow: tip20ChannelEscrow,
-          requiredCumulative: '200',
-          settled: '0',
-          spent: '100',
-          units: 1,
-        },
-      },
-    })
-    let updatedDeposit = 0n
-    const method = session({
-      account,
-      channelStore,
-      decimals: 0,
-      getClient: () => client,
-      onChannelUpdate: (entry) => {
-        updatedDeposit = entry.deposit
-      },
-    })
-
-    await expect(
-      MethodChallenge.handle(method, {
-        challenge,
-        context: {},
-        fetch: async () => {
-          throw new Error('unexpected top-up')
-        },
-        input: 'https://example.com/resource',
-      }),
-    ).resolves.toBeUndefined()
-    expect(updatedDeposit).toBe(200n)
-  })
-
-  test('opens for the current amount without client deposit configuration', async () => {
-    const method = session({ account, getClient: () => client })
-    const payload = deserialize(
-      await method.createCredential({ challenge: makeChallenge(), context: {} }),
-    )
-
-    expect(payload.action).toBe('open')
-    expect(openDeposit(payload)).toBe(100n)
-  })
-
-  test('atomically auto-swaps before opening a session channel', async () => {
-    const sourceToken = '0x0000000000000000000000000000000000000007' as Address
-    const swapCalls = [
-      { to: sourceToken, data: '0x1234' as const },
-      { to: '0x0000000000000000000000000000000000000008' as Address, data: '0x5678' as const },
-    ]
-    const findCalls = vi.spyOn(AutoSwap, 'findCalls').mockResolvedValue(swapCalls)
-    try {
-      const method = session({
-        account,
-        autoSwap: { slippage: 2, tokenIn: [sourceToken] },
-        getClient: () => client,
-      })
-      const payload = deserialize(
-        await method.createCredential({ challenge: makeChallenge(), context: {} }),
-      )
-
-      expect(findCalls).toHaveBeenCalledWith(expect.any(Object), {
-        account: account.address,
-        amountOut: 100n,
-        slippage: 2,
-        tokenIn: expect.arrayContaining([sourceToken]),
-        tokenOut: descriptor.token,
-      })
-      const calls = transactionCalls(payload)
-      expect(calls.slice(0, 2)).toEqual(swapCalls)
-      expect(calls[2]!.to?.toLowerCase()).toBe(tip20ChannelEscrow.toLowerCase())
-      expect(decodeFunctionData({ abi: escrowAbi, data: calls[2]!.data! }).functionName).toBe(
-        'open',
-      )
-    } finally {
-      findCalls.mockRestore()
-    }
-  })
-
-  test('atomically auto-swaps before topping up a session channel', async () => {
-    const sourceToken = '0x0000000000000000000000000000000000000007' as Address
-    const swapCalls = [{ to: sourceToken, data: '0x1234' as const }]
-    const findCalls = vi.spyOn(AutoSwap, 'findCalls').mockResolvedValue(swapCalls)
-    try {
-      const method = session({ account, autoSwap: true, getClient: () => client })
-      const payload = deserialize(
-        await method.createCredential({
-          challenge: makeChallenge(),
-          context: { action: 'topUp', additionalDepositRaw: '250', descriptor },
-        }),
-      )
-
-      expect(findCalls).toHaveBeenCalledWith(expect.any(Object), {
-        account: account.address,
-        amountOut: 250n,
-        slippage: 1,
-        tokenIn: AutoSwap.defaultCurrencies,
-        tokenOut: descriptor.token,
-      })
-      const calls = transactionCalls(payload)
-      expect(calls[0]).toEqual(swapCalls[0])
-      expect(calls[1]!.to?.toLowerCase()).toBe(tip20ChannelEscrow.toLowerCase())
-      expect(decodeFunctionData({ abi: escrowAbi, data: calls[1]!.data! }).functionName).toBe(
-        'topUp',
-      )
-    } finally {
-      findCalls.mockRestore()
-    }
-  })
-
-  test('uses client chain ID when the challenge omits chain ID', async () => {
-    const method = session({ account, getClient: () => client })
-    const credential = deserializeCredential(
-      await method.createCredential({
-        challenge: makeChallenge({
-          methodDetails: { escrowContract: tip20ChannelEscrow },
-        }),
-        context: {},
-      }),
-    )
-    const payload = credential.payload
-
-    if (payload.action !== 'open') throw new Error('expected open payload')
-    expect(credential.source).toBe(`did:pkh:eip155:${chainId}:${account.address}`)
-    expect(payload.channelId).toBe(
-      Channel.computeId({ ...payload.descriptor, chainId, escrow: tip20ChannelEscrow }),
-    )
-  })
-
-  test('uses explicit context depositRaw before server hints', async () => {
-    const method = session({ account, getClient: () => client })
-    const payload = deserialize(
-      await method.createCredential({
-        challenge: makeChallenge(),
-        context: { depositRaw: '500' },
-      }),
-    )
-
-    expect(payload.action).toBe('open')
-    expect(openDeposit(payload)).toBe(500n)
-  })
-
-  test('caps suggestedDeposit by maxDeposit', async () => {
-    const method = session({ account, decimals: 0, maxDeposit: '500', getClient: () => client })
-    const payload = deserialize(
-      await method.createCredential({
-        challenge: makeChallenge({ suggestedDeposit: '1000' }),
-        context: {},
-      }),
-    )
-
-    expect(payload.action).toBe('open')
-    expect(openDeposit(payload)).toBe(500n)
-  })
-
-  test('uses suggestedDeposit when below maxDeposit', async () => {
-    const method = session({ account, decimals: 0, maxDeposit: '1000', getClient: () => client })
-    const payload = deserialize(
-      await method.createCredential({
-        challenge: makeChallenge({ suggestedDeposit: '700' }),
-        context: {},
-      }),
-    )
-
-    expect(payload.action).toBe('open')
-    expect(openDeposit(payload)).toBe(700n)
-  })
-
-  test('uses current amount without suggestedDeposit even when maxDeposit is higher', async () => {
-    const method = session({ account, decimals: 0, maxDeposit: '1000', getClient: () => client })
-    const payload = deserialize(
-      await method.createCredential({ challenge: makeChallenge(), context: {} }),
-    )
-
-    expect(payload.action).toBe('open')
-    expect(openDeposit(payload)).toBe(100n)
-  })
-
-  test('rejects open above maxDeposit without leaking the Fetch lock', async () => {
-    const method = session({ account, decimals: 0, maxDeposit: '50', getClient: () => client })
-    const fetch = Fetch.from({
-      fetch: async () => paymentRequired(makeSessionChallenge()),
-      methods: [method],
-    })
-
-    for (let attempt = 0; attempt < 2; attempt++)
-      await expect(fetch('https://example.com/resource')).rejects.toThrow(
-        'requested voucher amount 100 exceeds local maxDeposit 50',
-      )
-  })
-
-  test('rejects explicit opening deposits below the request amount', async () => {
-    const method = session({ account, decimals: 0, maxDeposit: '1000', getClient: () => client })
-
-    await expect(
-      method.createCredential({
-        challenge: makeChallenge(),
-        context: { depositRaw: '50' },
-      }),
-    ).rejects.toThrow('opening deposit 50 below request amount 100')
-  })
-
-  test('uses resolved escrow address for open transactions', async () => {
-    const challengeEscrow = '0x0000000000000000000000000000000000000005' as Address
-    const method = session({ account, decimals: 0, getClient: () => client })
-    const payload = deserialize(
-      await method.createCredential({
-        challenge: makeChallenge({
-          methodDetails: { chainId, escrowContract: challengeEscrow },
-        }),
-        context: {},
-      }),
-    )
-
-    if (payload.action !== 'open') throw new Error('expected open payload')
-    const transaction = Transaction.deserialize(payload.transaction)
-    if (!('calls' in transaction)) throw new Error('expected tempo calls')
-    const calls = transaction.calls as readonly { to?: Address; data?: `0x${string}` }[]
-    expect(calls[0]!.to?.toLowerCase()).toBe(challengeEscrow.toLowerCase())
-    expect(payload.channelId).toBe(
-      Channel.computeId({ ...payload.descriptor, chainId, escrow: challengeEscrow }),
-    )
-  })
-
-  test('uses challenge-advertised operator for open transactions', async () => {
-    const operator = '0x0000000000000000000000000000000000000006' as Address
-    const method = session({ account, decimals: 0, getClient: () => client })
-    const payload = deserialize(
-      await method.createCredential({
-        challenge: makeChallenge({
-          methodDetails: { chainId, escrowContract: tip20ChannelEscrow, operator },
-        }),
-        context: {},
-      }),
-    )
-
-    if (payload.action !== 'open') throw new Error('expected open payload')
-    expect(openArgs(payload)[1].toLowerCase()).toBe(operator.toLowerCase())
-    expect(payload.descriptor.operator.toLowerCase()).toBe(operator.toLowerCase())
-  })
-
-  test('tracks cumulative amount and calls onChannelUpdate in auto mode', async () => {
-    const updates: bigint[] = []
-    const method = session({
-      account,
-      decimals: 0,
-      maxDeposit: '1000',
-      getClient: () => client,
-      onChannelUpdate: (entry) => updates.push(entry.cumulativeAmount),
-    })
-    const first = deserialize(
-      await method.createCredential({ challenge: makeChallenge(), context: {} }),
-    )
-    const second = deserialize(
-      await method.createCredential({ challenge: makeChallenge(), context: {} }),
-    )
-
-    expect(first.action).toBe('open')
-    expect(second.action).toBe('voucher')
-    if (second.action !== 'voucher') throw new Error('expected voucher')
-    expect(second.channelId).toBe(first.channelId)
-    expect(second.cumulativeAmount).toBe('200')
-    expect(updates).toEqual([100n, 200n])
-  })
-
-  test('passes existing channel authority to resolveAccount before reusing session channel', async () => {
-    const accessKey = TempoAccount.fromSecp256k1(Secp256k1.randomPrivateKey(), {
-      access: account,
-    })
-    const calls: session.ResolveAccountInfo[] = []
-    const method = session({
-      account,
-      decimals: 0,
-      maxDeposit: '1000',
-      getClient: () => client,
-      resolveAccount(info) {
-        calls.push(info)
-        return accessKey
-      },
-    })
-    const first = deserializeCredential(
-      await method.createCredential({ challenge: makeChallenge(), context: {} }),
-    )
-    const second = deserializeCredential(
-      await method.createCredential({ challenge: makeChallenge(), context: {} }),
-    )
-
-    expect(calls).toHaveLength(2)
-    expect(calls[0]!.account.address).toBe(account.address)
-    expect(calls[0]!.operation).toEqual({ kind: 'authorizePaymentChannel' })
-    expect(calls[1]!.operation).toEqual({
-      kind: 'authorizePaymentChannel',
-      authority: accessKey.accessKeyAddress,
-    })
-    expect(first.source).toBe(`did:pkh:eip155:${chainId}:${account.address}`)
-    expect(second.source).toBe(`did:pkh:eip155:${chainId}:${account.address}`)
-    expect(first.payload.action).toBe('open')
-    if (first.payload.action !== 'open' || second.payload.action !== 'voucher')
-      throw new Error('expected open then voucher payloads')
-    expect(first.payload.descriptor.payer).toBe(account.address)
-    expect(first.payload.descriptor.authorizedSigner).toBe(accessKey.accessKeyAddress)
-    expect(second.payload.channelId).toBe(first.payload.channelId)
-    expect(second.payload.cumulativeAmount).toBe('200')
-  })
-
-  test('enforces maxDeposit when reusing a cached auto-mode channel', async () => {
-    const updates: bigint[] = []
-    const method = session({
-      account,
-      decimals: 0,
-      maxDeposit: '150',
-      getClient: () => client,
-      onChannelUpdate: (entry) => updates.push(entry.cumulativeAmount),
-    })
-
-    await method.createCredential({ challenge: makeChallenge(), context: {} })
-
-    await expect(
-      method.createCredential({ challenge: makeChallenge(), context: {} }),
-    ).rejects.toThrow('requested voucher amount 200 exceeds local maxDeposit 150')
-    expect(updates).toEqual([100n])
-  })
-
-  test('recovers and reuses a descriptor supplied in context', async () => {
-    const updates: bigint[] = []
-    const method = session({
-      account,
-      decimals: 0,
-      maxDeposit: '1000',
-      getClient: () => client,
-      onChannelUpdate: (entry) => updates.push(entry.cumulativeAmount),
-    })
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-    const recovered = deserialize(
-      await method.createCredential({
-        challenge: makeChallenge(),
-        context: { channelId, descriptor },
-      }),
-    )
-    const next = deserialize(
-      await method.createCredential({ challenge: makeChallenge(), context: {} }),
-    )
-
-    expect(recovered.action).toBe('voucher')
-    if (recovered.action !== 'voucher' || next.action !== 'voucher')
-      throw new Error('expected voucher')
-    expect(recovered.channelId).toBe(channelId)
-    expect(recovered.cumulativeAmount).toBe('100')
-    expect(next.channelId).toBe(channelId)
-    expect(next.cumulativeAmount).toBe('200')
-    expect(updates).toEqual([100n, 200n])
-  })
-
-  test('increments stored cumulative when recovering without a server snapshot', async () => {
-    const method = session({ account, decimals: 0, maxDeposit: '1000', getClient: () => client })
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-    const payload = deserialize(
-      await method.createCredential({
-        challenge: makeChallenge(),
-        context: { channelId, cumulativeAmountRaw: '100', descriptor },
-      }),
-    )
-
-    expect(payload.action).toBe('voucher')
-    if (payload.action !== 'voucher') throw new Error('expected voucher')
-    expect(payload.channelId).toBe(channelId)
-    expect(payload.cumulativeAmount).toBe('200')
-  })
-
-  test('uses required server snapshot cumulative when recovering a channel', async () => {
-    const method = session({ account, decimals: 0, maxDeposit: '1000', getClient: () => client })
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-    const payload = deserialize(
-      await method.createCredential({
-        challenge: makeChallenge({
-          methodDetails: {
-            chainId,
-            escrowContract: tip20ChannelEscrow,
-            sessionSnapshot: {
-              acceptedCumulative: '400',
-              chainId,
-              channelId,
-              deposit: '1000',
-              descriptor,
-              escrow: tip20ChannelEscrow,
-              requiredCumulative: '400',
-              settled: '0',
-              spent: '300',
-              units: 3,
-            },
-          },
-        }),
-        context: {},
-      }),
-    )
-
-    expect(payload.action).toBe('voucher')
-    if (payload.action !== 'voucher') throw new Error('expected voucher')
-    expect(payload.channelId).toBe(channelId)
-    expect(payload.descriptor).toEqual(descriptor)
-    expect(payload.cumulativeAmount).toBe('400')
-  })
-
-  test('does not decrease recovered authorization below accepted snapshot headroom', async () => {
-    const method = session({ account, decimals: 0, maxDeposit: '1000', getClient: () => client })
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-    const payload = deserialize(
-      await method.createCredential({
-        challenge: makeChallenge({
-          methodDetails: {
-            chainId,
-            escrowContract: tip20ChannelEscrow,
-            sessionSnapshot: {
-              acceptedCumulative: '500',
-              chainId,
-              channelId,
-              deposit: '1000',
-              descriptor,
-              escrow: tip20ChannelEscrow,
-              requiredCumulative: '400',
-              settled: '0',
-              spent: '300',
-              units: 3,
-            },
-          },
-        }),
-        context: {},
-      }),
-    )
-
-    expect(payload.action).toBe('voucher')
-    if (payload.action !== 'voucher') throw new Error('expected voucher')
-    expect(payload.cumulativeAmount).toBe('500')
-  })
-
-  test('caps recovered voucher authorization by maxDeposit', async () => {
-    const method = session({ account, decimals: 0, maxDeposit: '300', getClient: () => client })
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-
-    await expect(
-      method.createCredential({
-        challenge: makeChallenge({
-          methodDetails: {
-            chainId,
-            escrowContract: tip20ChannelEscrow,
-            sessionSnapshot: {
-              acceptedCumulative: '300',
-              chainId,
-              channelId,
-              deposit: '1000',
-              descriptor,
-              escrow: tip20ChannelEscrow,
-              requiredCumulative: '300',
-              settled: '0',
-              spent: '200',
-            },
-          },
-        }),
-        context: {},
-      }),
-    ).resolves.toBeDefined()
-
-    const overLimitMethod = session({
-      account,
-      decimals: 0,
-      maxDeposit: '300',
-      getClient: () => client,
-    })
-    await expect(
-      overLimitMethod.createCredential({
-        challenge: makeChallenge({
-          amount: '400',
-          methodDetails: {
-            chainId,
-            escrowContract: tip20ChannelEscrow,
-            sessionSnapshot: {
-              acceptedCumulative: '1000',
-              chainId,
-              channelId,
-              deposit: '1000',
-              descriptor,
-              escrow: tip20ChannelEscrow,
-              requiredCumulative: '1000',
-              settled: '0',
-              spent: '300',
-            },
-          },
-        }),
-        context: {},
-      }),
-    ).rejects.toThrow('requested voucher amount 1000 exceeds local maxDeposit 300')
-  })
-
-  test('rejects descriptor recovery for closed or missing channels', async () => {
-    const closedClient = createClient({
-      account,
-      chain: { id: chainId } as never,
-      transport: custom({
-        async request(args) {
-          if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
-          if (args.method === 'eth_call')
-            return encodeFunctionResult({
-              abi: escrowAbi,
-              functionName: 'getChannelState',
-              result: { settled: 0n, deposit: 0n, closeRequestedAt: 0 },
-            })
-          throw new Error(`unexpected rpc request: ${args.method}`)
-        },
-      }),
-    })
-    const method = session({
-      account,
-      decimals: 0,
-      maxDeposit: '1000',
-      getClient: () => closedClient,
-    })
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-
-    await expect(
-      method.createCredential({
-        challenge: makeChallenge(),
-        context: { channelId, descriptor },
-      }),
-    ).rejects.toThrow(/cannot be reused \(closed or not found on-chain\)/)
-  })
-
-  test('rejects channel recovery without descriptor', async () => {
-    const method = session({ account, decimals: 0, maxDeposit: '1000', getClient: () => client })
-
-    await expect(
-      method.createCredential({
-        challenge: makeChallenge(),
-        context: { channelId: `0x${'33'.repeat(32)}` },
-      }),
-    ).rejects.toThrow('descriptor required to reuse TIP-1034 channel')
-  })
-
-  test('defaults precompile authorizedSigner to account access key address', async () => {
-    const accessKeyAddress = '0x0000000000000000000000000000000000000009' as Address
-    const accessKeyAccount = Object.assign({}, account, { accessKeyAddress })
-    const method = session({
-      account: accessKeyAccount,
-      decimals: 0,
-      maxDeposit: '1000',
-      getClient: () => client,
-    })
-    const payload = deserialize(
-      await method.createCredential({ challenge: makeChallenge(), context: {} }),
-    )
-
-    expect(payload.action).toBe('open')
-    if (payload.action !== 'open') throw new Error('expected open payload')
-    expect(payload.descriptor.authorizedSigner).toBe(accessKeyAddress)
-  })
-
-  test('manual open requires transaction', async () => {
-    const method = session({ account, getClient: () => client })
-
-    await expect(
-      method.createCredential({
-        challenge: makeChallenge(),
-        context: { action: 'open', descriptor, cumulativeAmountRaw: '100' },
-      }),
-    ).rejects.toThrow('transaction required for open action')
-  })
-
-  test('manual open requires cumulativeAmount', async () => {
-    const method = session({ account, getClient: () => client })
-
-    await expect(
-      method.createCredential({
-        challenge: makeChallenge(),
-        context: { action: 'open', descriptor, transaction: '0x1234' },
-      }),
-    ).rejects.toThrow('cumulativeAmount required for open action')
-  })
-
-  test('manual topUp requires additionalDeposit', async () => {
-    const method = session({ account, getClient: () => client })
-
-    await expect(
-      method.createCredential({
-        challenge: makeChallenge(),
-        context: { action: 'topUp', descriptor, transaction: '0x1234' },
-      }),
-    ).rejects.toThrow('additionalDeposit required for topUp action')
-  })
-
-  test('manual voucher requires cumulativeAmount', async () => {
-    const method = session({ account, getClient: () => client })
-
-    await expect(
-      method.createCredential({
-        challenge: makeChallenge(),
-        context: { action: 'voucher', descriptor },
-      }),
-    ).rejects.toThrow('cumulativeAmount required for voucher action')
-  })
-
-  test('manual close requires cumulativeAmount', async () => {
-    const method = session({ account, getClient: () => client })
-
-    await expect(
-      method.createCredential({
-        challenge: makeChallenge(),
-        context: { action: 'close', descriptor },
-      }),
-    ).rejects.toThrow('cumulativeAmount required for close action')
-  })
-
-  test('manual actions require descriptors', async () => {
-    const method = session({ account, getClient: () => client })
-
-    await expect(
-      method.createCredential({
-        challenge: makeChallenge(),
-        context: { action: 'voucher', cumulativeAmountRaw: '100' },
-      }),
-    ).rejects.toThrow('descriptor required for TIP-1034 session action')
-  })
-
-  test('creates manual voucher credentials with descriptor payloads', async () => {
-    const method = session({ account, getClient: () => client })
-    const credential = await method.createCredential({
-      challenge: makeChallenge(),
-      context: {
-        action: 'voucher',
-        descriptor,
-        cumulativeAmountRaw: '250',
-      },
-    })
-
-    const decoded = deserializeCredential(credential)
-    const payload = decoded.payload as Types.SessionCredentialPayload
-    const cumulativeAmount = Types.uint96(250n)
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-
-    expect(decoded.challenge.id).toBe('test-id')
-    expect(decoded.challenge.realm).toBe('test.com')
-    expect(decoded.challenge.method).toBe('tempo')
-    expect(decoded.challenge.intent).toBe('session')
-    expect(payload.action).toBe('voucher')
-    if (payload.action !== 'voucher') throw new Error('expected voucher payload')
-    expect(payload.channelId).toBe(channelId)
-    expect(payload.descriptor).toEqual(descriptor)
-    expect(payload.cumulativeAmount).toBe('250')
-    expect(decoded.source).toBe(`did:pkh:eip155:${chainId}:${account.address}`)
-    expect(
-      Voucher.verifyVoucher(
-        tip20ChannelEscrow,
-        chainId,
-        { channelId, cumulativeAmount, signature: payload.signature },
-        descriptor.authorizedSigner,
-      ),
-    ).toBe(true)
-  })
-
-  test('creates manual open credentials with descriptor payloads', async () => {
-    const method = session({ account, getClient: () => client })
-    const credential = await method.createCredential({
-      challenge: makeChallenge(),
-      context: {
-        action: 'open',
-        descriptor,
-        cumulativeAmountRaw: '250',
-        transaction: '0x1234',
-      },
-    })
-
-    const decoded = deserializeCredential(credential)
-    const payload = decoded.payload
-    const cumulativeAmount = Types.uint96(250n)
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-
-    expect(decoded.challenge.id).toBe('test-id')
-    expect(payload.action).toBe('open')
-    if (payload.action !== 'open') throw new Error('expected open payload')
-    expect(payload.type).toBe('transaction')
-    expect(payload.channelId).toBe(channelId)
-    expect(payload.descriptor).toEqual(descriptor)
-    expect(payload.transaction).toBe('0x1234')
-    expect(payload.cumulativeAmount).toBe('250')
-    expect(payload.authorizedSigner).toBe(descriptor.authorizedSigner)
-    expect(decoded.source).toBe(`did:pkh:eip155:${chainId}:${account.address}`)
-    expect(
-      Voucher.verifyVoucher(
-        tip20ChannelEscrow,
-        chainId,
-        { channelId, cumulativeAmount, signature: payload.signature },
-        descriptor.authorizedSigner,
-      ),
-    ).toBe(true)
-  })
-
-  test('creates manual top-up credentials from provided transactions', async () => {
-    const method = session({ account, getClient: () => client })
-    const credential = await method.createCredential({
-      challenge: makeChallenge(),
-      context: {
-        action: 'topUp',
-        descriptor,
-        additionalDepositRaw: '500',
-        transaction: '0x1234',
-      },
-    })
-
-    const decoded = deserializeCredential(credential)
-    const payload = decoded.payload as Types.SessionCredentialPayload
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-
-    expect(payload.action).toBe('topUp')
-    if (payload.action !== 'topUp') throw new Error('expected topUp payload')
-    expect(payload.channelId).toBe(channelId)
-    expect(payload.descriptor).toEqual(descriptor)
-    expect(payload.additionalDeposit).toBe('500')
-    expect(payload.transaction).toBe('0x1234')
-    expect(decoded.source).toBe(`did:pkh:eip155:${chainId}:${account.address}`)
-  })
-
-  test('creates manual close credentials with descriptor payloads', async () => {
-    const method = session({ account, getClient: () => client })
-    const credential = await method.createCredential({
-      challenge: makeChallenge(),
-      context: {
-        action: 'close',
-        descriptor,
-        cumulativeAmountRaw: '250',
-      },
-    })
-
-    const decoded = deserializeCredential(credential)
-    const payload = decoded.payload
-    const cumulativeAmount = Types.uint96(250n)
-    const channelId = Channel.computeId({ ...descriptor, chainId, escrow: tip20ChannelEscrow })
-
-    expect(payload.action).toBe('close')
-    if (payload.action !== 'close') throw new Error('expected close payload')
-    expect(payload.channelId).toBe(channelId)
-    expect(payload.descriptor).toEqual(descriptor)
-    expect(payload.cumulativeAmount).toBe('250')
-    expect(decoded.source).toBe(`did:pkh:eip155:${chainId}:${account.address}`)
-    expect(
-      Voucher.verifyVoucher(
-        tip20ChannelEscrow,
-        chainId,
-        { channelId, cumulativeAmount, signature: payload.signature },
-        descriptor.authorizedSigner,
-      ),
-    ).toBe(true)
-  })
-})