mppx 0.8.14 → 0.8.17

package/src/discovery/OpenApi.test.ts

@@ -1,3 +1,4 @@
+import * as Challenge from '../Challenge.js'
 import * as Method from '../Method.js'
 import * as Mppx from '../server/Mppx.js'
 import * as z from '../zod.js'
@@ -56,6 +57,8 @@ const subscribe = Method.toServer(
       credential: { payload: z.object({ signature: z.string() }) },
       request: z.object({
         amount: z.string(),
+        interval: z.string(),
+        recipient: z.string(),
       }),
     },
   }),
@@ -69,6 +72,38 @@ const subscribe = Method.toServer(
   },
 )
 
+const transformedCharge = Method.toServer(
+  Method.from({
+    intent: 'charge',
+    name: 'transformed',
+    schema: {
+      credential: { payload: z.object({ signature: z.string() }) },
+      request: z.pipe(
+        z.object({
+          amount: z.string(),
+          asset: z.string(),
+          decimals: z.number(),
+          recipient: z.string(),
+        }),
+        z.transform(({ amount, asset, decimals, recipient }) => ({
+          amount: String(Number(amount) * 10 ** decimals),
+          currency: asset,
+          methodDetails: { decimals },
+          recipient,
+        })),
+      ),
+    },
+  }),
+  {
+    verify: async () => ({
+      method: 'transformed',
+      reference: '',
+      status: 'success' as const,
+      timestamp: '',
+    }),
+  },
+)
+
 function createMppx<const methods extends Mppx.Methods>(methods: methods) {
   return Mppx.create({
     methods,
@@ -169,6 +204,7 @@ describe('generate', () => {
                   {
                     "amount": "50",
                     "currency": "usd",
+                    "description": "Search credits",
                     "intent": "charge",
                     "method": "tempo",
                     "recipient": "0x1",
@@ -182,6 +218,140 @@ describe('generate', () => {
     `)
   })
 
+  test('matches handler discovery to its canonical runtime challenge', async () => {
+    const mppx = createMppx([transformedCharge])
+    const handler = mppx.charge({
+      amount: '2',
+      asset: '0xUSDC',
+      decimals: 6,
+      description: 'Canonical price',
+      recipient: '0x1',
+    })
+
+    const doc = generate(mppx, {
+      routes: [{ handler, method: 'post', path: '/api/resource' }],
+    }) as any
+    const result = await handler(new Request('https://example.com/api/resource'))
+    if (result.status !== 402) throw new Error('Expected payment challenge')
+    const challenge = Challenge.fromResponse(result.challenge)
+
+    expect(doc.paths['/api/resource'].post['x-payment-info'].offers[0]).toEqual({
+      amount: challenge.request.amount,
+      currency: challenge.request.currency,
+      description: challenge.description,
+      intent: challenge.intent,
+      method: challenge.method,
+      recipient: challenge.request.recipient,
+    })
+  })
+
+  test('applies method schema transforms to legacy route discovery', () => {
+    const mppx = createMppx([transformedCharge])
+    const doc = generate(mppx, {
+      routes: [
+        {
+          intent: 'charge',
+          method: 'post',
+          options: {
+            amount: '2',
+            asset: '0xUSDC',
+            decimals: 6,
+            description: 'Canonical price',
+            recipient: '0x1',
+          },
+          path: '/api/resource',
+        },
+      ],
+    }) as any
+
+    expect(doc.paths['/api/resource'].post['x-payment-info'].offers[0]).toEqual({
+      amount: '2000000',
+      currency: '0xUSDC',
+      description: 'Canonical price',
+      intent: 'charge',
+      method: 'transformed',
+      recipient: '0x1',
+    })
+  })
+
+  test('derives only explicitly composed payment offers from a handler', () => {
+    const mppx = createMppx([charge, session])
+    const handler = mppx.compose(
+      ['tempo/charge', { amount: '50', currency: '0xUSDC', description: 'USDC', recipient: '0x1' }],
+      [
+        'tempo/charge',
+        { amount: '50', currency: '0xNANOUSD', description: 'NANOUSD', recipient: '0x1' },
+      ],
+    )
+
+    const doc = generate(mppx, {
+      routes: [{ handler, method: 'post', path: '/api/search' }],
+    }) as any
+
+    expect(doc.paths['/api/search'].post['x-payment-info'].offers).toEqual([
+      {
+        amount: '50',
+        currency: '0xUSDC',
+        description: 'USDC',
+        intent: 'charge',
+        method: 'tempo',
+        recipient: '0x1',
+      },
+      {
+        amount: '50',
+        currency: '0xNANOUSD',
+        description: 'NANOUSD',
+        intent: 'charge',
+        method: 'tempo',
+        recipient: '0x1',
+      },
+    ])
+  })
+
+  test('keeps nested composed discovery in runtime challenge order', async () => {
+    const mppx = createMppx([charge])
+    const handler = Mppx.compose(
+      mppx.charge({
+        amount: '1',
+        currency: '0xUSDC',
+        description: 'USDC',
+        recipient: '0x1',
+      }),
+      Mppx.compose(
+        mppx.charge({
+          amount: '2',
+          currency: '0xNANOUSD',
+          description: 'NANOUSD',
+          recipient: '0x1',
+        }),
+        mppx.charge({
+          amount: '3',
+          currency: 'usd',
+          description: 'Card',
+          recipient: '0x1',
+        }),
+      ),
+    )
+
+    const doc = generate(mppx, {
+      routes: [{ handler, method: 'post', path: '/api/search' }],
+    }) as any
+    const result = await handler(new Request('https://example.com/api/search'))
+    if (result.status !== 402) throw new Error('Expected payment challenge')
+
+    const discovered = doc.paths['/api/search'].post['x-payment-info'].offers
+    const challenged = Challenge.fromResponseList(result.challenge).map((challenge) => ({
+      amount: challenge.request.amount,
+      currency: challenge.request.currency,
+      description: challenge.description,
+      intent: challenge.intent,
+      method: challenge.method,
+      recipient: challenge.request.recipient,
+    }))
+
+    expect(discovered).toEqual(challenged)
+  })
+
   test('handles null amount for session intent', () => {
     const mppx = createMppx([session])
     const doc = generate(mppx, {

package/src/discovery/OpenApi.ts

@@ -1,12 +1,11 @@
 import type * as Method from '../Method.js'
+import * as PaymentRequest from '../PaymentRequest.js'
 import { PaymentInfo, type ServiceInfo } from './Discovery.js'
+import * as Metadata from './internal/Metadata.js'
 
+/** Payment handler carrying metadata used to generate discovery documents. */
 export type DiscoveryHandler = ((...args: any[]) => unknown) & {
-  _internal?: {
-    _canonicalRequest: Record<string, unknown>
-    intent: string
-    name: string
-  }
+  _internal?: Metadata.Metadata
 }
 
 export type LegacyRouteConfig = {
@@ -151,11 +150,9 @@ function resolveRoute(
     return {
       method: route.method,
       path: route.path,
-      payment: paymentInfoFromCanonical({
-        canonicalRequest: internal._canonicalRequest,
-        intent: internal.intent,
-        method: internal.name,
-      }),
+      payment: {
+        offers: Metadata.offers(internal).map(Metadata.paymentOffer),
+      },
       ...(route.requestBody ? { requestBody: route.requestBody } : {}),
       ...(route.summary ? { summary: route.summary } : {}),
     }
@@ -168,52 +165,23 @@ function resolveRoute(
     )
   }
 
+  const { description, ...options } = route.options
+  const metadata: Metadata.Offer = {
+    _canonicalRequest: PaymentRequest.fromMethod(mi, options as never),
+    ...(typeof description === 'string' ? { description } : {}),
+    intent: mi.intent,
+    name: mi.name,
+  }
+
   return {
     method: route.method,
     path: route.path,
-    payment: paymentInfoFromCanonical({
-      canonicalRequest: route.options,
-      intent: mi.intent,
-      method: mi.name,
-    }),
+    payment: Metadata.paymentOffer(metadata),
     ...(route.requestBody ? { requestBody: route.requestBody } : {}),
     ...(route.summary ? { summary: route.summary } : {}),
   }
 }
 
-function paymentInfoFromCanonical(route: {
-  canonicalRequest: Record<string, unknown>
-  intent: string
-  method: string
-}) {
-  const { canonicalRequest, intent, method } = route
-  const methodDetails = (canonicalRequest.methodDetails ?? {}) as Record<string, unknown>
-
-  const amount = pickString(canonicalRequest.amount) ?? pickString(methodDetails.amount) ?? null
-  const currency = pickString(canonicalRequest.currency) ?? pickString(methodDetails.currency)
-  const description = pickString(canonicalRequest.description)
-
-  const base: Record<string, unknown> = {
-    amount,
-    ...(currency ? { currency } : {}),
-    ...(description ? { description } : {}),
-    intent,
-    method,
-  }
-
-  // Forward any extra canonical params that aren't already covered.
-  const reserved = new Set(['amount', 'currency', 'description', 'methodDetails'])
-  for (const [key, value] of Object.entries(canonicalRequest)) {
-    if (!reserved.has(key) && value !== undefined) base[key] = value
-  }
-
-  return base
-}
-
-function pickString(value: unknown) {
-  return typeof value === 'string' ? value : undefined
-}
-
 function withBasePath(basePath: string | undefined, path: string) {
   if (!basePath) return path
   const normalizedBasePath = basePath.startsWith('/') ? basePath : `/${basePath}`

package/src/discovery/internal/Metadata.ts

@@ -0,0 +1,51 @@
+/** Metadata retained by one explicitly configured payment handler. */
+export type Offer = {
+  _canonicalRequest: Record<string, unknown>
+  description?: string | undefined
+  intent: string
+  name: string
+}
+
+/** Metadata retained by a single or composed payment handler. */
+export type Metadata = Offer | { offers: readonly Offer[] }
+
+/** Returns every explicitly configured offer from discovery metadata. */
+export function offers(metadata: Metadata): readonly Offer[] {
+  if (isComposed(metadata)) return metadata.offers
+  return [metadata]
+}
+
+/** Converts configured handler metadata into a discovery payment offer. */
+export function paymentOffer(metadata: Offer): Record<string, unknown> {
+  const { _canonicalRequest: request, intent, name: method } = metadata
+  const methodDetails = (request.methodDetails ?? {}) as Record<string, unknown>
+
+  const amount = pickString(request.amount) ?? pickString(methodDetails.amount) ?? null
+  const currency = pickString(request.currency) ?? pickString(methodDetails.currency)
+  const description = pickString(metadata.description) ?? pickString(request.description)
+
+  const offer: Record<string, unknown> = {
+    amount,
+    ...(currency ? { currency } : {}),
+    ...(description ? { description } : {}),
+    intent,
+    method,
+  }
+
+  // Preserve extension fields emitted by method request schemas.
+  const reserved = new Set(['amount', 'currency', 'description', 'methodDetails'])
+  for (const [key, value] of Object.entries(request)) {
+    if (!reserved.has(key) && value !== undefined) offer[key] = value
+  }
+
+  return offer
+}
+
+/** Returns whether metadata represents a composed handler. */
+export function isComposed(metadata: Metadata): metadata is Extract<Metadata, { offers: unknown }> {
+  return 'offers' in metadata && !('_canonicalRequest' in metadata)
+}
+
+function pickString(value: unknown) {
+  return typeof value === 'string' ? value : undefined
+}

package/src/evm/server/Charge.ts

@@ -24,6 +24,8 @@ export function charge(parameters: charge.NativeConfig): Method.AnyServer {
   const transport = httpTransport(paths)
 
   return Method.toServer<typeof Methods.charge, charge.Defaults, typeof transport>(Methods.charge, {
+    canOffer: parameters.canOffer,
+    onPaymentSuccess: parameters.onPaymentSuccess,
     defaults: {
       chainId: config.chainId,
       currency: config.currency,
@@ -107,7 +109,10 @@ export declare namespace charge {
   type Parameters = NativeConfig
   type Native = Method.Server<typeof Methods.charge, Defaults>
 
-  type NativeConfig = BaseConfig & CurrencyConfig & RecipientConfig
+  type NativeConfig = BaseConfig &
+    CurrencyConfig &
+    RecipientConfig &
+    Method.ComposableHooks<typeof Methods.charge>
 
   type BaseConfig = {
     /** EIP-3009 token domain metadata. Required for raw addresses and viem tokens; inferred for known assets. */

package/src/internal/AcceptPayment.test.ts

@@ -226,21 +226,21 @@ describe('AcceptPayment', () => {
   test('selectChallengeCandidates supports duplicate method keys with challenge predicates', () => {
     const challenges = [
       {
-        id: 'v2',
+        id: 'primary',
         intent: 'session',
         method: 'tempo',
         realm: 'test',
-        request: { methodDetails: { sessionProtocol: 'v2' } },
+        request: { methodDetails: { sessionProtocol: 'primary' } },
       },
       {
-        id: 'v1',
+        id: 'fallback',
         intent: 'session',
         method: 'tempo',
         realm: 'test',
-        request: { methodDetails: { sessionProtocol: 'v1' } },
+        request: { methodDetails: { sessionProtocol: 'fallback' } },
       },
       {
-        id: 'old-server',
+        id: 'unmarked',
         intent: 'session',
         method: 'tempo',
         realm: 'test',
@@ -257,7 +257,7 @@ describe('AcceptPayment', () => {
           challenge: AcceptPayment.ChallengeCandidate['challenge']
         }) =>
           (challenge.request.methodDetails as { sessionProtocol?: string } | undefined)
-            ?.sessionProtocol === 'v2',
+            ?.sessionProtocol === 'primary',
       },
       {
         name: 'tempo',
@@ -270,7 +270,7 @@ describe('AcceptPayment', () => {
           const sessionProtocol = (
             challenge.request.methodDetails as { sessionProtocol?: string } | undefined
           )?.sessionProtocol
-          return sessionProtocol === undefined || sessionProtocol === 'v1'
+          return sessionProtocol === undefined || sessionProtocol === 'fallback'
         },
       },
     ] as const
@@ -281,7 +281,11 @@ describe('AcceptPayment', () => {
       AcceptPayment.parse('tempo/session'),
     )
 
-    expect(candidates.map(({ challenge }) => challenge.id)).toEqual(['v2', 'v1', 'old-server'])
+    expect(candidates.map(({ challenge }) => challenge.id)).toEqual([
+      'primary',
+      'fallback',
+      'unmarked',
+    ])
   })
 
   test('selectChallenge honors a specific opt-out over a broader wildcard', () => {

package/src/internal/types.ts

@@ -2,6 +2,15 @@
 // https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
 export type Compute<type> = { [key in keyof type]: type[key] } & unknown
 
+/** Recursively makes every property of a value readonly. */
+export type DeepReadonly<type> = type extends (...args: infer _arguments) => infer _return
+  ? type
+  : type extends readonly unknown[]
+    ? { readonly [key in keyof type]: DeepReadonly<type[key]> }
+    : type extends object
+      ? { readonly [key in keyof type]: DeepReadonly<type[key]> }
+      : type
+
 declare const symbol: unique symbol
 
 /**

package/src/mcp/client/McpClient.integration.test.ts

@@ -6,20 +6,22 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js'
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
-import { sessionLegacy as tempo_session_client, tempo as tempo_client } from 'mppx/client'
+import { session as tempo_session_client, tempo as tempo_client } from 'mppx/client'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import type { Address } from 'viem'
 import { readContract } from 'viem/actions'
 import { Actions, Addresses } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vp/test'
 import { tempoNetwork } from '~test/config.js'
-import { deployEscrow, signTopUpChannel } from '~test/tempo/legacy/session.js'
 import { accounts, asset, client as testClient, fundAccount } from '~test/tempo/viem.js'
 
 import * as Credential from '../../Credential.js'
 import * as core_Mcp from '../../Mcp.js'
 import * as Store from '../../Store.js'
-import type { SessionReceipt } from '../../tempo/session/precompile/Protocol.js'
+import type {
+  SessionCredentialPayload,
+  SessionReceipt,
+} from '../../tempo/session/precompile/Protocol.js'
 import * as ChannelStore from '../../tempo/session/server/ChannelStore.js'
 import * as McpServer_transport from '../server/Transport.js'
 import * as McpClient from './McpClient.js'
@@ -31,21 +33,11 @@ const doubleSessionAmountRaw = chargeAmountRaw * 2n
 const topUpAmountRaw = chargeAmountRaw * 3n
 const isLocalnet = tempoNetwork === 'localnet'
 
-let escrowContract: Address
-
-// TODO: Remove once the minimum viem version is >=2.54.0, which uses client-first Tempo call builders.
 function tokenGetBalanceCall(parameters: { account: Address; token: Address }) {
-  const call = Actions.token.getBalance.call as unknown as {
-    length: number
-    (parameters: { account: Address; token: Address }): unknown
-    (client: unknown, parameters: { account: Address; token: Address }): unknown
-  }
-  if (call.length >= 2) return call(testClient, parameters)
-  return call(parameters)
+  return Actions.token.getBalance.call(testClient, parameters)
 }
 
 beforeAll(async () => {
-  escrowContract = await deployEscrow()
   await fundAccount({ address: accounts[4].address, token: Addresses.pathUsd })
   await fundAccount({ address: accounts[4].address, token: asset })
   await fundAccount({ address: accounts[2].address, token: Addresses.pathUsd })
@@ -171,6 +163,7 @@ describe.runIf(isLocalnet)('McpClient.wrap integration', () => {
             action: 'voucher',
             channelId: openReceipt!.channelId,
             cumulativeAmountRaw: replayedCumulativeRaw,
+            descriptor: credentialDescriptor(openCredential),
           },
         })
         const firstVoucher = await callToolWithCredential(
@@ -236,7 +229,7 @@ describe.runIf(isLocalnet)('McpClient.wrap integration', () => {
     {
       name: 'session intent can top up a live MCP channel and continue metering on the same channel',
       sessionFeePayer: true,
-      sessionMaxDeposit: '2',
+      sessionMaxDeposit: '5',
       async run(harness: Harness) {
         const openChallenge = await getPaymentChallenge(harness.sdkClient, 'session_tool')
         const openCredential = await harness.sessionMethod.createCredential({
@@ -269,14 +262,6 @@ describe.runIf(isLocalnet)('McpClient.wrap integration', () => {
         expect(meteredReceipt?.channelId).toBe(openReceipt?.channelId)
         expect(meteredReceipt?.acceptedCumulative).toBe((chargeAmountRaw * 2n).toString())
 
-        const { serializedTransaction } = await signTopUpChannel({
-          escrow: escrowContract,
-          feePayer: true,
-          payer: accounts[2],
-          channelId: openReceipt!.channelId,
-          token: asset,
-          amount: topUpAmountRaw,
-        })
         const topUpChallenge = await getPaymentChallenge(harness.sdkClient, 'session_tool')
         const topUpCredential = await harness.sessionMethod.createCredential({
           challenge: topUpChallenge,
@@ -284,7 +269,7 @@ describe.runIf(isLocalnet)('McpClient.wrap integration', () => {
             action: 'topUp',
             additionalDepositRaw: topUpAmountRaw.toString(),
             channelId: openReceipt!.channelId,
-            transaction: serializedTransaction,
+            descriptor: credentialDescriptor(openCredential),
           },
         })
         const toppedUp = await callToolWithCredential(
@@ -317,7 +302,7 @@ describe.runIf(isLocalnet)('McpClient.wrap integration', () => {
         expect(resumedReceipt?.acceptedCumulative).toBe((chargeAmountRaw * 3n).toString())
 
         const channel = await harness.sessionStore.getChannel(openReceipt!.channelId)
-        expect(channel?.deposit).toBe(chargeAmountRaw * 2n + topUpAmountRaw)
+        expect(channel?.deposit).toBe(chargeAmountRaw * 5n + topUpAmountRaw)
         expect(channel?.highestVoucherAmount).toBe(chargeAmountRaw * 3n)
         expect(channel?.spent).toBeGreaterThanOrEqual(BigInt(topUpReceipt!.spent))
         expect(channel?.units).toBeGreaterThanOrEqual(topUpReceipt?.units ?? 0)
@@ -362,6 +347,7 @@ describe.runIf(isLocalnet)('McpClient.wrap integration', () => {
             action: 'close',
             channelId: openReceipt!.channelId,
             cumulativeAmountRaw: (chargeAmountRaw * 2n).toString(),
+            descriptor: credentialDescriptor(openCredential),
           },
         })
         const closed = await callToolWithCredential(
@@ -452,7 +438,6 @@ type Harness = {
 
 async function createHarness(options?: {
   sessionFeePayer?: boolean | undefined
-  sessionDeposit?: string | undefined
   sessionMaxDeposit?: string | undefined
 }): Promise<Harness> {
   const sessionBackingStore = Store.memory()
@@ -463,11 +448,8 @@ async function createHarness(options?: {
   })
   const sessionMethod = tempo_session_client({
     account: accounts[2],
-    escrowContract,
     getClient: () => testClient,
-    ...(options?.sessionMaxDeposit
-      ? { maxDeposit: options.sessionMaxDeposit }
-      : { deposit: options?.sessionDeposit ?? '5' }),
+    ...(options?.sessionMaxDeposit ? { maxDeposit: options.sessionMaxDeposit } : {}),
   })
 
   const payment = Mppx_server.create({
@@ -477,10 +459,9 @@ async function createHarness(options?: {
         currency: asset,
         getClient: () => testClient,
       }),
-      tempo_server.sessionLegacy({
+      tempo_server.session({
         account: accounts[0],
         currency: asset,
-        escrowContract,
         getClient: () => testClient,
         store: sessionBackingStore,
         ...(options?.sessionFeePayer ? { feePayer: accounts[4] } : {}),
@@ -578,6 +559,12 @@ async function createHarness(options?: {
   }
 }
 
+function credentialDescriptor(serializedCredential: string) {
+  const payload = Credential.deserialize<SessionCredentialPayload>(serializedCredential).payload
+  if (!payload.descriptor) throw new Error('Session credential is missing its channel descriptor.')
+  return payload.descriptor
+}
+
 async function getPaymentChallenge(client: Client, toolName: string): Promise<SessionChallenge> {
   try {
     await client.callTool({ name: toolName, arguments: {} })

package/src/middlewares/elysia.test.ts

@@ -2,18 +2,12 @@ import * as http from 'node:http'
 
 import { Elysia } from 'elysia'
 import { Receipt } from 'mppx'
-import {
-  Mppx as Mppx_client,
-  sessionLegacy as sessionIntent,
-  tempo as tempo_client,
-} from 'mppx/client'
+import { Mppx as Mppx_client, session as sessionIntent, tempo as tempo_client } from 'mppx/client'
 import { Mppx, discovery, payment } from 'mppx/elysia'
 import { tempo as tempo_server } from 'mppx/server'
-import type { Address } from 'viem'
 import { Addresses } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vp/test'
 import * as TestHttp from '~test/Http.js'
-import { deployEscrow } from '~test/tempo/legacy/session.js'
 import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
 
 function createServer(app: Elysia<any, any, any, any, any, any, any>) {
@@ -201,16 +195,13 @@ describe('charge', () => {
 })
 
 describe('session', () => {
-  let escrowContract: Address
-
   function createSessionHarness(feePayer: boolean) {
     const mppx = Mppx.create({
       methods: [
-        tempo_server.sessionLegacy({
+        tempo_server.session({
           getClient: () => client,
           account: accounts[0],
           currency: asset,
-          escrowContract,
           ...(feePayer ? { feePayer: accounts[1] } : {}),
         } as any),
       ],
@@ -232,7 +223,6 @@ describe('session', () => {
   }
 
   beforeAll(async () => {
-    escrowContract = await deployEscrow()
     await fundAccount({ address: accounts[1].address, token: Addresses.pathUsd })
     await fundAccount({ address: accounts[1].address, token: asset })
     await fundAccount({ address: accounts[2].address, token: Addresses.pathUsd })

package/src/middlewares/express.test.ts

@@ -1,17 +1,11 @@
 import express from 'express'
 import { Receipt } from 'mppx'
-import {
-  Mppx as Mppx_client,
-  sessionLegacy as sessionIntent,
-  tempo as tempo_client,
-} from 'mppx/client'
+import { Mppx as Mppx_client, session as sessionIntent, tempo as tempo_client } from 'mppx/client'
 import { Mppx, discovery, payment } from 'mppx/express'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
-import type { Address } from 'viem'
 import { Addresses } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
-import { deployEscrow } from '~test/tempo/legacy/session.js'
 import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
 
 function createServer(app: express.Express) {
@@ -195,16 +189,13 @@ describe('payment', () => {
 })
 
 describe('session', () => {
-  let escrowContract: Address
-
   function createSessionHarness(feePayer: boolean) {
     const mppx = Mppx.create({
       methods: [
-        tempo_server.sessionLegacy({
+        tempo_server.session({
           getClient: () => client,
           account: accounts[0],
           currency: asset,
-          escrowContract,
           ...(feePayer ? { feePayer: accounts[1] } : {}),
         } as any),
       ],
@@ -226,7 +217,6 @@ describe('session', () => {
   }
 
   beforeAll(async () => {
-    escrowContract = await deployEscrow()
     await fundAccount({ address: accounts[1].address, token: Addresses.pathUsd })
     await fundAccount({ address: accounts[1].address, token: asset })
     await fundAccount({ address: accounts[2].address, token: Addresses.pathUsd })