mppx 0.8.13 → 0.8.14

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

@@ -194,10 +194,25 @@ describe('precompile client ChannelOps credential builders', () => {
     const now = Math.floor(Date.now() / 1_000)
 
     expect(requests).toMatchObject([
-      { feePayer: true, validAfter: expect.any(Number) },
-      { feePayer: true, validAfter: expect.any(Number) },
+      { feePayer: true, nonceKey: 'expiring', validAfter: expect.any(Number) },
+      { feePayer: true, nonceKey: 'expiring', validAfter: expect.any(Number) },
     ])
     expect(new Set(validAfter).size).toBe(2)
     expect(validAfter.every((value) => value >= 0 && value < now)).toBe(true)
   })
+
+  test('uses expiring nonces and entropy for unsponsored management transactions', async () => {
+    mocks.prepareTransactionRequest.mockClear()
+
+    await ChannelOps.createTopUpPayload(client, account, descriptor, 10n, chainId, false)
+
+    expect(mocks.prepareTransactionRequest).toHaveBeenCalledWith(
+      client,
+      expect.objectContaining({
+        nonceKey: 'expiring',
+        validAfter: expect.any(Number),
+      }),
+    )
+    expect(mocks.prepareTransactionRequest.mock.calls[0]?.[1]).not.toHaveProperty('feePayer')
+  })
 })

package/src/tempo/session/client/ChannelOps.ts

@@ -28,7 +28,7 @@ import type {
 import { uint96 } from '../precompile/Protocol.js'
 import * as Voucher from '../precompile/Voucher.js'
 
-type TempoChannelCall = {
+export type TempoChannelCall = {
   to: Address
   data: Hex.Hex
 }
@@ -91,14 +91,18 @@ async function prepareTempoChannelTransaction(
   },
 ) {
   const { account, calls, feePayer, feeToken, validAfter } = parameters
+  // Session management transactions are independent and short-lived, so they
+  // always use TIP-1009 expiring nonces. `feePayer` controls sponsorship only.
   // viem's stable transaction request type does not yet expose Tempo's
   // `calls`, `feePayer`, and `feeToken` fields together. Keep the cast at
   // this boundary so session credential builders stay typed.
   return prepareTransactionRequest(client, {
     account,
     calls,
-    ...(feePayer ? { feePayer: true, ...(validAfter !== undefined ? { validAfter } : {}) } : {}),
+    nonceKey: 'expiring',
+    ...(feePayer ? { feePayer: true } : {}),
     feeToken,
+    ...(validAfter !== undefined ? { validAfter } : {}),
   } as never)
 }
 
@@ -227,6 +231,8 @@ export async function createOpenPayload(
     initialAmount: bigint
     operator?: Address | undefined
     payee: Address
+    /** Calls executed atomically before the channel is opened. */
+    prefixCalls?: readonly TempoChannelCall[] | undefined
     token: Address
   },
 ): Promise<OpenCredentialPayload> {
@@ -244,7 +250,7 @@ export async function createOpenPayload(
   })
   const prepared = await prepareTempoChannelTransaction(client, {
     account,
-    calls: [{ to: escrow, data: openData }],
+    calls: [...(parameters.prefixCalls ?? []), { to: escrow, data: openData }],
     feePayer: parameters.feePayer,
     feeToken: parameters.token,
   })
@@ -304,6 +310,7 @@ export async function createTopUpPayload(
   chainId: number,
   feePayer?: boolean | undefined,
   escrow: Address = tip20ChannelEscrow,
+  prefixCalls: readonly TempoChannelCall[] = [],
 ): Promise<TopUpCredentialPayload> {
   const channelId = Channel.computeId({
     ...descriptor,
@@ -314,6 +321,7 @@ export async function createTopUpPayload(
   const prepared = await prepareTempoChannelTransaction(client, {
     account,
     calls: [
+      ...prefixCalls,
       {
         to: escrow,
         data: encodeFunctionData({
@@ -325,7 +333,7 @@ export async function createTopUpPayload(
     ],
     feePayer,
     feeToken: descriptor.token,
-    ...(feePayer ? { validAfter: randomValidAfter() } : {}),
+    validAfter: randomValidAfter(),
   })
   const transaction = await signPreparedTempoTransaction(client, prepared)
 

package/src/tempo/session/client/CredentialState.ts

@@ -11,6 +11,7 @@ import type * as Challenge from '../../../Challenge.js'
 import * as Constants from '../../../Constants.js'
 import * as Account from '../../../viem/Account.js'
 import * as z from '../../../zod.js'
+import * as AutoSwap from '../../internal/auto-swap.js'
 import * as Chain from '../precompile/Chain.js'
 import * as Channel from '../precompile/Channel.js'
 import type { SessionCredentialPayload } from '../precompile/Protocol.js'
@@ -25,6 +26,7 @@ import {
   resolveAuthorizedSigner,
   resolveEscrow,
   type ChannelEntry,
+  type TempoChannelCall,
 } from './ChannelOps.js'
 import { channelKey, entryKey, type ChannelSink } from './ChannelStore.js'
 import { assertWithinMaxDeposit, resolveOpeningDeposit } from './Runtime.js'
@@ -88,6 +90,7 @@ const hashSchema = z.custom<Hex>(
 /** Runtime schema for low-level TIP-1034 session credential context. */
 export const sessionContextSchema = z.object({
   account: z.optional(z.custom<Account.getResolver.Parameters['account']>()),
+  autoSwap: z.optional(z.custom<AutoSwap.resolve.Value>()),
   action: z.optional(z.enum(['open', 'topUp', 'voucher', 'close'])),
   channelId: z.optional(hashSchema),
   cumulativeAmount: z.optional(z.amount()),
@@ -103,6 +106,8 @@ export const sessionContextSchema = z.object({
 export type SessionContext = {
   /** Optional account override used for this credential only. */
   account?: Account.getResolver.Parameters['account'] | undefined
+  /** Automatically acquire the session currency from fallback stablecoins before open/top-up. */
+  autoSwap?: AutoSwap.resolve.Value | undefined
   /** Manual credential action. Omit for automatic open/recover/voucher management. */
   action?: 'open' | 'topUp' | 'voucher' | 'close' | undefined
   /** Channel ID being reused or manually operated on. */
@@ -497,7 +502,7 @@ function assertReusableChannelDescriptor(parameters: {
     throw new Error('context descriptor token does not match challenge')
   if (!isSameAddress(descriptor.payer, payer))
     throw new Error('context descriptor payer does not match account')
-  if (!isSameAddress(descriptor.authorizedSigner, authorizedSigner))
+  if (!isSameAddress(Channel.resolveAuthorizedSigner(descriptor), authorizedSigner))
     throw new Error('context descriptor authorizedSigner does not match account')
 }
 
@@ -558,10 +563,6 @@ export async function hydrateSessionSnapshot(
   if (snapshotSettled > snapshotDeposit)
     throw new Error('session snapshot settled amount exceeds deposit')
 
-  const authorizedSigner =
-    BigInt(snapshot.descriptor.authorizedSigner) === 0n
-      ? snapshot.descriptor.payer
-      : snapshot.descriptor.authorizedSigner
   if (
     !Voucher.verifyVoucher(
       snapshot.escrow,
@@ -571,7 +572,7 @@ export async function hydrateSessionSnapshot(
         cumulativeAmount: voucherCumulative,
         signature: signed.signature,
       },
-      authorizedSigner,
+      Channel.resolveAuthorizedSigner(snapshot.descriptor),
     )
   )
     throw new Error('session snapshot highest voucher signature is invalid')
@@ -618,9 +619,10 @@ export function canSignDescriptor(
 ): boolean {
   // Only the payer can deposit into and voucher against its own channel.
   if (!isSameAddress(account.address, descriptor.payer)) return false
-  const authority = descriptor.authorizedSigner
-  if (BigInt(authority) === 0n || isSameAddress(authority, descriptor.payer)) return true
-  return isSameAddress(resolveAuthorizedSigner(account), authority)
+  return isSameAddress(
+    resolveAuthorizedSigner(account),
+    Channel.resolveAuthorizedSigner(descriptor),
+  )
 }
 
 /** Chooses the next credential plan from local channel cache and optional caller context. */
@@ -661,22 +663,43 @@ export function planCredential(parameters: PlanCredentialParameters): Credential
 export async function executeCredentialPlan(
   plan: CredentialPlan,
   sink: ChannelSink,
+  autoSwap: AutoSwap.resolve.Resolved | false = false,
 ): Promise<SessionCredentialPayload> {
   switch (plan.type) {
     case 'open':
-      return open(plan, sink)
+      return open(plan, sink, autoSwap)
     case 'recover':
       return recover(plan, sink)
     case 'voucher':
       return voucher(plan, sink)
     case 'manual':
-      return manual(plan, sink)
+      return manual(plan, sink, autoSwap)
   }
 }
 
+async function resolveAutoSwapCalls(
+  autoSwap: AutoSwap.resolve.Resolved | false,
+  parameters: {
+    account: Address
+    amountOut: bigint
+    client: Client
+    tokenOut: Address
+  },
+): Promise<readonly TempoChannelCall[] | undefined> {
+  if (!autoSwap) return undefined
+  return (await AutoSwap.findCalls(parameters.client, {
+    account: parameters.account,
+    amountOut: parameters.amountOut,
+    tokenOut: parameters.tokenOut,
+    tokenIn: autoSwap.tokenIn,
+    slippage: autoSwap.slippage,
+  })) as readonly TempoChannelCall[] | undefined
+}
+
 async function open(
   plan: Extract<CredentialPlan, { type: 'open' }>,
   sink: ChannelSink,
+  autoSwap: AutoSwap.resolve.Resolved | false,
 ): Promise<SessionCredentialPayload> {
   const { account, resolved } = plan
   const deposit = resolveOpeningDeposit({
@@ -693,6 +716,12 @@ async function open(
     initialAmount: resolved.amount,
     operator: resolved.operator,
     payee: resolved.payee,
+    prefixCalls: await resolveAutoSwapCalls(autoSwap, {
+      account: account.address,
+      amountOut: deposit,
+      client: resolved.client,
+      tokenOut: resolved.token,
+    }),
     token: resolved.token,
   })
   await storeChannelEntry(sink, {
@@ -779,6 +808,7 @@ async function voucher(
 async function manual(
   plan: Extract<CredentialPlan, { type: 'manual' }>,
   sink: ChannelSink,
+  autoSwap: AutoSwap.resolve.Resolved | false,
 ): Promise<SessionCredentialPayload> {
   const { account, context, decimals, resolved } = plan
   const { descriptor } = context
@@ -797,26 +827,30 @@ async function manual(
     token: resolved.token,
   })
 
-  const payload = await executeManualCredential({
-    account,
-    channelId,
-    context,
-    decimals,
-    descriptor,
-    resolved,
-  })
+  const payload = await executeManualCredential(
+    {
+      account,
+      channelId,
+      context,
+      decimals,
+      descriptor,
+      resolved,
+    },
+    autoSwap,
+  )
   await applyCumulative(sink, resolved.key, payload)
   return payload
 }
 
 async function executeManualCredential(
   parameters: ManualCredentialParameters,
+  autoSwap: AutoSwap.resolve.Resolved | false,
 ): Promise<SessionCredentialPayload> {
   switch (parameters.context.action) {
     case 'open':
       return manualOpen(parameters)
     case 'topUp':
-      return manualTopUp(parameters)
+      return manualTopUp(parameters, autoSwap)
     case 'voucher':
       return manualVoucher(parameters)
     case 'close':
@@ -852,6 +886,7 @@ async function manualOpen(
 
 async function manualTopUp(
   parameters: ManualCredentialParameters,
+  autoSwap: AutoSwap.resolve.Resolved | false,
 ): Promise<SessionCredentialPayload> {
   const { account, channelId, context, decimals, descriptor, resolved } = parameters
   const additionalDeposit = requireContextAmount(context, decimals, 'additionalDeposit', 'topUp')
@@ -873,6 +908,12 @@ async function manualTopUp(
     resolved.chainId,
     resolved.feePayer,
     resolved.escrow,
+    await resolveAutoSwapCalls(autoSwap, {
+      account: account.address,
+      amountOut: additionalDeposit,
+      client: resolved.client,
+      tokenOut: resolved.token,
+    }),
   )
 }
 

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

@@ -30,6 +30,7 @@ import {
   nextSpentFromReceipt,
   parseManagerAmount,
   reduce,
+  resolveAutomaticTopUp,
   resolveCloseTarget,
   resolveNeedVoucherTransition,
   resolveOpeningDeposit,
@@ -925,6 +926,17 @@ describe('LocalAuthorization', () => {
       )
     })
 
+    test.each([
+      [{ topUpAmount: 80n, suggestedDeposit: 100n }, 80n],
+      [{ suggestedDeposit: 100n }, 100n],
+      [{}, 50n],
+      [{ maxDeposit: 180n, suggestedDeposit: 100n }, 80n],
+    ])('resolves bounded automatic top-ups %#', (policy, expected) => {
+      expect(resolveAutomaticTopUp({ deposit: 100n, requiredCumulative: 150n, ...policy })).toBe(
+        expected,
+      )
+    })
+
     test('enforces optional maxDeposit through the compatibility helper', () => {
       expect(() => assertWithinMaxDeposit(101n, 100n)).toThrow(
         'requested voucher amount 101 exceeds local maxDeposit 100',

package/src/tempo/session/client/Runtime.ts

@@ -533,6 +533,28 @@ export function resolveOpeningDeposit(parameters: ResolveOpeningDepositParameter
   return proposed
 }
 
+/** Resolves a bounded automatic refill, preferring explicit policy over server headroom. */
+export function resolveAutomaticTopUp(parameters: {
+  deposit: bigint
+  maxDeposit?: bigint | null | undefined
+  requiredCumulative: bigint
+  suggestedDeposit?: bigint | undefined
+  topUpAmount?: bigint | null | undefined
+}): bigint {
+  const { deposit, maxDeposit, requiredCumulative, suggestedDeposit, topUpAmount } = parameters
+  if (requiredCumulative <= deposit) return 0n
+  assertVoucherWithinLocalLimit({
+    cumulativeAmount: requiredCumulative,
+    maxVoucherCumulative: maxDeposit ?? null,
+  })
+  const shortfall = requiredCumulative - deposit
+  const preferred = topUpAmount ?? suggestedDeposit ?? shortfall
+  const proposed = preferred > shortfall ? preferred : shortfall
+  if (maxDeposit === null || maxDeposit === undefined) return proposed
+  const remaining = maxDeposit - deposit
+  return proposed < remaining ? proposed : remaining
+}
+
 /** Enforces the optional client-side maximum cumulative voucher authorization. */
 export function assertWithinMaxDeposit(
   cumulativeAmount: bigint,

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

@@ -1,13 +1,15 @@
 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 } from 'vp/test'
+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'
@@ -99,6 +101,14 @@ 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 })
@@ -205,7 +215,164 @@ describe('precompile client session', () => {
     expect(await response.text()).toBe(
       `${Types.formatMessageEvent('first')}${Types.formatMessageEvent('second')}`,
     )
-    expect(actions).toEqual(['open', 'voucher', 'topUp', 'voucher'])
+    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
+    }[] = []
+    let opened: Extract<Types.SessionCredentialPayload, { action: 'open' }> | undefined
+    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 (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')
+
+      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'])
+    expect(paidRequests).toEqual([{ body: 'request-body', header: 'preserved', method: 'POST' }])
+  })
+
+  test('does not top up 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 = makeChallenge({
+      methodDetails: {
+        chainId,
+        escrowContract: tip20ChannelEscrow,
+        sessionProtocol: Constants.SessionProtocols.v2,
+      },
+    })
+    const fetch = Fetch.from({
+      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) },
+          })
+        actions.push(deserialize(authorization).action)
+        return new Response('paid')
+      },
+      methods: [session({ account, channelStore, decimals: 0, getClient: () => client })],
+    })
+
+    expect(await (await fetch('https://example.com/resource')).text()).toBe('paid')
+    expect(actions).toEqual(['open'])
+  })
+
+  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 () => {
@@ -218,6 +385,72 @@ describe('precompile client session', () => {
     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(