mppx 0.8.14 → 0.8.17

package/src/server/Methods.test-d.ts

@@ -0,0 +1,88 @@
+import { evm, stripe, tempo } from 'mppx/server'
+import { expectTypeOf, test } from 'vp/test'
+
+import type { StripeClient } from '../stripe/internal/types.js'
+
+test('all server method constructors expose typed canOffer hooks', () => {
+  tempo.charge({
+    canOffer({ input, request }) {
+      expectTypeOf(input).toEqualTypeOf<Request>()
+      expectTypeOf(request.amount).toEqualTypeOf<string>()
+      expectTypeOf(request.methodDetails?.chainId).toEqualTypeOf<number | undefined>()
+      return true
+    },
+  })
+
+  tempo.session({
+    canOffer({ input, request }) {
+      expectTypeOf(input).toEqualTypeOf<Request>()
+      expectTypeOf(request.amount).toEqualTypeOf<string>()
+      expectTypeOf(request.methodDetails?.chainId).toEqualTypeOf<number | undefined>()
+      return true
+    },
+  })
+
+  tempo.subscription({
+    canOffer({ input, request }) {
+      expectTypeOf(input).toEqualTypeOf<Request>()
+      expectTypeOf(request.amount).toEqualTypeOf<string>()
+      expectTypeOf(request.periodUnit).toEqualTypeOf<'dev_second' | 'day' | 'week'>()
+      return true
+    },
+    resolve: async () => null,
+  })
+
+  evm.charge({
+    canOffer({ input, request }) {
+      expectTypeOf(input).toEqualTypeOf<Request>()
+      expectTypeOf(request.amount).toEqualTypeOf<string>()
+      expectTypeOf(request.methodDetails.chainId).toEqualTypeOf<number>()
+      return true
+    },
+    currency: evm.assets.base.USDC,
+    recipient: '0x0000000000000000000000000000000000000001',
+    settle: async () => ({ reference: '0x01' }),
+  })
+
+  stripe.charge({
+    canOffer({ input, request }) {
+      expectTypeOf(input).toEqualTypeOf<Request>()
+      expectTypeOf(request.amount).toEqualTypeOf<string>()
+      expectTypeOf(request.methodDetails.networkId).toEqualTypeOf<string>()
+      return true
+    },
+    client: {} as StripeClient,
+    networkId: 'internal',
+    paymentMethodTypes: ['card'],
+  })
+})
+
+test('provider convenience constructors forward canOffer', () => {
+  evm({
+    canOffer({ request }) {
+      expectTypeOf(request.methodDetails.chainId).toEqualTypeOf<number>()
+      return true
+    },
+    currency: evm.assets.base.USDC,
+    recipient: '0x0000000000000000000000000000000000000001',
+    settle: async () => ({ reference: '0x01' }),
+  })
+
+  stripe.charge({
+    canOffer({ request }) {
+      expectTypeOf(request.methodDetails.networkId).toEqualTypeOf<string>()
+      return true
+    },
+    client: {} as StripeClient,
+    networkId: 'internal',
+    paymentMethodTypes: ['card'],
+  })
+
+  tempo({
+    canOffer({ input, request }) {
+      expectTypeOf(input).toEqualTypeOf<Request>()
+      expectTypeOf(request.amount).toEqualTypeOf<string>()
+      return true
+    },
+  })
+})

package/src/server/Methods.test.ts

@@ -0,0 +1,69 @@
+import { evm, stripe, tempo } from 'mppx/server'
+import { Methods as StripeMethods } from 'mppx/stripe'
+import { describe, expect, test, vi } from 'vp/test'
+import { accounts } from '~test/tempo/viem.js'
+
+const recipient = '0x0000000000000000000000000000000000000001'
+
+describe('composable method hooks', () => {
+  test('all server method constructors forward canOffer', () => {
+    const canOffer = vi.fn(() => true)
+    const methods = [
+      tempo.charge({ canOffer }),
+      tempo.session({ account: accounts[0], canOffer }),
+      tempo.subscription({
+        account: accounts[0],
+        canOffer,
+        resolve: async () => null,
+      }),
+      evm.charge({
+        canOffer,
+        currency: evm.assets.base.USDC,
+        recipient,
+        settle: async () => ({ reference: '0x01' }),
+      }),
+    ]
+
+    for (const method of methods) expect(method.canOffer).toBe(canOffer)
+  })
+
+  test('Tempo common constructor forwards canOffer to every intent', () => {
+    const canOffer = vi.fn(() => true)
+    const methods = tempo({ account: accounts[0], canOffer })
+
+    expect(tempo.common).toBe(tempo)
+    expect(methods).toHaveLength(2)
+    for (const method of methods) expect(method.canOffer).toBe(canOffer)
+  })
+
+  test('provider convenience constructors preserve canOffer', async () => {
+    const evmCanOffer = vi.fn(() => true)
+    const [evmCharge] = evm({
+      canOffer: evmCanOffer,
+      currency: evm.assets.base.USDC,
+      recipient,
+      settle: async () => ({ reference: '0x01' }),
+    })
+    expect(evmCharge.canOffer).toBe(evmCanOffer)
+
+    const stripeCanOffer = vi.fn(() => true)
+    const stripeCharge = stripe.charge({
+      canOffer: stripeCanOffer,
+      client: {} as never,
+      networkId: 'internal',
+      paymentMethodTypes: ['card'],
+    })
+    const request = StripeMethods.charge.schema.request.parse({
+      amount: '1',
+      currency: 'usd',
+      decimals: 2,
+      networkId: 'internal',
+      paymentMethodTypes: ['card'],
+    })
+
+    await expect(
+      stripeCharge.canOffer?.({ input: new Request('https://example.com'), request }),
+    ).resolves.toBe(true)
+    expect(stripeCanOffer).toHaveBeenCalledOnce()
+  })
+})

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

@@ -1,7 +1,9 @@
 import { Method, z } from 'mppx'
-import { Mppx, tempo } from 'mppx/server'
+import { Mppx, tempo, Transport } from 'mppx/server'
 import { assertType, describe, expectTypeOf, test } from 'vp/test'
 
+import type * as Attestation from '../attestation/Types.js'
+
 const mockChargeA = Method.from({
   name: 'alpha',
   intent: 'charge',
@@ -83,8 +85,8 @@ const tip1034SessionMethod = Method.toServer(mockSession, {
   },
 })
 
-const legacySessionMethod = Method.toServer(mockSession, {
-  alias: 'sessionLegacy',
+const alternateSessionMethod = Method.toServer(mockSession, {
+  alias: 'alternateSession',
   async verify() {
     return {
       method: 'tempo',
@@ -99,12 +101,42 @@ const secretKey = 'test-secret-key-test-secret-key-32'
 const realm = 'api.example.com'
 
 describe('Mppx type tests', () => {
+  test('method handlers expose method extensions', () => {
+    const sessionMethod = tempo.session({
+      amount: '1',
+      currency: '0x0000000000000000000000000000000000000001',
+      decimals: 6,
+      getClient: () => null as never,
+      recipient: '0x0000000000000000000000000000000000000002',
+      unitType: 'token',
+    })
+    const mppx = Mppx.create({ methods: [sessionMethod], realm, secretKey })
+
+    expectTypeOf(mppx.session.settleScheduled).toBeFunction()
+    expectTypeOf(mppx.session.serveWebSocket).toBeFunction()
+    type Options = Parameters<typeof mppx.session.serveWebSocket>[0]
+    expectTypeOf<Options>().toHaveProperty('route')
+    expectTypeOf<Options>().not.toHaveProperty('store')
+    expectTypeOf<Options>().not.toHaveProperty('onChargeCommitted')
+    expectTypeOf<Options>().not.toHaveProperty('settleScheduled')
+    type LowLevelOptions = Parameters<typeof tempo.Ws.serve>[0]
+    expectTypeOf<LowLevelOptions>().toHaveProperty('onChargeCommitted')
+    expectTypeOf<LowLevelOptions>().toHaveProperty('settleScheduled')
+  })
+
   test('compose exists on the instance and returns a handler', () => {
     const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
 
     expectTypeOf(mppx.compose).toBeFunction()
   })
 
+  test('multi-method intent handler is callable and non-nullable', () => {
+    const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
+
+    expectTypeOf(mppx.charge).toBeFunction()
+    expectTypeOf(mppx.charge).not.toBeNullable()
+  })
+
   test('compose accepts method reference tuples', () => {
     const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
 
@@ -135,6 +167,107 @@ describe('Mppx type tests', () => {
     expectTypeOf(handler).toBeFunction()
   })
 
+  test('selectOffers exposes typed methods, normalized requests, and the HTTP request', () => {
+    Mppx.create({
+      methods: [alphaMethod, betaMethod],
+      realm,
+      secretKey,
+      selectOffers(offers, { request }) {
+        expectTypeOf(request).toEqualTypeOf<Request>()
+        expectTypeOf(offers[0]!.key).toEqualTypeOf<'alpha/charge' | 'beta/charge'>()
+        expectTypeOf(offers[0]!.method.name).toEqualTypeOf<'alpha' | 'beta'>()
+        expectTypeOf(offers[0]!.method.intent).toEqualTypeOf<'charge'>()
+        expectTypeOf(offers[0]!.request.amount).toEqualTypeOf<string>()
+        return offers.filter((offer) => offer.method.name !== 'beta')
+      },
+    })
+  })
+
+  test('method canOffer receives its normalized payment request and HTTP input', () => {
+    Method.toServer(mockChargeA, {
+      canOffer({ input, request }) {
+        expectTypeOf(input).toEqualTypeOf<Request>()
+        expectTypeOf(request.amount).toEqualTypeOf<string>()
+        expectTypeOf(request.currency).toEqualTypeOf<string>()
+        expectTypeOf(request.decimals).toEqualTypeOf<number>()
+        expectTypeOf(request.recipient).toEqualTypeOf<string>()
+        return true
+      },
+      async verify() {
+        return {
+          method: 'alpha',
+          reference: 'tx',
+          status: 'success' as const,
+          timestamp: new Date().toISOString(),
+        }
+      },
+    })
+  })
+
+  test('offer selection data is deeply readonly', () => {
+    Mppx.create({
+      methods: [tip1034SessionMethod, alternateSessionMethod],
+      realm,
+      secretKey,
+      selectOffers(offers) {
+        expectTypeOf(offers[0]!.method.alias).toEqualTypeOf<undefined | 'alternateSession'>()
+        // @ts-expect-error offer method descriptors are readonly.
+        offers[0]!.method.name = 'changed'
+        // @ts-expect-error normalized offer requests are deeply readonly.
+        offers[0]!.request.methodDetails.sessionProtocol = 'changed'
+        expectTypeOf(offers[0]!.method).not.toHaveProperty('verify')
+        return offers
+      },
+    })
+
+    Method.toServer(mockSession, {
+      canOffer({ request }) {
+        // @ts-expect-error canOffer requests are deeply readonly.
+        request.methodDetails.sessionProtocol = 'changed'
+        return true
+      },
+      async verify() {
+        return {
+          method: 'tempo',
+          reference: 'tx',
+          status: 'success' as const,
+          timestamp: new Date().toISOString(),
+        }
+      },
+    })
+  })
+
+  test('selectOffers is only available for HTTP transport', () => {
+    Mppx.create({
+      methods: [alphaMethod],
+      realm,
+      secretKey,
+      transport: Transport.mcp(),
+      // @ts-expect-error selectOffers applies to composed HTTP offers only.
+      selectOffers: (offers) => offers,
+    })
+  })
+
+  test('accepts request attestation for HTTP transport only', () => {
+    const verifier = {} as Attestation.Verifier
+    const mppx = Mppx.create({
+      attestation: { webBotAuth: verifier },
+      methods: [alphaMethod],
+      realm,
+      secretKey,
+    })
+    expectTypeOf(mppx.charge).toBeFunction()
+
+    Mppx.create({
+      // @ts-expect-error request attestation applies to HTTP transport only.
+      attestation: { webBotAuth: verifier },
+      methods: [alphaMethod],
+      realm,
+      secretKey,
+      transport: Transport.mcp(),
+    })
+  })
+
   test('nested handlers are accessible', () => {
     const mppx = Mppx.create({ methods: [alphaMethod, betaMethod], realm, secretKey })
 
@@ -146,17 +279,17 @@ describe('Mppx type tests', () => {
 
   test('aliased duplicate handlers are accessible by nested and slash keys', () => {
     const mppx = Mppx.create({
-      methods: [tip1034SessionMethod, legacySessionMethod],
+      methods: [tip1034SessionMethod, alternateSessionMethod],
       realm,
       secretKey,
     })
 
     expectTypeOf(mppx.tempo.session).toBeFunction()
-    expectTypeOf(mppx.tempo.sessionLegacy).toBeFunction()
+    expectTypeOf(mppx.tempo.alternateSession).toBeFunction()
     expectTypeOf(mppx['tempo/session']).toBeFunction()
-    expectTypeOf(mppx['tempo/sessionLegacy']).toBeFunction()
+    expectTypeOf(mppx['tempo/alternateSession']).toBeFunction()
     expectTypeOf(mppx.challenge.tempo.session).toBeFunction()
-    expectTypeOf(mppx.challenge.tempo.sessionLegacy).toBeFunction()
+    expectTypeOf(mppx.challenge.tempo.alternateSession).toBeFunction()
   })
 
   test('slash key handlers are accessible', () => {
@@ -182,6 +315,7 @@ describe('Mppx type tests', () => {
     assertType<Promise<{ status: 402; challenge: Response } | { status: 200; withReceipt: any }>>(
       {} as Awaited<HandlerReturn> as any,
     )
+    expectTypeOf(_handler._internal?.offers).toMatchTypeOf<readonly unknown[] | undefined>()
   })
 
   test('static Mppx.compose accepts configured handlers', () => {