mppx 0.8.14 → 0.8.17

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

@@ -3,6 +3,7 @@ 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'
@@ -16,6 +17,7 @@ import * as defaults from '../../internal/defaults.js'
 import * as Methods from '../../Methods.js'
 import * as Channel from '../precompile/Channel.js'
 import {
+  deserializeSessionReceipt,
   isEventStream,
   readSessionChallengeAmount,
   requireSessionCredentialContext,
@@ -35,6 +37,7 @@ import {
 } from './CredentialState.js'
 import { assertWithinMaxDeposit, resolveAutomaticTopUp } from './Runtime.js'
 import {
+  getSessionSnapshot,
   handleSseNeedVoucher,
   isTip1034SessionChallenge,
   postTopUp,
@@ -45,6 +48,67 @@ import {
 
 export { sessionContextSchema, type SessionContext } from './CredentialState.js'
 
+/** Tail promise for each payment scope, used to serialize automatic opens per store. */
+const channelTails = new WeakMap<ChannelStore, Map<string, Promise<void>>>()
+
+/** Serializes automatic opens for one payment scope across methods sharing a store. */
+async function lockChannel(store: ChannelStore, key: string) {
+  const tails = channelTails.get(store) ?? new Map<string, Promise<void>>()
+  channelTails.set(store, tails)
+  const previous = tails.get(key)
+  let unlock!: () => void
+  const current = new Promise<void>((resolve) => {
+    unlock = resolve
+  })
+  tails.set(key, current)
+  await previous
+  return () => {
+    unlock()
+    if (tails.get(key) === current) tails.delete(key)
+  }
+}
+
+function matchesOpen(
+  opened: ChannelEntry,
+  acknowledgement: { acceptedCumulative: string; channelId: string } | null | undefined,
+): boolean {
+  try {
+    return (
+      acknowledgement?.channelId.toLowerCase() === opened.channelId.toLowerCase() &&
+      BigInt(acknowledgement.acceptedCumulative) === opened.cumulativeAmount
+    )
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Returns whether the server acknowledged an open.
+ *
+ * Receipts must match the originating challenge, channel, and cumulative amount.
+ * Replacement challenges may acknowledge the same channel and amount through a
+ * session snapshot. Malformed acknowledgements are ignored.
+ */
+function acknowledgesOpen(
+  outcome: MethodResponse.AttemptOutcome,
+  challenge: TempoSessionChallenge,
+  opened: ChannelEntry,
+): boolean {
+  try {
+    const receiptHeader = outcome.response?.headers.get(Constants.Headers.paymentReceipt)
+    if (receiptHeader) {
+      const receipt = deserializeSessionReceipt(receiptHeader)
+      if (receipt.challengeId === challenge.id && matchesOpen(opened, receipt)) return true
+    }
+  } catch {}
+  return (
+    outcome.challenges?.some((candidate) => {
+      if (!isTip1034SessionChallenge(candidate)) return false
+      return matchesOpen(opened, getSessionSnapshot(candidate))
+    }) ?? false
+  )
+}
+
 /**
  * Creates the low-level TIP-1034 session payment method for use with `Mppx.create()`.
  *
@@ -100,30 +164,102 @@ export function session(parameters: session.Parameters = {}) {
     )
   }
 
+  const resolveCredentialPlan = async (
+    resolved: ChallengeContext,
+    context: CredentialContext | undefined,
+    entry: ChannelEntry | undefined,
+  ) =>
+    planCredential({
+      account: await resolveCredentialAccount(resolved, context, entry),
+      entry,
+      context,
+      decimals,
+      maxDeposit,
+      resolved,
+    })
+
   const method = Method.toClient(Methods.session, {
     canHandleChallenge: ({ challenge }) => isTip1034SessionChallenge(challenge),
     context: sessionContextSchema,
-    async createCredential({ challenge, context }) {
+    async createCredential(parameters) {
+      const { challenge, context } = parameters
       const resolved = await resolveChallengeContext({
         challenge,
         escrowOverride,
         getClient,
       })
-      const entry = await store.get(resolved.key)
-      const account = await resolveCredentialAccount(resolved, context, entry)
-      const payload = await executeCredentialPlan(
-        planCredential({
-          account,
-          entry,
-          context,
-          decimals,
-          maxDeposit,
-          resolved,
-        }),
-        sink,
-        AutoSwap.resolve(context?.autoSwap ?? autoSwapParameter, AutoSwap.defaultCurrencies),
-      )
-      return serializeCredential(challenge, payload, resolved.chainId, account)
+      const attempt = MethodResponse.getAttempt(parameters)
+      let release = () => {}
+      try {
+        let entry = await store.get(resolved.key)
+        let plan = await resolveCredentialPlan(resolved, context, entry)
+        if (attempt && plan.type === 'open') {
+          release = await lockChannel(store, resolved.key)
+          const nextEntry = await store.get(resolved.key)
+          if (nextEntry?.channelId !== entry?.channelId) {
+            entry = nextEntry
+            if (entry?.opened) {
+              await attempt.prepare()
+              entry = await store.get(resolved.key)
+            }
+            plan = await resolveCredentialPlan(resolved, context, entry)
+          }
+        }
+        let pendingOpen: ChannelEntry | undefined
+        // Defer opens only when low-level Fetch owns the response lifecycle.
+        // SessionManager unregisters this hook and keeps its existing transaction boundary.
+        const credentialSink =
+          attempt && plan.type === 'open'
+            ? {
+                store: {
+                  get: (key: string) => store.get(key),
+                  async set(next: ChannelEntry) {
+                    pendingOpen = next
+                  },
+                  delete: (key: string) => store.delete(key),
+                },
+                notifyUpdate() {},
+              }
+            : sink
+        const payload = await executeCredentialPlan(
+          plan,
+          credentialSink,
+          AutoSwap.resolve(context?.autoSwap ?? autoSwapParameter, AutoSwap.defaultCurrencies),
+        )
+        const credential = await serializeCredential(
+          challenge,
+          payload,
+          resolved.chainId,
+          plan.account,
+        )
+        if (attempt && pendingOpen) {
+          const opened = pendingOpen
+          attempt.settle = async (outcome) => {
+            const accepted =
+              outcome.status === 'accepted' || acknowledgesOpen(outcome, challenge, opened)
+            if (!accepted && outcome.status === 'pending') return false
+            try {
+              if (accepted) {
+                const current = await store.get(resolved.key)
+                if (
+                  !current?.opened ||
+                  current.channelId.toLowerCase() !== opened.channelId.toLowerCase()
+                ) {
+                  await store.set(opened)
+                  sink.notifyUpdate(opened)
+                }
+              }
+              return true
+            } finally {
+              release()
+            }
+          }
+        } else release()
+        return credential
+      } catch (error) {
+        release()
+        throw error
+      }
     },
   })
 

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

@@ -113,6 +113,20 @@ function makeChannelStore(seed: readonly ChannelEntry[] = []) {
   return { store, set, delete: remove, map }
 }
 
+function makeDurableChannelStore() {
+  const backend = new Map<string, string>()
+  const store = createJsonChannelStore({
+    get: (key) => backend.get(key),
+    set: (key, value) => {
+      backend.set(key, value)
+    },
+    delete: (key) => {
+      backend.delete(key)
+    },
+  })
+  return { backend, store }
+}
+
 function makeChallenge(overrides: Record<string, unknown> = {}): Challenge.Challenge {
   return Challenge.from({
     id: challengeId,
@@ -657,7 +671,7 @@ describe('Session', () => {
       })
     })
 
-    test('rolls back an optimistic open when a replacement challenge does not reference it', async () => {
+    test('rolls back optimistic opens across replacement challenges', async () => {
       const { store, delete: remove } = makeChannelStore()
       const postedPayloads: SessionCredentialPayload[] = []
       const challenge = (feePayer: boolean) =>
@@ -669,6 +683,8 @@ describe('Session', () => {
             feePayer,
           },
         })
+      const original = challenge(true)
+      const replacement = challenge(false)
       let openCount = 0
       const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
         const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
@@ -677,10 +693,11 @@ describe('Session', () => {
           : undefined
         if (payload) postedPayloads.push(payload)
 
-        if (!payload) return Promise.resolve(make402Response(challenge(true)))
+        if (!payload) return Promise.resolve(make402Response(original))
         if (payload.action === 'open') {
           openCount++
-          if (openCount === 1) return Promise.resolve(make402Response(challenge(false)))
+          if (openCount === 1) return Promise.resolve(make402Response(replacement))
+          if (openCount === 2) return Promise.resolve(make402Response(original))
           return Promise.resolve(makeOkResponse())
         }
         return Promise.resolve(new Response('unexpected voucher', { status: 500 }))
@@ -696,12 +713,33 @@ describe('Session', () => {
       const response = await s.fetch('https://api.example.com/data')
 
       expect(response.status).toBe(200)
-      // A replacement challenge with no snapshot means the server did not
-      // acknowledge the optimistic open, so the next credential must open again.
-      expect(postedPayloads.map((payload) => payload.action)).toEqual(['open', 'open'])
-      expect(postedPayloads[0]?.channelId).not.toBe(postedPayloads[1]?.channelId)
-      expect(remove).toHaveBeenCalledOnce()
-      expect(s.channelId).toBe(postedPayloads[1]?.channelId)
+      expect(postedPayloads.map((payload) => payload.action)).toEqual(['open', 'open', 'open'])
+      expect(new Set(postedPayloads.map((payload) => payload.channelId)).size).toBe(3)
+      expect(remove).toHaveBeenCalledTimes(2)
+      expect(s.channelId).toBe(postedPayloads[2]?.channelId)
+    })
+
+    test('reuses prepared voucher state when an identical challenge succeeds', async () => {
+      const vouchers: Extract<SessionCredentialPayload, { action: 'voucher' }>[] = []
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization) return Promise.resolve(make402Response())
+        const payload = Credential.deserialize<SessionCredentialPayload>(authorization).payload
+        if (payload.action !== 'voucher') throw new Error('expected voucher')
+        vouchers.push(payload)
+        return Promise.resolve(vouchers.length === 1 ? make402Response() : makeOkResponse())
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        channelStore: makeChannelStore([channelEntry()]).store,
+      })
+
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(200)
+      expect(vouchers.map((voucher) => voucher.cumulativeAmount)).toEqual(['2000000', '2000000'])
+      expect(s.cumulative).toBe(2_000_000n)
+      expect(s.state.status).toBe('active')
     })
 
     test('does not bootstrap when disabled', async () => {
@@ -989,6 +1027,60 @@ describe('Session', () => {
       })
     })
 
+    test('preserves a snapshot-acknowledged open when its voucher fails', async () => {
+      const { backend, store } = makeDurableChannelStore()
+      const payloads: SessionCredentialPayload[] = []
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization)
+          return Promise.resolve(make402Response(makeChallenge({ suggestedDeposit: '10000000' })))
+        const payload = Credential.deserialize<SessionCredentialPayload>(authorization).payload
+        payloads.push(payload)
+        if (payload.action !== 'open')
+          return Promise.resolve(new Response('failed', { status: 500 }))
+        return Promise.resolve(
+          make402Response(
+            makeChallenge({
+              methodDetails: {
+                escrowContract: tip20ChannelEscrow,
+                chainId: 4217,
+                sessionProtocol: Constants.SessionProtocols.v2,
+                sessionSnapshot: {
+                  acceptedCumulative: '1000000',
+                  chainId: 4217,
+                  channelId: payload.channelId,
+                  deposit: '10000000',
+                  descriptor: payload.descriptor,
+                  escrow: tip20ChannelEscrow,
+                  requiredCumulative: '2000000',
+                  settled: '0',
+                  spent: '1000000',
+                  units: 1,
+                },
+              },
+            }),
+          ),
+        )
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        maxDeposit: '10',
+        channelStore: store,
+      })
+
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(500)
+      expect(payloads.map((payload) => payload.action)).toEqual(['open', 'voucher'])
+      expect(s.channelId).toBe(payloads[0]?.channelId)
+      expect(s.cumulative).toBe(1_000_000n)
+      expect(JSON.parse([...backend.values()][0]!)).toMatchObject({
+        channelId: payloads[0]?.channelId,
+        cumulativeAmount: '1000000',
+        opened: true,
+      })
+    })
+
     test('preemptively top-ups before signing an HTTP voucher that exceeds deposit', async () => {
       const postedPayloads: SessionCredentialPayload[] = []
       let challengeCount = 0
@@ -1055,6 +1147,121 @@ describe('Session', () => {
         units: 2,
       })
     })
+
+    test('preserves a successful automatic top-up when the paid retry fails', async () => {
+      const { map, store } = makeChannelStore()
+      const payloads: SessionCredentialPayload[] = []
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization)
+          return Promise.resolve(make402Response(makeChallenge({ suggestedDeposit: '1000000' })))
+        const payload = Credential.deserialize<SessionCredentialPayload>(authorization).payload
+        payloads.push(payload)
+        if (payload.action === 'open')
+          return Promise.resolve(
+            new Response('ok', {
+              headers: {
+                [Constants.Headers.paymentReceipt]: serializeSessionReceipt(
+                  createSessionReceipt({
+                    acceptedCumulative: 1_000_000n,
+                    challengeId,
+                    channelId: payload.channelId,
+                    spent: 1_000_000n,
+                    units: 3,
+                  }),
+                ),
+              },
+            }),
+          )
+        if (payload.action === 'topUp') return Promise.resolve(new Response(null, { status: 204 }))
+        return Promise.resolve(make402Response(makeChallenge({ suggestedDeposit: '1000000' })))
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        maxDeposit: '3',
+        channelStore: store,
+      })
+
+      await s.fetch('https://api.example.com/data')
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(402)
+
+      expect(payloads.map((payload) => payload.action)).toEqual([
+        'open',
+        'topUp',
+        'voucher',
+        'voucher',
+        'voucher',
+      ])
+      expect(s.cumulative).toBe(1_000_000n)
+      expect(s.state).toMatchObject({ status: 'active', deposit: '2000000', units: 3 })
+      expect([...map.values()][0]).toMatchObject({
+        cumulativeAmount: 1_000_000n,
+        deposit: 2_000_000n,
+      })
+    })
+
+    test('preserves a topped-up resumed channel in durable storage after payment fails', async () => {
+      const { store } = makeDurableChannelStore()
+      const seeded = channelEntry({ cumulativeAmount: 1_000_000n, deposit: 1_000_000n })
+      await store.set(seeded)
+      const payloads: SessionCredentialPayload[] = []
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        if (!authorization)
+          return Promise.resolve(make402Response(makeChallenge({ suggestedDeposit: '1000000' })))
+        const payload = Credential.deserialize<SessionCredentialPayload>(authorization).payload
+        payloads.push(payload)
+        return Promise.resolve(
+          payload.action === 'topUp'
+            ? new Response(null, { status: 204 })
+            : new Response('failed', { status: 500 }),
+        )
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        maxDeposit: '3',
+        channelStore: store,
+      })
+
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(500)
+
+      expect(payloads.map((payload) => payload.action)).toEqual(['topUp', 'voucher'])
+      expect(s.cumulative).toBe(1_000_000n)
+      expect(s.state).toMatchObject({ status: 'active', deposit: '2000000' })
+      await expect(store.get(entryKey(seeded))).resolves.toMatchObject({
+        cumulativeAmount: 1_000_000n,
+        deposit: 2_000_000n,
+        opened: true,
+      })
+    })
+
+    test.each([
+      ['new', false],
+      ['replacement', true],
+    ] as const)('removes a failed %s durable channel', async (_kind, seeded) => {
+      const { backend, store } = makeDurableChannelStore()
+      if (seeded) await store.set(channelEntry())
+      const mockFetch = vi.fn().mockImplementation((_input, init?: RequestInit) => {
+        const authorization = new Headers(init?.headers).get(Constants.Headers.authorization)
+        return Promise.resolve(
+          authorization ? new Response('failed', { status: 500 }) : make402Response(),
+        )
+      })
+      const s = sessionManager({
+        account,
+        client,
+        fetch: mockFetch as typeof globalThis.fetch,
+        channelStore: store,
+      })
+
+      expect((await s.fetch('https://api.example.com/data')).status).toBe(500)
+      expect(s.channelId).toBeUndefined()
+      expect(backend.size).toBe(0)
+    })
   })
 
   describe('.topUp()', () => {

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

@@ -58,6 +58,7 @@ import { applyTopUpResult, resolveManualTopUp, type TopUpRequirement } from './T
 import {
   openWebSocketSession,
   prepareWebSocketSession,
+  probeWebSocketSession,
   type WebSocketDriverOptions,
 } from './Transports.js'
 
@@ -243,11 +244,14 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
 
   /** Removes a failed channel from candidacy for the rest of this manager's life. */
   async function ignoreChannel(entry: ChannelEntry) {
+    const key = entryKey(entry)
     ignoredChannelIds.add(entry.channelId)
-    await Promise.resolve(backing.delete(entryKey(entry))).catch(() => undefined)
+    channelUse?.seenExisting.delete(key)
+    if (channelUse?.resumed === entry) channelUse.resumed = undefined
+    await Promise.resolve(backing.delete(key)).catch(() => undefined)
   }
 
-  async function rollbackCreatedChannelsForRetry() {
+  async function rollbackCreatedChannels() {
     const use = channelUse
     if (!use?.created.size) return
     for (const [key, entry] of use.created) {
@@ -255,19 +259,31 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
       await Promise.resolve(backing.delete(key)).catch(() => undefined)
     }
     use.created.clear()
-    restoreRuntime(use.previous)
+    await restoreRuntime(use.committed ?? use.previous)
   }
 
-  function referencesCreatedChannel(challenge: Challenge.Challenge): boolean {
+  /** Commits a newly created channel once an authoritative server snapshot references it. */
+  function commitReferencedChannel(challenge: Challenge.Challenge): boolean {
     const snapshot = Constants.getMethodDetail<{ channelId?: unknown }>(
       challenge.request.methodDetails,
       Constants.MethodDetailKeys.sessionSnapshot,
     )
     if (typeof snapshot?.channelId !== 'string') return false
     const use = channelUse
-    if (!use?.created.size) return false
-    for (const entry of use.created.values()) {
-      if (entry.channelId.toLowerCase() === snapshot.channelId.toLowerCase()) return true
+    if (!use?.created.size || !runtime.channel) return false
+    for (const [key, entry] of use.created) {
+      if (
+        entry.channelId.toLowerCase() !== snapshot.channelId.toLowerCase() ||
+        runtime.channel.channelId.toLowerCase() !== snapshot.channelId.toLowerCase()
+      )
+        continue
+      use.created.delete(key)
+      use.committed = captureRuntimeStateSnapshot({
+        channel: runtime.channel,
+        spent: runtime.spent,
+        state: runtime.state,
+      })
+      return true
     }
     return false
   }
@@ -276,6 +292,14 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
     return dispatchSessionEvent(runtime, event)
   }
 
+  function activeUnits() {
+    const state =
+      runtime.state.status === 'active'
+        ? runtime.state
+        : (channelUse?.committed?.state ?? channelUse?.previous.state)
+    return state?.status === 'active' ? state.units : 0
+  }
+
   function commitDurableTopUp(entry: ChannelEntry) {
     const use = channelUse
     const baseline = use?.committed?.channel?.entry ?? use?.resumed
@@ -312,7 +336,7 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
           challengeId: runtime.lastChallenge.id,
           entry,
           spent: runtime.spent.toString(),
-          units: 0,
+          units: activeUnits(),
         })
       }
       commitDurableTopUp(entry)
@@ -332,11 +356,15 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
       const use = channelUse
       const isRepeatedRetryChallenge =
         use && use.challengesReceived > 0 && challenge.id === runtime.lastChallenge?.id
-      if (!referencesCreatedChannel(challenge)) {
-        if (use?.created.size) await rollbackCreatedChannelsForRetry()
-        else if (isRepeatedRetryChallenge) restoreRuntime(use.previous)
-      }
+      const isSameRetryChallenge =
+        isRepeatedRetryChallenge &&
+        Challenge.serialize(challenge) === Challenge.serialize(runtime.lastChallenge!)
       if (use) use.challengesReceived++
+      if (isSameRetryChallenge) return undefined
+      if (!commitReferencedChannel(challenge)) {
+        if (use?.created.size) await rollbackCreatedChannels()
+        else if (isRepeatedRetryChallenge) await restoreRuntime(use.committed ?? use.previous)
+      }
       runtime.lastChallenge = challenge
       dispatch({ type: 'challengeReceived', challengeId: challenge.id })
       return undefined
@@ -558,7 +586,7 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
         challengeId: runtime.lastChallenge.id,
         entry: applied.channel,
         spent: runtime.spent.toString(),
-        units: runtime.state.status === 'active' ? runtime.state.units : 0,
+        units: activeUnits(),
       })
       commitDurableTopUp(applied.channel)
     }
@@ -589,7 +617,7 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
     })
   }
 
-  function restoreCumulative(channelId: Hex.Hex, cumulativeAmount: bigint) {
+  async function restoreCumulative(channelId: Hex.Hex, cumulativeAmount: bigint) {
     const restored = restoreCumulativeAuthorization({
       channel: runtime.channel,
       channelId,
@@ -606,14 +634,16 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
         spent: restored.spent,
         units: restored.units,
       })
+      await backing.set(runtime.channel)
     }
   }
 
-  function restoreRuntime(snapshot: RuntimeSnapshot) {
+  async function restoreRuntime(snapshot: RuntimeSnapshot) {
     const restored = restoreRuntimeStateSnapshot(snapshot, runtime.channel)
     runtime.channel = restored.channel
     runtime.spent = restored.spent
     runtime.state = restored.state
+    if (runtime.channel?.opened) await backing.set(runtime.channel)
   }
 
   function toPaymentResponse(response: Response): PaymentResponse {
@@ -679,7 +709,8 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
         try {
           response = await wrappedFetch(input, effectiveInit)
         } catch (error) {
-          restoreRuntime(use.committed ?? previous)
+          if (use.created.size) await rollbackCreatedChannels()
+          else await restoreRuntime(use.committed ?? previous)
           if (await retryWithoutResumed()) continue
           throw error
         }
@@ -706,7 +737,8 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
           }
         }
         if (!attemptedHttpManagement && !paymentResponse.ok && !paymentResponse.receipt) {
-          restoreRuntime(use.committed ?? previous)
+          if (use.created.size) await rollbackCreatedChannels()
+          else await restoreRuntime(use.committed ?? previous)
           if (await retryWithoutResumed()) continue
           return paymentResponse
         }
@@ -838,6 +870,20 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
         setSocketSession(session) {
           runtime.socketSession = session
         },
+        async refreshChallenge() {
+          const refreshed = await probeWebSocketSession({
+            fetch: config.fetch,
+            input: httpUrl,
+            probeInit: requestInitWithSessionHint(
+              httpUrl,
+              signalInit,
+              runtime.channel?.opened ? runtime.channel.channelId : undefined,
+            ),
+            signal: init?.signal,
+          })
+          runtime.lastChallenge = refreshed.challenge
+          return refreshed.challenge
+        },
         assertVoucherWithinLocalLimit,
         acceptReceipt: updateSpentFromReceipt,
         rejectCloseReady: receipts.rejectCloseReady,