mppx 0.8.12 → 0.8.14

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

@@ -1,8 +1,8 @@
 import { type Address, parseUnits } from 'viem'
 import { tempo as tempo_chain } from 'viem/chains'
 
+import * as MethodChallenge from '../../../client/internal/MethodChallenge.js'
 import * as MethodResponse from '../../../client/internal/MethodResponse.js'
-import * as Constants from '../../../Constants.js'
 import * as Credential from '../../../Credential.js'
 import * as Method from '../../../Method.js'
 import * as Account from '../../../viem/Account.js'
@@ -11,26 +11,36 @@ import type {
   ResolveAccount as ResolveAccount_,
   ResolveAccountInfo as ResolveAccountInfo_,
 } from '../../client/ResolveAccount.js'
+import * as AutoSwap from '../../internal/auto-swap.js'
 import * as defaults from '../../internal/defaults.js'
 import * as Methods from '../../Methods.js'
-import { isEventStream, requireSessionCredentialContext } from '../precompile/Protocol.js'
+import * as Channel from '../precompile/Channel.js'
+import {
+  isEventStream,
+  readSessionChallengeAmount,
+  requireSessionCredentialContext,
+} from '../precompile/Protocol.js'
 import { serializeCredential, type ChannelEntry } from './ChannelOps.js'
 import { createChannelStore, type ChannelStore } from './ChannelStore.js'
 import {
+  canSignDescriptor,
   executeCredentialPlan,
+  hasSessionAction,
   planCredential,
   resolveChallengeContext,
   resolveRecoverContext,
   sessionContextSchema,
+  type ChallengeContext,
+  type SessionContext as CredentialContext,
 } from './CredentialState.js'
-import { assertWithinMaxDeposit } from './Runtime.js'
+import { assertWithinMaxDeposit, resolveAutomaticTopUp } from './Runtime.js'
 import {
   handleSseNeedVoucher,
-  isTempoSessionChallenge,
-  managementInput,
+  isTip1034SessionChallenge,
   postTopUp,
   wrapSseResponse,
   type SsePaymentDriver,
+  type TempoSessionChallenge,
 } from './Transports.js'
 
 export { sessionContextSchema, type SessionContext } from './CredentialState.js'
@@ -45,11 +55,13 @@ export { sessionContextSchema, type SessionContext } from './CredentialState.js'
 export function session(parameters: session.Parameters = {}) {
   const {
     account,
+    autoSwap: autoSwapParameter,
     channelStore,
     decimals = defaults.decimals,
     escrow: escrowOverride,
     getClient: getClientParameter,
     maxDeposit: maxDepositParameter,
+    topUpAmount: topUpAmountParameter,
     onChannelUpdate,
     resolveAccount,
   } = parameters
@@ -61,18 +73,35 @@ export function session(parameters: session.Parameters = {}) {
   const getAccount = Account.getResolver({ account })
   const maxDeposit =
     maxDepositParameter !== undefined ? parseUnits(maxDepositParameter, decimals) : undefined
+  const topUpAmount =
+    topUpAmountParameter !== undefined ? parseUnits(topUpAmountParameter, decimals) : undefined
   const store = channelStore ?? createChannelStore()
   const sink = { store, notifyUpdate: (entry: ChannelEntry) => onChannelUpdate?.(entry) }
 
+  const resolveCredentialAccount = async (
+    resolved: ChallengeContext,
+    context: CredentialContext | undefined,
+    entry: ChannelEntry | undefined,
+  ) => {
+    const defaultAccount = getAccount(resolved.client, context)
+    const descriptor = context?.action
+      ? context.descriptor
+      : (entry?.descriptor ??
+        resolveRecoverContext({ context, snapshot: resolved.snapshot })?.descriptor)
+    return (
+      (await resolveAccount?.({
+        account: defaultAccount,
+        chainId: resolved.chainId,
+        operation: {
+          kind: 'authorizePaymentChannel',
+          ...(descriptor ? { authority: Channel.resolveAuthorizedSigner(descriptor) } : {}),
+        },
+      })) ?? defaultAccount
+    )
+  }
+
   const method = Method.toClient(Methods.session, {
-    canHandleChallenge({ challenge }) {
-      return (
-        Constants.getMethodDetail(
-          challenge.request.methodDetails,
-          Constants.MethodDetailKeys.sessionProtocol,
-        ) === Constants.SessionProtocols.v2
-      )
-    },
+    canHandleChallenge: ({ challenge }) => isTip1034SessionChallenge(challenge),
     context: sessionContextSchema,
     async createCredential({ challenge, context }) {
       const resolved = await resolveChallengeContext({
@@ -80,22 +109,8 @@ export function session(parameters: session.Parameters = {}) {
         escrowOverride,
         getClient,
       })
-      const defaultAccount = getAccount(resolved.client, context)
       const entry = await store.get(resolved.key)
-      // Resolve recovery hints early so account selection can satisfy an existing channel authority.
-      const recoverContext = resolveRecoverContext({ context, snapshot: resolved.snapshot })
-      const descriptor = context?.action
-        ? context.descriptor
-        : (entry?.descriptor ?? recoverContext?.descriptor)
-      const account =
-        (await resolveAccount?.({
-          account: defaultAccount,
-          chainId: resolved.chainId,
-          operation: {
-            kind: 'authorizePaymentChannel',
-            ...(descriptor ? { authority: descriptor.authorizedSigner } : {}),
-          },
-        })) ?? defaultAccount
+      const account = await resolveCredentialAccount(resolved, context, entry)
       const payload = await executeCredentialPlan(
         planCredential({
           account,
@@ -106,15 +121,89 @@ export function session(parameters: session.Parameters = {}) {
           resolved,
         }),
         sink,
+        AutoSwap.resolve(context?.autoSwap ?? autoSwapParameter, AutoSwap.defaultCurrencies),
       )
       return serializeCredential(challenge, payload, resolved.chainId, account)
     },
   })
 
+  const topUpChannelIfNeeded = async ({
+    challenge,
+    channel,
+    deposit,
+    fetch,
+    input,
+    requiredCumulative,
+  }: {
+    challenge: TempoSessionChallenge
+    channel: ChannelEntry
+    deposit: bigint
+    fetch: typeof globalThis.fetch
+    input: RequestInfo | URL
+    requiredCumulative: bigint
+  }) => {
+    const knownDeposit = channel.deposit > deposit ? channel.deposit : deposit
+    const additionalDeposit = resolveAutomaticTopUp({
+      deposit: knownDeposit,
+      maxDeposit,
+      requiredCumulative,
+      suggestedDeposit:
+        challenge.request.suggestedDeposit === undefined
+          ? undefined
+          : BigInt(challenge.request.suggestedDeposit),
+      topUpAmount,
+    })
+    if (additionalDeposit > 0n)
+      await postTopUp({
+        additionalDeposit,
+        challenge,
+        channel,
+        channelId: channel.channelId,
+        createSessionCredential: (challenge, context) =>
+          method.createCredential({ challenge, context }),
+        fetch,
+        input,
+      })
+    const nextDeposit = knownDeposit + additionalDeposit
+    if (nextDeposit === channel.deposit) return
+    const updated = { ...channel, deposit: nextDeposit }
+    await store.set(updated)
+    sink.notifyUpdate(updated)
+  }
+
+  MethodChallenge.register(method, async ({ challenge, context, fetch, input }) => {
+    if (!isTip1034SessionChallenge(challenge)) return
+    const sessionContext = context === undefined ? undefined : sessionContextSchema.parse(context)
+    if (hasSessionAction(sessionContext)) return
+    const resolved = await resolveChallengeContext({ challenge, escrowOverride, getClient })
+    const channel = await store.get(resolved.key)
+    if (!channel?.opened) return
+    const snapshot =
+      resolved.snapshot?.channelId.toLowerCase() === channel.channelId.toLowerCase()
+        ? resolved.snapshot
+        : undefined
+    const nextCumulative = channel.cumulativeAmount + readSessionChallengeAmount(challenge)
+    const snapshotRequired = snapshot ? BigInt(snapshot.requiredCumulative) : nextCumulative
+    const requiredCumulative = snapshotRequired > nextCumulative ? snapshotRequired : nextCumulative
+    const snapshotDeposit = snapshot ? BigInt(snapshot.deposit) : channel.deposit
+    const deposit = snapshotDeposit > channel.deposit ? snapshotDeposit : channel.deposit
+    if (requiredCumulative <= deposit && deposit === channel.deposit) return
+    const account = await resolveCredentialAccount(resolved, sessionContext, channel)
+    if (!canSignDescriptor(account, channel.descriptor)) return
+    await topUpChannelIfNeeded({
+      challenge,
+      channel,
+      deposit,
+      fetch,
+      input,
+      requiredCumulative,
+    })
+  })
+
   return MethodResponse.register(
     method,
     async ({ challenge, credential, fetch, headers, input, refetch, response, signal }) => {
-      if (!isTempoSessionChallenge(challenge)) return response
+      if (!isTip1034SessionChallenge(challenge)) return response
       if (!isEventStream(response)) {
         const credentialContext = requireSessionCredentialContext(
           Credential.deserialize(credential).payload,
@@ -142,23 +231,16 @@ export function session(parameters: session.Parameters = {}) {
           method.createCredential({ challenge, context }),
         fetch,
         getChannel: () => channel ?? null,
-        managementInput,
-        async topUpIfNeeded({ channelId, deposit, requiredCumulative }) {
-          if (requiredCumulative <= deposit || !channel) return
-          const additionalDeposit = requiredCumulative - deposit
-          await postTopUp({
-            additionalDeposit,
+        async topUpIfNeeded({ deposit, requiredCumulative }) {
+          if (!channel) return
+          await topUpChannelIfNeeded({
             challenge,
             channel,
-            channelId,
-            createSessionCredential: (challenge, context) =>
-              method.createCredential({ challenge, context }),
+            deposit: channel.deposit > deposit ? channel.deposit : deposit,
             fetch,
             input,
+            requiredCumulative,
           })
-          channel.deposit += additionalDeposit
-          await store.set(channel)
-          sink.notifyUpdate(channel)
         },
       } satisfies SsePaymentDriver
 
@@ -179,6 +261,8 @@ export declare namespace session {
 
   type Parameters = Account.getResolver.Parameters &
     Client.getResolver.Parameters & {
+      /** Automatically acquire the session currency from fallback stablecoins before open/top-up. */
+      autoSwap?: AutoSwap.resolve.Value | undefined
       /** Pluggable persistence for reusable channels. Defaults to an in-memory store. */
       channelStore?: ChannelStore | undefined
       /** Token decimals for parsing human-readable amounts (default: 6). */
@@ -187,6 +271,11 @@ export declare namespace session {
       escrow?: Address | undefined
       /** Maximum channel deposit in human-readable units. Caps server-suggested opens and automatic top-ups. */
       maxDeposit?: string | undefined
+      /**
+       * Preferred automatic top-up size in human-readable units. When omitted,
+       * a bounded server `suggestedDeposit` is preferred, then the exact shortfall.
+       */
+      topUpAmount?: string | undefined
       /** Called whenever channel state changes. */
       onChannelUpdate?: ((entry: ChannelEntry) => void) | undefined
       /** Selects the account that signs this session credential after the challenge is known. */

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

@@ -14,6 +14,7 @@ import { createSessionReceipt, serializeSessionReceipt } from '../precompile/Pro
 import type { NeedVoucherEvent, SessionReceipt } from '../precompile/Protocol.js'
 import { formatNeedVoucherEvent, parseEvent } from '../precompile/Protocol.js'
 import type { SessionCredentialPayload } from '../precompile/Protocol.js'
+import * as Voucher from '../precompile/Voucher.js'
 import { computeFallbackCloseAmount, sessionManager } from './SessionManager.js'
 
 const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
@@ -44,6 +45,24 @@ const client = createClient({
   }),
 })
 
+function channelStateClient(state: { closeRequestedAt: number; deposit: bigint; settled: bigint }) {
+  return createClient({
+    account,
+    chain: { id: 4217 } as never,
+    transport: custom({
+      async request(args) {
+        if (args.method === 'eth_call')
+          return encodeFunctionResult({
+            abi: escrowAbi,
+            functionName: 'getChannelState',
+            result: state,
+          })
+        throw new Error(`unexpected rpc request: ${args.method}`)
+      },
+    }),
+  })
+}
+
 const storedDescriptor = {
   authorizedSigner: account.address,
   expiringNonceHash: `0x${'11'.repeat(32)}` as Hex,
@@ -332,6 +351,17 @@ describe('Session', () => {
     test('seeds a same-route HEAD snapshot and resolves the account when resuming it', async () => {
       const { store, set } = makeChannelStore()
       const posted: SessionCredentialPayload[] = []
+      const highestVoucher = {
+        channelId: storedChannelId,
+        cumulativeAmount: '1000000',
+        signature: await Voucher.signVoucher(
+          client,
+          account,
+          { channelId: storedChannelId, cumulativeAmount: 1_000_000n },
+          tip20ChannelEscrow,
+          4217,
+        ),
+      }
       const resolveAccount = vi.fn(
         (info: Parameters<NonNullable<sessionManager.Parameters['resolveAccount']>>[0]) =>
           info.account,
@@ -356,6 +386,7 @@ describe('Session', () => {
                   deposit: '10000000',
                   descriptor: storedDescriptor,
                   escrow: tip20ChannelEscrow,
+                  highestVoucher,
                   requiredCumulative: '1000000',
                   settled: '0',
                   spent: '0',
@@ -372,7 +403,11 @@ describe('Session', () => {
           ? Credential.deserialize<SessionCredentialPayload>(authorization).payload
           : undefined
         if (payload) posted.push(payload)
-        if (!payload) return Promise.resolve(make402Response())
+        if (!payload) {
+          expect(s.channelId).toBe(storedChannelId)
+          expect(s.cumulative).toBe(1_000_000n)
+          return Promise.resolve(make402Response())
+        }
         return Promise.resolve(makeOkResponse())
       })
       const s = sessionManager({
@@ -389,8 +424,8 @@ describe('Session', () => {
       expect(response.status).toBe(200)
       expect(set).toHaveBeenCalledWith(expect.objectContaining({ channelId: storedChannelId }))
       expect(posted[0]).toMatchObject({ action: 'voucher', channelId: storedChannelId })
-      expect(resolveAccount).toHaveBeenCalledOnce()
-      expect(resolveAccount).toHaveBeenCalledWith({
+      expect(resolveAccount).toHaveBeenCalledTimes(2)
+      expect(resolveAccount).toHaveBeenNthCalledWith(1, {
         account,
         chainId: 4217,
         operation: { authority: account.address, kind: 'authorizePaymentChannel' },
@@ -399,6 +434,103 @@ describe('Session', () => {
       expect(new Headers(contentCall?.[1]?.headers).get('Payment-Session')).toBeNull()
     })
 
+    test('does not cache a server snapshot for a channel that is closed on-chain', async () => {
+      const { store, set } = makeChannelStore()
+      const highestVoucher = {
+        channelId: storedChannelId,
+        cumulativeAmount: '1000000',
+        signature: await Voucher.signVoucher(
+          client,
+          account,
+          { channelId: storedChannelId, cumulativeAmount: 1_000_000n },
+          tip20ChannelEscrow,
+          4217,
+        ),
+      }
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const headers = new Headers(init?.headers)
+        if (init?.method === 'HEAD' && !headers.get(Constants.Headers.authorization))
+          return Promise.resolve(make402Response(makeChargeChallenge()))
+        if (init?.method === 'HEAD')
+          return Promise.resolve(
+            new Response(null, {
+              status: 204,
+              headers: {
+                [Constants.Headers.paymentSessionSnapshot]: sessionManager.serializeSnapshot({
+                  acceptedCumulative: '1000000',
+                  chainId: 4217,
+                  channelId: storedChannelId,
+                  deposit: '10000000',
+                  descriptor: storedDescriptor,
+                  escrow: tip20ChannelEscrow,
+                  highestVoucher,
+                  requiredCumulative: '1000000',
+                  settled: '0',
+                  spent: '0',
+                  units: 0,
+                }),
+              },
+            }),
+          )
+        return Promise.resolve(makeOkResponse())
+      })
+      const s = sessionManager({
+        account,
+        bootstrap: true,
+        client: channelStateClient({ closeRequestedAt: 0, deposit: 0n, settled: 0n }),
+        fetch: mockFetch as typeof globalThis.fetch,
+        channelStore: store,
+      })
+
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(200)
+      expect(set).not.toHaveBeenCalled()
+    })
+
+    test('does not cache a server snapshot with an invalid highest voucher signature', async () => {
+      const { store, set } = makeChannelStore()
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const headers = new Headers(init?.headers)
+        if (init?.method === 'HEAD' && !headers.get(Constants.Headers.authorization))
+          return Promise.resolve(make402Response(makeChargeChallenge()))
+        if (init?.method === 'HEAD')
+          return Promise.resolve(
+            new Response(null, {
+              status: 204,
+              headers: {
+                [Constants.Headers.paymentSessionSnapshot]: sessionManager.serializeSnapshot({
+                  acceptedCumulative: '1000000',
+                  chainId: 4217,
+                  channelId: storedChannelId,
+                  deposit: '10000000',
+                  descriptor: storedDescriptor,
+                  escrow: tip20ChannelEscrow,
+                  highestVoucher: {
+                    channelId: storedChannelId,
+                    cumulativeAmount: '1000000',
+                    signature: `0x${'00'.repeat(64)}`,
+                  },
+                  requiredCumulative: '1000000',
+                  settled: '0',
+                  spent: '0',
+                  units: 0,
+                }),
+              },
+            }),
+          )
+        return Promise.resolve(makeOkResponse())
+      })
+      const s = sessionManager({
+        account,
+        bootstrap: true,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        channelStore: store,
+      })
+
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(200)
+      expect(set).not.toHaveBeenCalled()
+    })
+
     test('does not answer non-zero bootstrap charge challenges', async () => {
       const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
         const headers = new Headers(init?.headers)
@@ -477,6 +609,54 @@ describe('Session', () => {
       expect(s.channelId).not.toBe(storedChannelId)
     })
 
+    test('keeps a persisted channel after its committed top-up when the paid retry fails', async () => {
+      const seeded = channelEntry({ cumulativeAmount: 10_000_000n, deposit: 10_000_000n })
+      const { store, delete: remove, map } = makeChannelStore([seeded])
+      const postedPayloads: SessionCredentialPayload[] = []
+      let probes = 0
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        const payload = authorization
+          ? Credential.deserialize<SessionCredentialPayload>(authorization).payload
+          : undefined
+        if (!payload) {
+          probes++
+          if (probes > 1) throw new Error('unexpected fresh-channel retry')
+          return Promise.resolve(make402Response())
+        }
+
+        postedPayloads.push(payload)
+        if (payload.action === 'topUp') return Promise.resolve(new Response(null, { status: 204 }))
+        if (payload.action === 'voucher')
+          return Promise.resolve(new Response('upstream failed', { status: 500 }))
+        throw new Error(`unexpected ${payload.action} credential`)
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        maxDeposit: '20',
+        channelStore: store,
+      })
+
+      const response = await s.fetch('https://api.example.com/data')
+
+      expect(response.status).toBe(500)
+      expect(postedPayloads.map((payload) => payload.action)).toEqual(['topUp', 'voucher'])
+      expect(remove).not.toHaveBeenCalled()
+      expect(map.get(entryKey(seeded))).toMatchObject({
+        channelId: storedChannelId,
+        cumulativeAmount: 10_000_000n,
+        deposit: 11_000_000n,
+      })
+      expect(s.channelId).toBe(storedChannelId)
+      expect(s.state).toMatchObject({
+        status: 'active',
+        channelId: storedChannelId,
+        deposit: '11000000',
+      })
+    })
+
     test('rolls back an optimistic open when a replacement challenge does not reference it', async () => {
       const { store, delete: remove } = makeChannelStore()
       const postedPayloads: SessionCredentialPayload[] = []
@@ -621,10 +801,11 @@ describe('Session', () => {
       await restarted.fetch('https://api.example.com/data')
 
       // The first request carries no hint header; after the 402 the restarted
-      // manager resumes the persisted channel from the entry index with a
-      // voucher rather than opening a new one.
+      // manager tops up and resumes the full persisted channel rather than
+      // opening a new one.
       expect(new Headers(resumeFetch.mock.calls[0]?.[1]?.headers).get('Payment-Session')).toBeNull()
-      expect(posted[0]).toMatchObject({ action: 'voucher', channelId })
+      expect(posted.map((payload) => payload.action)).toEqual(['topUp', 'voucher'])
+      expect(posted[1]).toMatchObject({ channelId })
     })
 
     test('persists opened channels and deletes closed channels when supported', async () => {
@@ -855,6 +1036,7 @@ describe('Session', () => {
         client,
         fetch: mockFetch as typeof globalThis.fetch,
         maxDeposit: '10',
+        topUpAmount: '5',
       })
 
       await s.fetch('https://api.example.com/data')
@@ -862,10 +1044,13 @@ describe('Session', () => {
 
       expect(response.status).toBe(200)
       expect(postedPayloads.map((payload) => payload.action)).toEqual(['open', 'topUp', 'voucher'])
+      const topUp = postedPayloads[1]
+      if (topUp?.action !== 'topUp') throw new Error('expected top-up payload')
+      expect(topUp.additionalDeposit).toBe('5000000')
       expect(s.state).toMatchObject({
         status: 'active',
         acceptedCumulative: '2000000',
-        deposit: '2000000',
+        deposit: '6000000',
         spent: '2000000',
         units: 2,
       })
@@ -1082,7 +1267,7 @@ describe('Session', () => {
       expect(voucherPayload.channelId).toBe(openPayload.channelId)
       expect(voucherPayload.descriptor).toEqual(openPayload.descriptor)
       expect(voucherPayload.cumulativeAmount).toBe('2000000')
-      expect(requestedUrls[2]).toBe('https://api.example.com/stream')
+      expect(requestedUrls[2]).toBe('https://api.example.com/stream?prompt=paid')
     })
 
     test('ignores precompile SSE voucher requests for a different channel', async () => {
@@ -1266,6 +1451,51 @@ describe('Session', () => {
     })
   })
 
+  describe('.ws()', () => {
+    test('tops up a full persisted channel before constructing the socket', async () => {
+      const events: string[] = []
+      const { map, set, store } = makeChannelStore([
+        channelEntry({ cumulativeAmount: 1_000_000n, deposit: 1_000_000n }),
+      ])
+      set.mockImplementation((entry) => {
+        map.set(entryKey(entry), entry)
+        events.push(`set:${entry.deposit}:${entry.cumulativeAmount}`)
+      })
+      const fetch = vi.fn(async (_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization) {
+          events.push('probe')
+          return make402Response(makeChallenge({ suggestedDeposit: '1000000' }))
+        }
+        const payload = Credential.deserialize<SessionCredentialPayload>(authorization).payload
+        if (payload.action !== 'topUp') throw new Error(`unexpected ${payload.action} fetch`)
+        events.push('topUp')
+        return new Response(null, { status: 204 })
+      })
+      function WebSocket() {
+        events.push('socket')
+        throw new Error('stop after preparation')
+      }
+      const s = sessionManager({
+        account,
+        client,
+        fetch: fetch as typeof globalThis.fetch,
+        maxDeposit: '3',
+        channelStore: store,
+        webSocket: WebSocket as never,
+      })
+
+      await expect(s.ws('wss://api.example.com/socket')).rejects.toThrow('stop after preparation')
+      expect(events).toEqual([
+        'probe',
+        'topUp',
+        'set:2000000:1000000',
+        'set:2000000:2000000',
+        'socket',
+      ])
+    })
+  })
+
   describe('.close()', () => {
     test('is no-op when not opened', async () => {
       const mockFetch = vi.fn()
@@ -1321,6 +1551,7 @@ describe('Session', () => {
                     challengeId,
                     channelId: payload.channelId,
                     spent: BigInt(payload.cumulativeAmount),
+                    txHash: `0x${'aa'.repeat(32)}` as Hex,
                     units: 1,
                   }),
                 ),