mppx 0.8.12 → 0.8.13

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

@@ -9,6 +9,7 @@ import type { ChannelEntry } from '../client/ChannelOps.js'
 import type { SessionContext } from '../client/CredentialState.js'
 import {
   createSessionReceipt,
+  formatNeedVoucherEvent,
   serializeSessionReceipt,
   tip20ChannelEscrow,
   type ChannelDescriptor,
@@ -18,6 +19,7 @@ import { initialState, type SessionState } from './Runtime.js'
 import {
   applyTopUpResult,
   closeHttpSession,
+  consumeSseSessionResponse,
   createActiveSocketSession,
   driveSseResponse,
   isExpectedSocketReceipt,
@@ -112,9 +114,15 @@ describe('HttpManagement', () => {
     })
   }
 
-  function receiptHeader(acceptedCumulative: bigint, spent: bigint) {
+  function receiptHeader(acceptedCumulative: bigint, spent: bigint, challengeId = 'challenge-1') {
     return serializeSessionReceipt(
-      createSessionReceipt({ acceptedCumulative, challengeId: 'challenge-1', channelId, spent }),
+      createSessionReceipt({
+        acceptedCumulative,
+        challengeId,
+        channelId,
+        spent,
+        txHash: `0x${'aa'.repeat(32)}`,
+      }),
     )
   }
 
@@ -139,9 +147,12 @@ describe('HttpManagement', () => {
       )
     })
 
-    test('strips resource query state from management URLs', () => {
+    test('preserves query state and strips fragments from management URLs', () => {
       expect(managementInput('https://example.test/resource?cursor=abc').toString()).toBe(
-        'https://example.test/resource',
+        'https://example.test/resource?cursor=abc',
+      )
+      expect(managementInput('https://example.test/resource?cursor=abc#result').toString()).toBe(
+        'https://example.test/resource?cursor=abc',
       )
     })
 
@@ -185,7 +196,7 @@ describe('HttpManagement', () => {
         return 'top-up-credential'
       })
       const fetch = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
-        expect(input.toString()).toBe('https://example.test/resource')
+        expect(input.toString()).toBe('https://example.test/resource?cursor=abc')
         expect(init?.method).toBe('POST')
         expect(authorizationHeader(init)).toBe('top-up-credential')
         return new Response(null, {
@@ -301,16 +312,20 @@ describe('HttpManagement', () => {
       const entry = channel()
       const retryChallenge = { ...challenge(), id: 'challenge-2' } as TempoSessionChallenge
       const setChallenge = vi.fn()
-      const createSessionCredential = vi.fn(async (challenge_) => {
+      const closeAmounts: string[] = []
+      const createSessionCredential = vi.fn(async (challenge_, context: SessionContext) => {
+        if (context.action !== 'close') throw new Error('expected close context')
+        closeAmounts.push(context.cumulativeAmountRaw!)
         return `close-${challenge_.id}`
       })
+      const resolveSignedCloseAmount = vi.fn(() => '6')
       const fetch = vi
         .fn()
         .mockResolvedValueOnce(response402(retryChallenge))
         .mockResolvedValueOnce(
           new Response(null, {
             status: 200,
-            headers: { [Constants.Headers.paymentReceipt]: receiptHeader(5n, 5n) },
+            headers: { [Constants.Headers.paymentReceipt]: receiptHeader(6n, 6n, 'challenge-2') },
           }),
         )
 
@@ -318,18 +333,71 @@ describe('HttpManagement', () => {
         createSessionCredential,
         fetch,
         lastUrl: 'https://example.test/resource',
+        resolveSignedCloseAmount,
         signedCloseAmount: '5',
         setChallenge,
         target: { challenge: challenge(), channel: entry, channelId },
       })
 
-      expect(receipt?.spent).toBe('5')
+      expect(receipt?.spent).toBe('6')
       expect(setChallenge).toHaveBeenCalledWith(retryChallenge)
+      expect(resolveSignedCloseAmount).toHaveBeenCalledOnce()
+      expect(resolveSignedCloseAmount).toHaveBeenCalledWith(retryChallenge)
+      expect(closeAmounts).toEqual(['5', '6'])
       expect(createSessionCredential).toHaveBeenCalledTimes(2)
       expect(createSessionCredential.mock.calls[1]?.[0]).toMatchObject({ id: retryChallenge.id })
       expect(authorizationHeader(fetch.mock.calls[1]?.[1])).toBe('close-challenge-2')
     })
 
+    test('closeHttpSession rejects a receipt without settlement proof', async () => {
+      const receipt = serializeSessionReceipt(
+        createSessionReceipt({
+          acceptedCumulative: 5n,
+          challengeId: 'challenge-1',
+          channelId,
+          spent: 5n,
+        }),
+      )
+      await expect(
+        closeHttpSession({
+          createSessionCredential: async () => 'close-credential',
+          fetch: async () =>
+            new Response(null, {
+              headers: { [Constants.Headers.paymentReceipt]: receipt },
+            }),
+          lastUrl: 'https://example.test/resource',
+          signedCloseAmount: '5',
+          target: { challenge: challenge(), channel: channel(), channelId },
+        }),
+      ).rejects.toThrow('Session close response included a mismatched payment receipt.')
+    })
+
+    test('closeHttpSession rejects an invalid settlement transaction hash', async () => {
+      for (const txHash of ['0x1234', `0x${'gg'.repeat(32)}`]) {
+        const receipt = serializeSessionReceipt(
+          createSessionReceipt({
+            acceptedCumulative: 5n,
+            challengeId: 'challenge-1',
+            channelId,
+            spent: 5n,
+            txHash: txHash as Hex.Hex,
+          }),
+        )
+        await expect(
+          closeHttpSession({
+            createSessionCredential: async () => 'close-credential',
+            fetch: async () =>
+              new Response(null, {
+                headers: { [Constants.Headers.paymentReceipt]: receipt },
+              }),
+            lastUrl: 'https://example.test/resource',
+            signedCloseAmount: '5',
+            target: { challenge: challenge(), channel: channel(), channelId },
+          }),
+        ).rejects.toThrow('Session close response included a mismatched payment receipt.')
+      }
+    })
+
     test('closeHttpSession includes problem detail and challenge header on failure', async () => {
       await expect(
         closeHttpSession({
@@ -747,6 +815,80 @@ describe('SseDriver', () => {
       await vi.waitFor(() => expect(cancel).toHaveBeenCalledOnce())
     },
   )
+
+  test('keeps voucher events bound to the challenge that opened the stream', async () => {
+    const channelId = `0x${'01'.repeat(32)}` as Hex.Hex
+    const token = '0x20c0000000000000000000000000000000000001' as Address
+    const payee = '0x0000000000000000000000000000000000000002' as Address
+    const descriptor: ChannelDescriptor = {
+      authorizedSigner: '0x0000000000000000000000000000000000000001',
+      expiringNonceHash: `0x${'03'.repeat(32)}` as Hex.Hex,
+      operator: '0x0000000000000000000000000000000000000000',
+      payee,
+      payer: '0x0000000000000000000000000000000000000001',
+      salt: `0x${'02'.repeat(32)}` as Hex.Hex,
+      token,
+    }
+    const makeChallenge = (id: string) =>
+      Challenge.from({
+        id,
+        intent: Constants.Intents.session,
+        method: Constants.Methods.tempo,
+        realm: 'example.test',
+        request: {
+          amount: '1',
+          currency: token,
+          methodDetails: { chainId: 4217, escrowContract: tip20ChannelEscrow },
+          recipient: payee,
+          unitType: 'request',
+        },
+      }) as TempoSessionChallenge
+    const streamChallenge = makeChallenge('challenge-1')
+    let currentChallenge = streamChallenge
+    const createSessionCredential = vi.fn(async () => 'Payment credential')
+    const channel: ChannelEntry = {
+      chainId: 4217,
+      channelId,
+      cumulativeAmount: 1n,
+      deposit: 10n,
+      descriptor,
+      escrow: tip20ChannelEscrow,
+      opened: true,
+    }
+    const response = new Response(
+      formatNeedVoucherEvent({
+        acceptedCumulative: '1',
+        channelId,
+        deposit: '10',
+        requiredCumulative: '2',
+      }),
+      { headers: { 'Content-Type': 'text/event-stream' } },
+    )
+    const stream = consumeSseSessionResponse('https://example.test/stream', response, undefined, {
+      acceptReceipt() {},
+      assertVoucherWithinLocalLimit() {},
+      createSessionCredential,
+      async doFetch() {
+        throw new Error('unexpected resource fetch')
+      },
+      fetch: vi.fn(async () => new Response(null, { status: 204 })),
+      getChallenge: () => currentChallenge,
+      getChannel: () => channel,
+      managementInput: (input) => input,
+      async topUpIfNeeded() {},
+    })
+
+    currentChallenge = makeChallenge('challenge-2')
+    const frames: string[] = []
+    for await (const frame of stream) frames.push(frame)
+
+    expect(frames).toEqual([])
+    expect(createSessionCredential).toHaveBeenCalledOnce()
+    expect(createSessionCredential).toHaveBeenCalledWith(
+      streamChallenge,
+      expect.objectContaining({ action: 'voucher', cumulativeAmountRaw: '2' }),
+    )
+  })
 })
 
 describe('WsDriver', () => {

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

@@ -1,4 +1,4 @@
-import type { Hex } from 'ox'
+import { Hex } from 'ox'
 
 import * as Challenge from '../../../Challenge.js'
 import * as Fetch from '../../../client/internal/Fetch.js'
@@ -502,6 +502,8 @@ export type CloseHttpSessionParameters = {
   fetch: typeof globalThis.fetch
   /** Last paid resource URL; used as the management endpoint base. */
   lastUrl: RequestInfo | URL | null
+  /** Resolves the close amount again when the server refreshes the challenge. */
+  resolveSignedCloseAmount?: ((challenge: TempoSessionChallenge) => string) | undefined
   /** Final cumulative amount the client is willing to sign. */
   signedCloseAmount: string
   /** Stores a fresh close challenge when the first close credential expired. */
@@ -544,7 +546,7 @@ export function requestInitWithAuthorization(
   }
 }
 
-/** Returns the URL used for out-of-band management POSTs, stripping resource query state. */
+/** Returns the exact resource URL used for out-of-band management POSTs, without its fragment. */
 export function managementInput(input: RequestInfo | URL): RequestInfo | URL {
   try {
     const base =
@@ -555,7 +557,7 @@ export function managementInput(input: RequestInfo | URL): RequestInfo | URL {
         : input instanceof URL
           ? new URL(input)
           : new URL(String(input), base)
-    url.search = ''
+    url.hash = ''
     return url
   } catch {
     return input
@@ -682,12 +684,18 @@ export async function closeHttpSession(
     )
   }
 
-  const postClose = async (challenge: TempoSessionChallenge) => {
+  let closeChallenge = parameters.target.challenge
+  let signedCloseAmount = parameters.signedCloseAmount
+  const postClose = async (challenge: TempoSessionChallenge, refreshed = false) => {
+    closeChallenge = challenge
+    signedCloseAmount =
+      (refreshed ? parameters.resolveSignedCloseAmount?.(challenge) : undefined) ??
+      parameters.signedCloseAmount
     const credential = await parameters.createSessionCredential(challenge, {
       action: 'close',
       channelId: parameters.target.channelId,
       descriptor: parameters.target.channel.descriptor,
-      cumulativeAmountRaw: parameters.signedCloseAmount,
+      cumulativeAmountRaw: signedCloseAmount,
     })
     return parameters.fetch(parameters.lastUrl!, {
       method: 'POST',
@@ -700,7 +708,7 @@ export async function closeHttpSession(
     const challenge = Challenge.fromResponseList(response).find(isTempoSessionChallenge)
     if (challenge) {
       parameters.setChallenge?.(challenge)
-      response = await postClose(challenge)
+      response = await postClose(challenge, true)
     }
   }
   if (!response.ok) {
@@ -712,7 +720,21 @@ export async function closeHttpSession(
   }
 
   const receiptHeader = response.headers.get(Constants.Headers.paymentReceipt)
-  return receiptHeader ? deserializeSessionReceipt(receiptHeader) : undefined
+  if (!receiptHeader) return undefined
+  const receipt = deserializeSessionReceipt(receiptHeader)
+  if (
+    !receipt.txHash ||
+    !Hex.validate(receipt.txHash, { strict: true }) ||
+    Hex.size(receipt.txHash) !== 32 ||
+    !isExpectedCloseReceipt({
+      challengeId: closeChallenge.id,
+      channelId: parameters.target.channelId,
+      expectedCloseAmount: signedCloseAmount,
+      receipt,
+    })
+  )
+    throw new Error('Session close response included a mismatched payment receipt.')
+  return receipt
 }
 
 /** Options accepted by the auto-driving SSE session flow. */
@@ -723,6 +745,12 @@ export type SseDriverOptions = RequestInit & {
   signal?: AbortSignal | undefined
 }
 
+/** @internal Options used when consuming an already-paid SSE response. */
+export type SseResponseOptions = {
+  onReceipt?: ((receipt: SessionReceipt) => void) | undefined
+  signal?: AbortSignal | undefined
+}
+
 /** Dependencies the SSE driver needs from `SessionManager`. */
 export type OpenSseSessionParameters = {
   /** Creates a session credential for the selected challenge/context. */
@@ -784,18 +812,28 @@ export async function openSseSession(
   if (!isEventStream(response) && driver.getChannel()?.opened)
     response = await driver.doFetch(input, sseInit)
 
-  const challenge = driver.getChallenge()
+  return consumeSseSessionResponse(input, response, { onReceipt, signal }, driver)
+}
+
+/** @internal Consumes an already-paid SSE response with the session transport driver. */
+export function consumeSseSessionResponse(
+  input: RequestInfo | URL,
+  response: Response,
+  options: SseResponseOptions | undefined,
+  driver: OpenSseSessionParameters,
+): AsyncIterable<string> {
   if (!isEventStream(response)) throw new Error('SSE response is not an event stream.')
   if (!response.body) throw new Error('Response has no body.')
+  const challenge = driver.getChallenge()
 
   return iterateSseMessages({
     onNeedVoucher: (event) => handleSseNeedVoucher({ challenge, driver, input }, event),
     onReceipt(receipt) {
       driver.acceptReceipt(receipt)
-      onReceipt?.(receipt)
+      options?.onReceipt?.(receipt)
     },
     response,
-    signal,
+    signal: options?.signal,
   })
 }
 

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

@@ -0,0 +1,36 @@
+import type { ChannelEntry } from '../ChannelOps.js'
+import type { PaymentResponse, SessionManager } from '../SessionManager.js'
+import type { SseResponseOptions, TempoSessionChallenge } from '../Transports.js'
+
+type RehydrateParameters = {
+  channel: ChannelEntry
+  challenge: TempoSessionChallenge
+  input: RequestInfo | URL
+  spent: bigint
+}
+
+type SessionManagerInternals = {
+  consumeSseResponse(
+    input: RequestInfo | URL,
+    response: PaymentResponse,
+    options?: SseResponseOptions | undefined,
+  ): AsyncIterable<string>
+  rehydrate(parameters: RehydrateParameters): void
+}
+
+const internals = new WeakMap<SessionManager, SessionManagerInternals>()
+
+/** @internal Registers private transport and recovery hooks for a session manager. */
+export function registerSessionManagerInternals(
+  manager: SessionManager,
+  value: SessionManagerInternals,
+): void {
+  internals.set(manager, value)
+}
+
+/** @internal Returns private transport and recovery hooks for a session manager. */
+export function getSessionManagerInternals(manager: SessionManager): SessionManagerInternals {
+  const value = internals.get(manager)
+  if (!value) throw new Error('Session manager internals are unavailable.')
+  return value
+}

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

@@ -62,6 +62,7 @@ function createMockClient(
         parameters.rpcMethods?.push(args.method)
         parameters.onRequest?.(args.method, args.params)
         if (args.method === 'eth_chainId') return `0x${chainId.toString(16)}`
+        if (args.method === 'eth_sendTransaction') return txHash
         if (args.method === 'eth_sendRawTransaction') return txHash
         if (args.method === 'eth_sendRawTransactionSync') return parameters.receipt ?? receipt([])
         if (args.method === 'eth_getTransactionReceipt') return parameters.receipt ?? null
@@ -290,6 +291,31 @@ describe('precompile receipt wait', () => {
   })
 })
 
+describe('precompile server transactions', () => {
+  test('does not add a fee-payer signature when the sender and fee payer are the same account', async () => {
+    const rpcMethods: string[] = []
+    const client = createMockClient({ rpcMethods })
+    const sender = { address: feePayer.address, type: 'json-rpc' } as const
+
+    await Chain.closeOnChain(
+      client,
+      descriptor,
+      1n,
+      1n,
+      `0x${'11'.repeat(65)}`,
+      tip20ChannelEscrow,
+      {
+        account: sender,
+        candidateFeeTokens: [descriptor.token],
+        feePayer,
+      },
+    )
+
+    expect(rpcMethods).toContain('eth_sendTransaction')
+    expect(rpcMethods).not.toContain('eth_sendRawTransactionSync')
+  })
+})
+
 describe('precompile open calldata parsing', () => {
   test('parseOpenCall accepts TIP-1034 open calldata', () => {
     const data = encodeFunctionData({

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

@@ -1001,8 +1001,11 @@ async function sendPrecompileTransaction(
   label: string,
   options?: ChannelTransactionOptions,
 ): Promise<Hex> {
-  if (options?.feePayer) {
-    const account = options.account ?? client.account
+  const account = options?.account ?? client.account
+  const selfSponsored =
+    account && options?.feePayer && isAddressEqual(account.address, options.feePayer.address)
+
+  if (options?.feePayer && !selfSponsored) {
     if (!account) throw new Error(`Cannot ${label} precompile channel: no account available.`)
     const feeToken =
       options.feeToken ??
@@ -1033,10 +1036,20 @@ async function sendPrecompileTransaction(
     return receipt.transactionHash
   }
 
+  const feeToken =
+    options?.feeToken ??
+    (selfSponsored
+      ? await resolveFeeToken({
+          account: account.address,
+          candidateTokens: options?.candidateFeeTokens,
+          client,
+        })
+      : undefined)
+
   return sendPrecompileContractCall(client, {
-    account: options?.account,
+    account,
     to,
     data,
-    feeToken: options?.feeToken,
+    feeToken,
   })
 }

package/src/tempo/session/server/CredentialVerification.ts

@@ -30,7 +30,7 @@ import {
 import * as Voucher from '../precompile/Voucher.js'
 import * as ChannelStore from './ChannelStore.js'
 import { getChallengePaymentFields } from './RequestState.js'
-import { assertSettlementSender, getClientAccount } from './Settlement.js'
+import { assertSettlementSender, getClientAccount, type OnSessionSettlement } from './Settlement.js'
 
 /** Returns the effective voucher signer for a TIP-1034 descriptor. */
 export function authorizedSigner(descriptor: Channel.ChannelDescriptor): Address {
@@ -344,6 +344,8 @@ export type VerifyCredentialPayloadParameters = {
   lastOnChainVerified: Map<Hex, number>
   /** Minimum allowed voucher delta in raw units. */
   minVoucherDelta: bigint
+  /** Callback invoked after an on-chain settlement or close transaction is confirmed. */
+  onSessionSettlement?: OnSessionSettlement | undefined
   /** Discriminated session credential payload to verify. */
   payload: SessionCredentialPayload
   /** Server-side channel store. */
@@ -747,6 +749,21 @@ async function handleCloseCredential(
       signature: payload.signature,
     }),
   )
+  if (parameters.onSessionSettlement && txHash) {
+    try {
+      await parameters.onSessionSettlement(
+        Object.freeze({
+          txHash,
+          channelId,
+          trigger: 'close' as const,
+          amount: settledToPayee,
+          delta: settledToPayee - state.settled,
+        }),
+      )
+    } catch {
+      // Errors are isolated — observers cannot break the settlement flow.
+    }
+  }
   return createSessionReceipt({
     challengeId: challenge.id,
     channelId,

package/src/tempo/session/server/MeteredStream.ts

@@ -12,8 +12,14 @@ export type SessionController = {
    * The reservation blocks until sufficient voucher headroom exists, but the
    * charge is only committed once a chunk is actually emitted. If the stream
    * ends or aborts before that emission, the reservation is dropped.
+   *
+   * Pass an explicit raw-unit `amount` for request-aware or otherwise dynamic
+   * pricing. When omitted, the session challenge's configured tick cost is
+   * used.
    */
-  charge(): Promise<void>
+  charge(amount?: bigint): Promise<void>
+  /** Aborted when the client closes or requests the final session receipt. */
+  signal: AbortSignal
 }
 
 /** Async stream source accepted by paid session transports. */
@@ -49,7 +55,7 @@ export async function* meterIterable(options: MeteredStreamOptions): AsyncGenera
   let reservedAmount = 0n
   let reservedUnits = 0
 
-  const charge = async () => {
+  const charge = async (amount = options.tickCost) => {
     if (prepaidUnits > 0) {
       prepaidUnits -= 1
       return
@@ -58,19 +64,20 @@ export async function* meterIterable(options: MeteredStreamOptions): AsyncGenera
     await reserveChargeOrWait({
       store: options.store,
       channelId: options.channelId,
-      amount: options.tickCost,
+      amount,
       reservedAmount,
       emit: options.emitNeedVoucher,
       formatNeedVoucher: options.formatNeedVoucher,
       pollIntervalMs: options.pollIntervalMs,
       signal: options.signal,
     })
-    reservedAmount += options.tickCost
+    reservedAmount += amount
     reservedUnits += 1
   }
 
+  const signal = options.signal ?? new AbortController().signal
   const iterable =
-    typeof options.generate === 'function' ? options.generate({ charge }) : options.generate
+    typeof options.generate === 'function' ? options.generate({ charge, signal }) : options.generate
 
   for await (const value of iterable) {
     if (options.signal?.aborted) break

package/src/tempo/session/server/RequestState.test.ts

@@ -316,7 +316,11 @@ describe('SessionSnapshotHints', () => {
       escrowContract,
       expiringNonceHash: descriptor.expiringNonceHash,
       finalized: false,
-      highestVoucher: null,
+      highestVoucher: {
+        channelId,
+        cumulativeAmount: 500n,
+        signature: `0x${'44'.repeat(64)}`,
+      },
       highestVoucherAmount: 500n,
       operator: descriptor.operator,
       payee: descriptor.payee,
@@ -451,6 +455,11 @@ describe('SessionSnapshotHints', () => {
         deposit: '1000',
         descriptor,
         escrow: escrowContract,
+        highestVoucher: {
+          channelId,
+          cumulativeAmount: '500',
+          signature: `0x${'44'.repeat(64)}`,
+        },
         requiredCumulative: '350',
         settled: '100',
         spent: '300',
@@ -458,7 +467,7 @@ describe('SessionSnapshotHints', () => {
       })
     })
 
-    test('raises accepted cumulative when next request exceeds current authorization', async () => {
+    test('keeps accepted cumulative at the signed voucher when the next request needs more', async () => {
       const snapshot = await resolveSessionSnapshot({
         amount: 300n,
         channelId,
@@ -466,7 +475,34 @@ describe('SessionSnapshotHints', () => {
       })
 
       expect(snapshot?.requiredCumulative).toBe('600')
-      expect(snapshot?.acceptedCumulative).toBe('600')
+      expect(snapshot?.acceptedCumulative).toBe('500')
+      expect(snapshot?.highestVoucher?.cumulativeAmount).toBe('500')
+    })
+
+    test('omits reusable channel hints without a matching signed highest voucher', async () => {
+      await expect(
+        resolveSessionSnapshot({
+          amount: 50n,
+          channelId,
+          store: store(channel({ highestVoucher: null })),
+        }),
+      ).resolves.toBeUndefined()
+
+      await expect(
+        resolveSessionSnapshot({
+          amount: 50n,
+          channelId,
+          store: store(
+            channel({
+              highestVoucher: {
+                channelId,
+                cumulativeAmount: 499n,
+                signature: `0x${'44'.repeat(64)}`,
+              },
+            }),
+          ),
+        }),
+      ).resolves.toBeUndefined()
     })
 
     test('omits reusable channel hints when payment fields do not match', async () => {

package/src/tempo/session/server/RequestState.ts

@@ -80,7 +80,11 @@ export type ResolveSessionChannelIdParameters = {
   store: ChannelStore.ChannelStore
 }
 
-/** Application hook for mapping request identity to an existing session channel. */
+/**
+ * Application-owned lookup from authenticated identity and payment scope to an existing session
+ * channel. MPPx does not derive a storage key or scan the channel store; the returned channel ID is
+ * loaded and independently validated before its snapshot is advertised.
+ */
 export type ResolveSessionChannelId = (
   parameters: ResolveSessionChannelIdParameters,
 ) => Promise<string | null | undefined> | string | null | undefined
@@ -139,14 +143,12 @@ export async function resolveSessionSnapshot(
   const channel = await store.getChannel(ChannelStore.normalizeChannelId(channelId))
   if (!channel || !ChannelStore.isPrecompileState(channel)) return undefined
   if (channel.finalized) return undefined
+  if (!channel.highestVoucher) return undefined
+  if (channel.highestVoucher.cumulativeAmount !== channel.highestVoucherAmount) return undefined
   if (expected && !matchesSnapshotPaymentFields(channel, expected)) return undefined
   const requiredCumulative = channel.spent + amount
-  const acceptedCumulative =
-    channel.highestVoucherAmount > requiredCumulative
-      ? channel.highestVoucherAmount
-      : requiredCumulative
   return {
-    acceptedCumulative: acceptedCumulative.toString(),
+    acceptedCumulative: channel.highestVoucherAmount.toString(),
     chainId: channel.chainId,
     channelId: channel.channelId,
     closeRequestedAt:
@@ -154,6 +156,11 @@ export async function resolveSessionSnapshot(
     deposit: channel.deposit.toString(),
     descriptor: channel.descriptor,
     escrow: channel.escrowContract,
+    highestVoucher: {
+      channelId: channel.highestVoucher.channelId,
+      cumulativeAmount: channel.highestVoucher.cumulativeAmount.toString(),
+      signature: channel.highestVoucher.signature,
+    },
     requiredCumulative: requiredCumulative.toString(),
     settled: channel.settledOnChain.toString(),
     spent: channel.spent.toString(),