mppx 0.8.14 → 0.8.17

package/src/stripe/server/Charge.test.ts

@@ -37,6 +37,85 @@ function createMockStripeClient(
   }
 }
 
+describe('stripe.charge offer availability', () => {
+  test.each([
+    { atMinimum: '0.50', belowMinimum: '0.49', currency: 'usd', decimals: 2, normalized: '50' },
+    { atMinimum: '0.30', belowMinimum: '0.29', currency: 'gbp', decimals: 2, normalized: '30' },
+    { atMinimum: '50', belowMinimum: '49', currency: 'jpy', decimals: 0, normalized: '50' },
+    { atMinimum: '10', belowMinimum: '9.99', currency: 'mxn', decimals: 2, normalized: '1000' },
+  ])(
+    'filters $currency offers below the Stripe currency minimum',
+    async ({ atMinimum, belowMinimum, currency, decimals, normalized }) => {
+      const { client } = createMockStripeClient()
+      const stripeCharge = stripe.charge({
+        client,
+        networkId: 'internal',
+        paymentMethodTypes: ['card'],
+      })
+      const server = Mppx.create({ methods: [stripeCharge], realm, secretKey })
+
+      const result = await server.compose(
+        [stripeCharge, { amount: belowMinimum, currency, decimals }],
+        [stripeCharge, { amount: atMinimum, currency, decimals }],
+      )(new Request('https://example.com/resource'))
+
+      expect(result.status).toBe(402)
+      if (result.status !== 402) throw new Error()
+      const challenges = Challenge.fromResponseList(result.challenge)
+      expect(challenges).toHaveLength(1)
+      expect(challenges[0]?.request).toMatchObject({ amount: normalized, currency })
+    },
+  )
+
+  test('composes constructor canOffer after the Stripe currency minimum', async () => {
+    const { client } = createMockStripeClient()
+    const offeredAmounts: string[] = []
+    const stripeCharge = stripe.charge({
+      client,
+      canOffer({ request }) {
+        offeredAmounts.push(request.amount)
+        return BigInt(request.amount) >= 100n
+      },
+      networkId: 'internal',
+      paymentMethodTypes: ['card'],
+    })
+    const server = Mppx.create({ methods: [stripeCharge], realm, secretKey })
+
+    const result = await server.compose(
+      [stripeCharge, { amount: '0.49', currency: 'usd', decimals: 2 }],
+      [stripeCharge, { amount: '0.50', currency: 'usd', decimals: 2 }],
+      [stripeCharge, { amount: '1', currency: 'usd', decimals: 2 }],
+    )(new Request('https://example.com/resource'))
+
+    expect(result.status).toBe(402)
+    if (result.status !== 402) throw new Error()
+    expect(offeredAmounts).toEqual(['50', '100'])
+    expect(
+      Challenge.fromResponseList(result.challenge).map(({ request }) => request.amount),
+    ).toEqual(['100'])
+  })
+
+  test('lets constructor canOffer decide availability for an unknown currency', async () => {
+    const { client } = createMockStripeClient()
+    const canOffer = vi.fn(() => true)
+    const stripeCharge = stripe.charge({
+      client,
+      canOffer,
+      networkId: 'internal',
+      paymentMethodTypes: ['card'],
+    })
+    const server = Mppx.create({ methods: [stripeCharge], realm, secretKey })
+
+    const result = await server.compose([
+      stripeCharge,
+      { amount: '0.01', currency: 'unknown', decimals: 2 },
+    ])(new Request('https://example.com/resource'))
+
+    expect(result.status).toBe(402)
+    expect(canOffer).toHaveBeenCalledOnce()
+  })
+})
+
 describe('stripe.charge with client', () => {
   test('default: verifies payment via client.paymentIntents.create', async () => {
     const { client, create } = createMockStripeClient()

package/src/stripe/server/Charge.ts

@@ -20,6 +20,48 @@ import type {
 import * as Methods from '../Methods.js'
 import { html as htmlContent } from './internal/html.gen.js'
 
+/**
+ * Stripe's general minimum charge amounts in each currency's smallest unit.
+ * Payment methods with lower provider-specific exceptions remain conservatively
+ * subject to the general minimum.
+ *
+ * @see https://docs.stripe.com/currencies#minimum-and-maximum-charge-amounts
+ */
+const minimumChargeAmountByCurrency: Readonly<Record<string, bigint>> = {
+  aed: 200n,
+  ars: 50n,
+  aud: 50n,
+  bgn: 100n,
+  brl: 50n,
+  cad: 50n,
+  chf: 50n,
+  cop: 50n,
+  czk: 1_500n,
+  dkk: 250n,
+  eur: 50n,
+  gbp: 30n,
+  hkd: 400n,
+  huf: 17_500n,
+  idr: 50n,
+  ils: 50n,
+  inr: 50n,
+  jpy: 50n,
+  krw: 50n,
+  mxn: 1_000n,
+  myr: 200n,
+  nok: 300n,
+  nzd: 50n,
+  php: 50n,
+  pln: 200n,
+  ron: 200n,
+  rub: 50n,
+  sek: 300n,
+  sgd: 50n,
+  thb: 1_000n,
+  usd: 50n,
+  zar: 50n,
+}
+
 /**
  * Creates a Stripe charge method intent for usage on the server.
  *
@@ -48,6 +90,8 @@ import { html as htmlContent } from './internal/html.gen.js'
 export function charge<const parameters extends charge.Parameters>(parameters: parameters) {
   const {
     amount,
+    canOffer,
+    onPaymentSuccess,
     currency,
     decimals,
     description,
@@ -98,6 +142,14 @@ export function charge<const parameters extends charge.Parameters>(parameters: p
           }
         : undefined,
 
+    async canOffer(context) {
+      const minimum = minimumChargeAmountByCurrency[context.request.currency.toLowerCase()]
+      if (minimum !== undefined && BigInt(context.request.amount) < minimum) return false
+      return (await canOffer?.(context)) ?? true
+    },
+
+    onPaymentSuccess,
+
     async verify({ credential, envelope, request }) {
       const { challenge } = credential
       const resolvedRequest = (() => {
@@ -195,7 +247,8 @@ export declare namespace charge {
     metadata?: Record<string, string> | undefined
     /** Optional server-side Stripe Connect settlement policy. Not included in MPP challenges. */
     connect?: ConnectSettlement | ResolveConnectSettlement | undefined
-  } & Defaults &
+  } & Method.ComposableHooks<typeof Methods.charge> &
+    Defaults &
     OneOf<
       | {
           /** Pre-configured Stripe SDK instance. Any object matching the duck-typed `StripeClient` shape works. */

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

@@ -0,0 +1,157 @@
+import type { Client } from 'viem'
+import { expectTypeOf, test } from 'vp/test'
+
+import * as Mppx from '../../server/Mppx.js'
+import type { AtomicStore } from '../../Store.js'
+import { stripe } from './Methods.js'
+
+test('async defaultMethods() produces types compose can use', async () => {
+  const mp = stripe.create({ client: {} as any, networkId: 'profile_x', livemode: false })
+  const methods = await mp.defaultMethods()
+  const mppx = Mppx.create({ methods, secretKey: 'test' })
+
+  const result = await mppx.compose(
+    ['tempo/charge', { amount: '0.01', description: 'test' }],
+    ['stripe/charge', { amount: '0.50', currency: 'usd', decimals: 2, description: 'test' }],
+  )(new Request('http://localhost'))
+
+  expectTypeOf(result.status).toEqualTypeOf<200 | 402>()
+})
+
+test('tempo.session() accepts getClient, feePayer, store without casts', () => {
+  const mp = stripe.create({ client: {} as any, networkId: 'profile_x', livemode: false })
+  const addr = '' as stripe.DepositAddress<'tempo'>
+
+  const session = mp.tempo.session({
+    recipient: addr,
+    getClient: () => ({}) as Client,
+    feePayer: 'https://api.tempo.xyz/rpc/sponsor?key=test',
+    store: {} as AtomicStore,
+    sse: true,
+    settlementSchedule: { amount: '0.01' },
+    onSessionSettlement: async () => {},
+  })
+
+  expectTypeOf(session).toHaveProperty('name')
+  expectTypeOf(session).toHaveProperty('intent')
+})
+
+test('.charge() works with multiple charge methods (implicit compose)', async () => {
+  const mp = stripe.create({ client: {} as any, networkId: 'profile_x', livemode: false })
+  const methods = await mp.defaultMethods()
+  const mppx = Mppx.create({ methods, secretKey: 'test' })
+
+  expectTypeOf(mppx.charge).toBeFunction()
+  expectTypeOf(mppx.charge).not.toBeNullable()
+
+  // Note: MultiMethodFn options are permissive (UnionToIntersection of any-based schemas).
+  // Negative assertions for .charge() options require concrete method schemas to be useful.
+})
+
+test('stripe.create() rejects invalid parameters', () => {
+  // @ts-expect-error - livemode is required
+  stripe.create({ client: {} as any, networkId: 'x' })
+  // @ts-expect-error - networkId is required
+  stripe.create({ client: {} as any, livemode: true })
+  stripe.create({
+    client: {} as any,
+    networkId: 'x',
+    livemode: true,
+    // @ts-expect-error - unsupported network key
+    depositAddresses: { ethereum: '0x' },
+  })
+})
+
+test('additional() rejects unsupported network keys', async () => {
+  const mp = stripe.create({ client: {} as any, networkId: 'profile_x', livemode: false })
+  // @ts-expect-error - 'arbitrum' is not a supported custom rail network
+  await mp.defaultMethods().additional({ arbitrum: (_addr) => ({}) as any })
+})
+
+test('additional() accepts tempo.session and base with full params', async () => {
+  const mp = stripe.create({ client: {} as any, networkId: 'profile_x', livemode: false })
+  const methods = await mp.defaultMethods().additional({
+    base: {
+      x402: { facilitator: { verify: async () => ({}) as any, settle: async () => ({}) as any } },
+    },
+    tempo: {
+      session: {
+        store: {} as AtomicStore,
+        sse: true,
+        settlementSchedule: { amount: '0.01' },
+        onSessionSettlement: async () => {},
+        getClient: () => ({}) as Client,
+      },
+    },
+  })
+
+  const mppx = Mppx.create({ methods, secretKey: 'test' })
+  expectTypeOf(mppx.charge).toBeFunction()
+  expectTypeOf(mppx.charge).not.toBeNullable()
+})
+
+test('sync defaultMethods() with static depositAddresses returns SyncMethodsResult', () => {
+  const mp = stripe.create({
+    client: {} as any,
+    networkId: 'profile_x',
+    livemode: false,
+    depositAddresses: { tempo: '0x123' },
+  })
+  const methods = mp.defaultMethods()
+  expectTypeOf(methods).toHaveProperty('additional')
+
+  const mppx = Mppx.create({ methods, secretKey: 'test' })
+  expectTypeOf(mppx.charge).toBeFunction()
+  expectTypeOf(mppx.charge).not.toBeNullable()
+})
+
+test('depositAddresses as resolver function returns DefaultMethodsBuilder', async () => {
+  const mp = stripe.create({
+    client: {} as any,
+    networkId: 'profile_x',
+    livemode: false,
+    depositAddresses: async (_network) => '0xaddr',
+  })
+  const methods = await mp.defaultMethods()
+  const mppx = Mppx.create({ methods, secretKey: 'test' })
+  expectTypeOf(mppx.charge).toBeFunction()
+})
+
+test('connect config with stripeAccount passes to Mppx.create', async () => {
+  const mp = stripe.create({
+    client: {} as any,
+    networkId: 'profile_x',
+    livemode: true,
+    connect: { stripeAccount: 'acct_123', applicationFeeAmount: 100 },
+  })
+  const methods = await mp.defaultMethods()
+  const mppx = Mppx.create({ methods, secretKey: 'test' })
+  expectTypeOf(mppx.charge).toBeFunction()
+})
+
+test('additional() with custom rail (solana) works via compose', async () => {
+  const mp = stripe.create({ client: {} as any, networkId: 'profile_x', livemode: false })
+  const methods = await mp.defaultMethods().additional({
+    base: {
+      x402: { facilitator: { verify: async () => ({}) as any, settle: async () => ({}) as any } },
+    },
+    solana: (_address) => ({
+      name: 'solana' as const,
+      intent: 'charge' as const,
+      schema: { credential: { payload: {} as any }, request: {} as any },
+      verify: async () =>
+        ({ method: 'solana', status: 'success', reference: '0x', timestamp: '' }) as const,
+    }),
+  })
+
+  const mppx = Mppx.create({ methods, secretKey: 'test' })
+
+  const result = await mppx.compose(
+    ['tempo/charge', { amount: '0.01', description: 'test' }],
+    ['evm/charge', { amount: '0.01', description: 'test' }],
+    ['solana/charge', { amount: '10000', description: 'test' }] as any,
+    ['stripe/charge', { amount: '0.50', currency: 'usd', decimals: 2, description: 'test' }],
+  )(new Request('http://localhost'))
+
+  expectTypeOf(result.status).toEqualTypeOf<200 | 402>()
+})