mppx 0.6.30 → 0.7.0

package/src/cli/cli.test.ts

@@ -4,16 +4,16 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import { pathToFileURL } from 'node:url'
 
-import { decodeFunctionData, erc20Abi, parseUnits, type Address } from 'viem'
+import { decodeFunctionData, parseUnits, type Address } from 'viem'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import { Addresses, Transaction } from 'viem/tempo'
 import { afterAll, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
-import { rpcUrl } from '~test/tempo/prool.js'
-import { deployEscrow, escrowAbi } from '~test/tempo/session.js'
+import { rpcUrl } from '~test/tempo/rpc.js'
 import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'
 
 import * as Challenge from '../Challenge.js'
+import * as Constants from '../Constants.js'
 import * as Credential from '../Credential.js'
 import * as Method from '../Method.js'
 import * as Receipt from '../Receipt.js'
@@ -22,7 +22,9 @@ import { toNodeListener } from '../server/Mppx.js'
 import * as Store from '../Store.js'
 import { stripe as stripe_server } from '../stripe/server/Methods.js'
 import { tempo } from '../tempo/server/Methods.js'
-import type { SessionCredentialPayload } from '../tempo/session/Types.js'
+import { escrowAbi } from '../tempo/session/precompile/escrow.abi.js'
+import { tip20ChannelEscrow } from '../tempo/session/precompile/Protocol.js'
+import type { SessionCredentialPayload } from '../tempo/session/precompile/Protocol.js'
 import * as z from '../zod.js'
 import cli from './cli.js'
 
@@ -798,7 +800,7 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
     await fundAccount({ address: testAccount.address, token: Addresses.pathUsd })
     await fundAccount({ address: testAccount.address, token: asset })
 
-    const escrow = await deployEscrow()
+    const escrow = tip20ChannelEscrow
     const store = Store.memory()
     const server = Mppx_server.create({
       methods: [
@@ -840,11 +842,11 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
     }
   })
 
-  test('prefers CLI deposit over server suggestedDeposit', { timeout: 120_000 }, async () => {
+  test('uses server suggestedDeposit within CLI max deposit', { timeout: 120_000 }, async () => {
     await fundAccount({ address: testAccount.address, token: Addresses.pathUsd })
     await fundAccount({ address: testAccount.address, token: asset })
 
-    const escrow = await deployEscrow()
+    const escrow = tip20ChannelEscrow
     let openCredential: SessionCredentialPayload | undefined
 
     const httpServer = await Http.createServer(async (req, res) => {
@@ -867,6 +869,7 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
                 methodDetails: {
                   chainId: chain.id,
                   escrowContract: escrow,
+                  sessionProtocol: Constants.SessionProtocols.v2,
                 },
               },
             }),
@@ -897,27 +900,18 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
 
       const transaction = Transaction.deserialize(openCredential.transaction)
       if (!('calls' in transaction)) throw new Error('unexpected transaction type')
-      const [approveCall, openCall] = transaction.calls as readonly [
-        { to?: Address; data?: `0x${string}` },
-        { to?: Address; data?: `0x${string}` },
-      ]
-      const approve = decodeFunctionData({ abi: erc20Abi, data: approveCall.data ?? '0x' })
+      const [openCall] = transaction.calls as readonly [{ to?: Address; data?: `0x${string}` }]
       const open = decodeFunctionData({ abi: escrowAbi, data: openCall.data ?? '0x' })
-      const approveArgs = approve.args as readonly [Address, bigint]
-      const openArgs = open.args as readonly [Address, Address, bigint, string, Address]
-
-      expect(approveCall.to).toBe(asset)
-      expect(approve.functionName).toBe('approve')
-      expect(approveArgs[0].toLowerCase()).toBe(escrow.toLowerCase())
-      expect(approveArgs[1]).toBe(10_000_000n)
+      const openArgs = open.args as readonly [Address, Address, Address, bigint, string, Address]
 
       expect(openCall.to?.toLowerCase()).toBe(escrow.toLowerCase())
       expect(open.functionName).toBe('open')
       expect(openArgs[0].toLowerCase()).toBe(accounts[0].address.toLowerCase())
-      expect(openArgs[1].toLowerCase()).toBe(asset.toLowerCase())
-      expect(openArgs[2]).toBe(10_000_000n)
-      expect(openArgs[3]).toEqual(expect.any(String))
-      expect(openArgs[4].toLowerCase()).toBe(testAccount.address.toLowerCase())
+      expect(openArgs[1]).toBe('0x0000000000000000000000000000000000000000')
+      expect(openArgs[2].toLowerCase()).toBe(asset.toLowerCase())
+      expect(openArgs[3]).toBe(7_000_000n)
+      expect(openArgs[4]).toEqual(expect.any(String))
+      expect(openArgs[5].toLowerCase()).toBe(testAccount.address.toLowerCase())
     } finally {
       httpServer.close()
     }
@@ -927,7 +921,7 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
     await fundAccount({ address: testAccount.address, token: Addresses.pathUsd })
     await fundAccount({ address: testAccount.address, token: asset })
 
-    const escrow = await deployEscrow()
+    const escrow = tip20ChannelEscrow
     const store = Store.memory()
     const tickAmount = '0.001'
     const server = Mppx_server.create({
@@ -991,7 +985,7 @@ describe('session multi-fetch (examples/session/multi-fetch)', () => {
     await fundAccount({ address: testAccount.address, token: Addresses.pathUsd })
     await fundAccount({ address: testAccount.address, token: asset })
 
-    const escrow = await deployEscrow()
+    const escrow = tip20ChannelEscrow
     const store = Store.memory()
     const server = Mppx_server.create({
       methods: [
@@ -1069,7 +1063,7 @@ describe('session sse (examples/session/sse)', () => {
     await fundAccount({ address: testAccount.address, token: Addresses.pathUsd })
     await fundAccount({ address: testAccount.address, token: asset })
 
-    const escrow = await deployEscrow()
+    const escrow = tip20ChannelEscrow
     const store = Store.memory()
     const server = Mppx_server.create({
       methods: [
@@ -1251,9 +1245,10 @@ describe('stripe charge', () => {
 
 // ---------------------------------------------------------------------------
 // account [action]
-// TODO: investigate account tests timing out in CI (secret-tool/gnome-keyring hangs)
+// Keychain tests are opt-in because macOS/Linux keychain commands can block on
+// developer machines without an unlocked keychain daemon.
 // ---------------------------------------------------------------------------
-describe.skipIf(!!process.env.CI)('account', () => {
+describe.runIf(process.env.MPPX_TEST_KEYCHAIN === 'true')('account', () => {
   const binPath = path.resolve(import.meta.dirname, '../bin.ts')
   const cwd = path.resolve(import.meta.dirname, '../..')
   const accountEnv = {

package/src/cli/cli.ts

@@ -11,6 +11,7 @@ import { tempo as tempoMainnet } from 'viem/tempo/chains'
 import * as Challenge from '../Challenge.js'
 import { normalizeHeaders } from '../client/internal/Fetch.js'
 import * as Mppx from '../client/Mppx.js'
+import * as Constants from '../Constants.js'
 import { validate as validateDiscovery } from '../discovery/Validate.js'
 import { createDefaultStore, createKeychain, resolveAccountName } from './account.js'
 import { loadConfig, resolveAcceptPayment, selectChallenge } from './internal.js'
@@ -32,6 +33,7 @@ import {
   printResponseHeaders,
   prompt,
   resolveChain,
+  resolveFundingNetwork,
   resolveRpcUrl,
 } from './utils.js'
 
@@ -373,7 +375,7 @@ const cli = Cli.create('mppx', {
       const { challenge, plugin, method: configMethod } = selected
       const selectedChallengeResponse = new Response(null, {
         status: 402,
-        headers: { 'WWW-Authenticate': Challenge.serialize(challenge) },
+        headers: { [Constants.Headers.wwwAuthenticate]: Challenge.serialize(challenge) },
       })
 
       let tokenSymbol = (challenge.request.currency as string | undefined) ?? ''
@@ -547,7 +549,7 @@ const cli = Cli.create('mppx', {
 
       if (!handled) {
         // Default: print receipt + body
-        const receiptHeader = credentialResponse.headers.get('Payment-Receipt')
+        const receiptHeader = credentialResponse.headers.get(Constants.Headers.paymentReceipt)
         if (receiptHeader && c.options.verbose >= 1) {
           try {
             const receiptJson = JSON.parse(Base64.toString(receiptHeader)) as Record<
@@ -704,8 +706,9 @@ const account = Cli.create('account', {
       const addrDisplay = explorerUrl
         ? link(`${explorerUrl}/address/${acct.address}`, acct.address)
         : acct.address
-      const rpcUrl = resolveRpcUrl(c.options.rpcUrl, { network: c.options.network })
-      resolveChain({ network: c.options.network, rpcUrl })
+      const fundingNetwork = resolveFundingNetwork(c.options)
+      const rpcUrl = resolveRpcUrl(c.options.rpcUrl, { network: fundingNetwork })
+      resolveChain({ network: fundingNetwork, rpcUrl })
         .then((chain) => createClient({ chain, transport: http(rpcUrl) }))
         .then((client) =>
           import('viem/tempo').then(({ Actions }) =>
@@ -715,6 +718,11 @@ const account = Cli.create('account', {
       return outputResult(c, { address: acct.address, name: resolvedName }, () => {
         console.log(`Account "${resolvedName}" saved to keychain.`)
         console.log(pc.dim(`Address ${addrDisplay}`))
+        console.log(
+          pc.dim(
+            `Fund testnet tokens: mppx account fund --account ${resolvedName} --network testnet`,
+          ),
+        )
       })
     },
   })
@@ -840,8 +848,9 @@ const account = Cli.create('account', {
           return c.error({ code: 'ACCOUNT_NOT_FOUND', message: 'No account found.', exitCode: 69 })
       }
       const acct = privateKeyToAccount(key as `0x${string}`)
-      const rpcUrl = resolveRpcUrl(c.options.rpcUrl, { network: c.options.network })
-      const chain = await resolveChain({ network: c.options.network, rpcUrl })
+      const fundingNetwork = resolveFundingNetwork(c.options)
+      const rpcUrl = resolveRpcUrl(c.options.rpcUrl, { network: fundingNetwork })
+      const chain = await resolveChain({ network: fundingNetwork, rpcUrl })
       const client = createClient({ chain, transport: http(rpcUrl) })
       if (!structured) console.log(`Funding "${accountName}" on ${chainName(chain)}`)
       try {
@@ -864,14 +873,18 @@ const account = Cli.create('account', {
           },
         )
       } catch (err) {
+        const message = err instanceof Error ? err.message : String(err)
         if (structured)
           return c.error({
             code: 'FUNDING_FAILED',
-            message: err instanceof Error ? err.message : String(err),
+            message,
             exitCode: 1,
           })
-        console.error('Funding failed:', err instanceof Error ? err.message : err)
-        return undefined as never
+        return c.error({
+          code: 'FUNDING_FAILED',
+          message: `Funding failed: ${message}`,
+          exitCode: 1,
+        })
       }
     },
   })
@@ -1145,7 +1158,7 @@ const sign = Cli.create('sign', {
     const wwwAuth = Challenge.serialize(challenge)
     const fakeResponse = new Response(null, {
       status: 402,
-      headers: { 'WWW-Authenticate': wwwAuth },
+      headers: { [Constants.Headers.wwwAuthenticate]: wwwAuth },
     })
 
     let credential: string

package/src/cli/mcp.test.ts

@@ -48,6 +48,14 @@ function createLineClient(child: ChildProcessWithoutNullStreams) {
   child.stderr.setEncoding('utf8')
   child.stdout.on('data', (chunk) => {
     buffer += chunk
+    drainLines()
+    drainJsonBuffer()
+  })
+  child.stderr.on('data', (chunk) => {
+    stderr += chunk
+  })
+
+  function drainLines() {
     for (;;) {
       const index = buffer.indexOf('\n')
       if (index === -1) break
@@ -60,10 +68,16 @@ function createLineClient(child: ChildProcessWithoutNullStreams) {
         nonJsonLines.push(line)
       }
     }
-  })
-  child.stderr.on('data', (chunk) => {
-    stderr += chunk
-  })
+  }
+
+  function drainJsonBuffer() {
+    const text = buffer.trim()
+    if (!text) return
+    try {
+      messages.push(JSON.parse(text))
+      buffer = ''
+    } catch {}
+  }
 
   return {
     get nonJsonLines() {
@@ -88,9 +102,9 @@ function createLineClient(child: ChildProcessWithoutNullStreams) {
         await new Promise((resolve) => setTimeout(resolve, 20))
       }
       throw new Error(
-        `Timed out waiting for MCP response ${id}. stderr=${stderr} nonJson=${JSON.stringify(
-          nonJsonLines,
-        )}`,
+        `Timed out waiting for MCP response ${id}. stderr=${stderr} buffer=${JSON.stringify(
+          buffer,
+        )} nonJson=${JSON.stringify(nonJsonLines)}`,
       )
     },
   }

package/src/cli/plugins/tempo.ts

@@ -11,10 +11,15 @@ import { createClient, http } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
 
 import { normalizeHeaders } from '../../client/internal/Fetch.js'
+import * as Constants from '../../Constants.js'
 import * as Credential from '../../Credential.js'
 import { tempo as tempoMethods } from '../../tempo/client/index.js'
-import type { SessionCredentialPayload } from '../../tempo/session/Types.js'
-import { signVoucher } from '../../tempo/session/Voucher.js'
+import { tip20ChannelEscrow } from '../../tempo/session/precompile/Protocol.js'
+import type {
+  ChannelDescriptor,
+  SessionCredentialPayload,
+} from '../../tempo/session/precompile/Protocol.js'
+import { signVoucher } from '../../tempo/session/precompile/Voucher.js'
 import { createDefaultStore, createKeychain, resolveAccountName } from '../account.js'
 import {
   fetchTokenInfo,
@@ -40,6 +45,7 @@ export function tempo() {
           chainId: number
           action?: 'voucher' | 'close'
         }): Promise<string>
+        descriptor?: ChannelDescriptor | undefined
         source: string
       }
     | undefined
@@ -176,7 +182,7 @@ export function tempo() {
         account,
         getClient: () => client!,
         ...(autoSwap !== undefined ? { autoSwap } : {}),
-        deposit: (() => {
+        maxDeposit: (() => {
           if (challenge.intent !== 'session') return undefined
           const suggestedDeposit = (challenge.request as Record<string, unknown>)
             .suggestedDeposit as string | undefined
@@ -209,6 +215,7 @@ export function tempo() {
 
       // Store session support for use in lifecycle hooks
       _session = {
+        descriptor: undefined,
         async signVoucher({
           channelId,
           cumulativeAmount,
@@ -216,11 +223,14 @@ export function tempo() {
           chainId,
           action = 'voucher',
         }) {
+          const descriptor = _session?.descriptor
+          if (!descriptor) throw new Error('session descriptor not available')
           return Credential.serialize({
             challenge,
             payload: {
               action,
               channelId,
+              descriptor,
               cumulativeAmount: cumulativeAmount.toString(),
               signature: await signVoucher(
                 client!,
@@ -260,16 +270,19 @@ export function tempo() {
       const parsed = Credential.deserialize<SessionCredentialPayload>(credential)
       const challengeRequest = challenge.request as Record<string, unknown>
       const sessionMd = challengeRequest.methodDetails as
-        | { escrowContract?: string; chainId?: number }
+        | { escrow?: string; escrowContract?: string; chainId?: number }
         | undefined
       const channelId = parsed.payload.channelId
-      const escrowContract = sessionMd?.escrowContract as Address | undefined
+      const escrowContract = (sessionMd?.escrowContract ??
+        sessionMd?.escrow ??
+        tip20ChannelEscrow) as Address
       const chainId = sessionMd?.chainId ?? 0
       const tickCost = BigInt(challengeRequest.amount as string)
       let cumulativeAmount =
         'cumulativeAmount' in parsed.payload && parsed.payload.cumulativeAmount
           ? BigInt(parsed.payload.cumulativeAmount)
           : 0n
+      if ('descriptor' in parsed.payload) _session.descriptor = parsed.payload.descriptor
 
       if (verbose >= 1) {
         if (parsed.payload.action === 'open') {
@@ -302,7 +315,7 @@ export function tempo() {
       }
 
       // Print receipt from initial response headers
-      const receiptHeader = credentialResponse.headers.get('Payment-Receipt')
+      const receiptHeader = credentialResponse.headers.get(Constants.Headers.paymentReceipt)
       if (receiptHeader) {
         try {
           const receiptJson = JSON.parse(Base64.toString(receiptHeader)) as Record<string, unknown>
@@ -556,7 +569,7 @@ async function handleSseStream(
           })
           await globalThis.fetch(opts.fetchUrl, {
             method: 'POST',
-            headers: { Authorization: voucherCred },
+            headers: { [Constants.Headers.authorization]: voucherCred },
           })
         } catch (e) {
           opts.info(pc.dim(pc.yellow(` [voucher failed: ${e instanceof Error ? e.message : e}]`)))
@@ -669,7 +682,7 @@ async function closeChannel(opts: {
   if (closeRes.ok) {
     deleteChannelState(opts.channelId)
     if (opts.verbose >= 1) {
-      const closeReceiptHeader = closeRes.headers.get('Payment-Receipt')
+      const closeReceiptHeader = closeRes.headers.get(Constants.Headers.paymentReceipt)
       let closeTxHash: string | undefined
       if (closeReceiptHeader) {
         try {

package/src/cli/utils.test.ts

@@ -1,7 +1,7 @@
 import { tempo as tempoMainnet, tempoModerato } from 'viem/tempo/chains'
 import { afterEach, describe, expect, test } from 'vp/test'
 
-import { networkRpcUrls, resolveChain, resolveRpcUrl } from './utils.js'
+import { networkRpcUrls, resolveChain, resolveFundingNetwork, resolveRpcUrl } from './utils.js'
 
 describe('resolveRpcUrl', () => {
   afterEach(() => {
@@ -52,6 +52,30 @@ describe('resolveRpcUrl', () => {
   })
 })
 
+describe('resolveFundingNetwork', () => {
+  afterEach(() => {
+    delete process.env.MPPX_RPC_URL
+    delete process.env.RPC_URL
+  })
+
+  test('defaults faucet funding to testnet', () => {
+    expect(resolveFundingNetwork()).toBe('testnet')
+  })
+
+  test('keeps explicit network selection', () => {
+    expect(resolveFundingNetwork({ network: 'mainnet' })).toBe('mainnet')
+  })
+
+  test('does not override explicit rpc url', () => {
+    expect(resolveFundingNetwork({ rpcUrl: 'https://explicit.example.com' })).toBeUndefined()
+  })
+
+  test('does not override env rpc urls', () => {
+    process.env.MPPX_RPC_URL = 'https://env.example.com'
+    expect(resolveFundingNetwork()).toBeUndefined()
+  })
+})
+
 describe('resolveChain', () => {
   afterEach(() => {
     delete process.env.MPPX_RPC_URL

package/src/cli/utils.ts

@@ -242,6 +242,16 @@ export function resolveRpcUrl(
   )
 }
 
+/** Select the default network for faucet funding without overriding explicit RPC configuration. */
+export function resolveFundingNetwork(
+  options: { network?: Network | undefined; rpcUrl?: string | undefined } = {},
+): Network | undefined {
+  if (options.network) return options.network
+  if (options.rpcUrl) return undefined
+  if (process.env.MPPX_RPC_URL?.trim() || process.env.RPC_URL?.trim()) return undefined
+  return 'testnet'
+}
+
 export async function resolveChain(
   opts: { network?: Network | undefined; rpcUrl?: string | undefined } = {},
 ): Promise<Chain> {

package/src/client/Methods.ts

@@ -1,5 +1,8 @@
 export { evm } from '../evm/client/index.js'
 export { stripe } from '../stripe/client/index.js'
 export { subscription } from '../tempo/client/Subscription.js'
-export { tempo } from '../tempo/client/index.js'
-export { session } from '../tempo/client/Session.js'
+export { session, tempo } from '../tempo/client/index.js'
+export { session as sessionMethod } from '../tempo/session/client/Session.js'
+export { sessionManager } from '../tempo/session/client/SessionManager.js'
+export { session as sessionLegacy } from '../tempo/legacy/client/index.js'
+export { sessionManager as sessionLegacyManager } from '../tempo/legacy/client/index.js'

package/src/client/Mppx.test-d.ts

@@ -10,10 +10,20 @@ import type * as AutoSwap from '../tempo/internal/auto-swap.js'
 import * as Methods from '../tempo/Methods.js'
 import * as z from '../zod.js'
 import * as Fetch from './internal/Fetch.js'
+import { session, sessionManager, sessionMethod } from './Methods.js'
 import * as Mppx from './Mppx.js'
 import * as Transport from './Transport.js'
 
 describe('Mppx', () => {
+  test('exports low-level session method and explicit managed session helper', () => {
+    expectTypeOf(session({ account: {} as Account })).toMatchTypeOf<Method.AnyClient>()
+    expectTypeOf(session.manager({ account: {} as Account })).toHaveProperty('fetch')
+    expectTypeOf(sessionManager({ account: {} as Account })).toHaveProperty('fetch')
+    expectTypeOf(sessionMethod({ account: {} as Account })).toMatchTypeOf<Method.AnyClient>()
+    expectTypeOf(tempo.session({ account: {} as Account })).toMatchTypeOf<Method.AnyClient>()
+    expectTypeOf(tempo.session.manager({ account: {} as Account })).toHaveProperty('fetch')
+  })
+
   test('has methods array', () => {
     const method = charge({
       account: {} as Account,

package/src/client/Mppx.test.ts

@@ -74,6 +74,81 @@ describe('Mppx.create', () => {
 })
 
 describe('createCredential', () => {
+  function sessionChallenge(id: string, sessionProtocol?: string) {
+    return {
+      expires: new Date(Date.now() + 60_000).toISOString(),
+      id,
+      intent: 'session',
+      method: 'tempo',
+      realm,
+      request: {
+        amount: '100',
+        currency: asset,
+        unitType: 'request',
+        methodDetails: {
+          chainId: 1,
+          escrowContract: '0x0000000000000000000000000000000000000001',
+          ...(sessionProtocol !== undefined ? { sessionProtocol } : {}),
+        },
+      },
+    } as const
+  }
+
+  function paymentRequiredResponse(...challenges: Challenge.Challenge[]) {
+    return new Response(null, {
+      status: 402,
+      headers: { 'WWW-Authenticate': challenges.map(Challenge.serialize).join(', ') },
+    })
+  }
+
+  function taggedSessionMethod(tag: string, canHandleChallenge: Method.CanHandleChallengeFn) {
+    return Method.toClient(Methods.session, {
+      canHandleChallenge,
+      async createCredential({ challenge }) {
+        return Credential.serialize({ challenge, payload: { tag } })
+      },
+    })
+  }
+
+  test('behavior: routes duplicate tempo/session client methods by sessionProtocol', async () => {
+    const tip1034 = taggedSessionMethod(
+      'v2',
+      ({ challenge }) =>
+        (challenge.request.methodDetails as { sessionProtocol?: string } | undefined)
+          ?.sessionProtocol === 'v2',
+    )
+    const legacy = taggedSessionMethod('v1', ({ challenge }) => {
+      const sessionProtocol = (
+        challenge.request.methodDetails as { sessionProtocol?: string } | undefined
+      )?.sessionProtocol
+      return sessionProtocol === undefined || sessionProtocol === 'v1'
+    })
+    const mppx = Mppx.create({ polyfill: false, methods: [tip1034, legacy] })
+
+    const [newCredential, legacyCredential, oldCredential] = await Promise.all([
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('new', 'v2'))),
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('v1', 'v1'))),
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('old'))),
+    ])
+    expect(Credential.deserialize(newCredential).payload).toEqual({ tag: 'v2' })
+    expect(Credential.deserialize(legacyCredential).payload).toEqual({ tag: 'v1' })
+    expect(Credential.deserialize(oldCredential).payload).toEqual({ tag: 'v1' })
+  })
+
+  test('behavior: rejects unknown tempo/session sessionProtocol', async () => {
+    const method = taggedSessionMethod(
+      'v2',
+      ({ challenge }) =>
+        (challenge.request.methodDetails as { sessionProtocol?: string } | undefined)
+          ?.sessionProtocol === 'v2',
+    )
+    const mppx = Mppx.create({ polyfill: false, methods: [method] })
+
+    await expect(
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('unknown', 'future'))),
+    ).rejects.toThrow('No method found for challenges: tempo.session')
+  })
+
   test('behavior: routes to correct method based on challenge', async () => {
     const mppx = Mppx.create({
       polyfill: false,

package/src/client/Transport.ts

@@ -1,4 +1,5 @@
 import * as Challenge from '../Challenge.js'
+import * as Constants from '../Constants.js'
 import * as Credential from '../Credential.js'
 import * as Mcp from '../Mcp.js'
 import * as x402_Header from '../x402/Header.js'
@@ -6,10 +7,8 @@ import * as x402_ChallengeBrand from '../x402/internal/ChallengeBrand.js'
 import * as x402_Types from '../x402/Types.js'
 
 const paymentRequiredStatus = 402
-const paymentAuthChallengeHeader = 'WWW-Authenticate'
-const paymentAuthCredentialHeader = 'Authorization'
 const credentialHeaders = [
-  paymentAuthCredentialHeader,
+  Constants.Headers.authorization,
   x402_Types.paymentRequiredHeader,
   x402_Types.paymentResponseHeader,
   x402_Types.paymentSignatureHeader,
@@ -107,7 +106,7 @@ export function http() {
       if (isX402Challenge(options?.challenge)) {
         headers.set(x402_Types.paymentSignatureHeader, credential)
       } else {
-        headers.set(paymentAuthCredentialHeader, credential)
+        headers.set(Constants.Headers.authorization, credential)
       }
       return { ...request, headers }
     },
@@ -116,7 +115,7 @@ export function http() {
 
 function paymentRequiredChallenges(response: Response): Challenge.Challenge[] {
   return [
-    ...(response.headers.has(paymentAuthChallengeHeader)
+    ...(response.headers.has(Constants.Headers.wwwAuthenticate)
       ? Challenge.fromResponseList(response)
       : []),
     ...x402Challenges(response),

package/src/client/index.ts

@@ -1,5 +1,15 @@
+export * as Constants from '../Constants.js'
 export * as Expires from '../Expires.js'
 export * as Fetch from './internal/Fetch.js'
-export { evm, session, stripe, tempo } from './Methods.js'
+export {
+  evm,
+  session,
+  sessionManager,
+  sessionMethod,
+  sessionLegacy,
+  sessionLegacyManager,
+  stripe,
+  tempo,
+} from './Methods.js'
 export * as Mppx from './Mppx.js'
 export * as Transport from './Transport.js'