mppx 0.4.9 → 0.4.10

package/src/proxy/services/stripe.test.ts

@@ -0,0 +1,132 @@
+import { Receipt } from 'mppx'
+import { Mppx as Mppx_client, tempo as tempo_client } from 'mppx/client'
+import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
+import { afterEach, describe, expect, test } from 'vp/test'
+import * as Http from '~test/Http.js'
+import { accounts, asset, client } from '~test/tempo/viem.js'
+
+import * as ApiProxy from '../Proxy.js'
+import { stripe } from './stripe.js'
+
+const apiKey = 'sk_test_fake_stripe_key'
+const secretKey = 'test-secret-key'
+
+const mppx_server = Mppx_server.create({
+  methods: [
+    tempo_server({
+      account: accounts[0],
+      currency: asset,
+      getClient: () => client,
+    }),
+  ],
+  secretKey,
+})
+
+const mppx_client = Mppx_client.create({
+  polyfill: false,
+  methods: [
+    tempo_client({
+      account: accounts[1],
+      getClient: () => client,
+    }),
+  ],
+})
+
+let proxyServer: Awaited<ReturnType<typeof Http.createServer>> | undefined
+let upstreamServer: Awaited<ReturnType<typeof Http.createServer>> | undefined
+
+afterEach(() => {
+  proxyServer?.close()
+  upstreamServer?.close()
+})
+
+describe('stripe', () => {
+  test('behavior: proxies POST /v1/charges with charge and injects Basic auth', async () => {
+    upstreamServer = await Http.createServer((req, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(
+        JSON.stringify({
+          headers: {
+            authorization: req.headers.authorization,
+          },
+        }),
+      )
+    })
+
+    const proxy = ApiProxy.create({
+      services: [
+        stripe({
+          apiKey,
+          baseUrl: upstreamServer.url,
+          routes: {
+            'POST /v1/charges': mppx_server.charge({ amount: '1', decimals: 6 }),
+          },
+        }),
+      ],
+    })
+    proxyServer = await Http.createServer(proxy.listener)
+
+    const res = await mppx_client.fetch(`${proxyServer.url}/stripe/v1/charges`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: 'amount=100&currency=usd',
+    })
+    expect(res.status).toBe(200)
+
+    const body = (await res.json()) as { headers: { authorization: string } }
+    expect(body.headers.authorization).toBe(`Basic ${btoa(`${apiKey}:`)}`)
+
+    const receipt = Receipt.fromResponse(res)
+    expect(receipt.status).toBe('success')
+    expect(receipt.method).toBe('tempo')
+  })
+
+  test('behavior: returns 402 without credential', async () => {
+    upstreamServer = await Http.createServer((_req, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end('{}')
+    })
+
+    const proxy = ApiProxy.create({
+      services: [
+        stripe({
+          apiKey,
+          baseUrl: upstreamServer.url,
+          routes: {
+            'POST /v1/charges': mppx_server.charge({ amount: '1', decimals: 6 }),
+          },
+        }),
+      ],
+    })
+    proxyServer = await Http.createServer(proxy.listener)
+
+    const res = await fetch(`${proxyServer.url}/stripe/v1/charges`, {
+      method: 'POST',
+    })
+    expect(res.status).toBe(402)
+    expect(res.headers.get('WWW-Authenticate')).toContain('Payment')
+  })
+
+  test('behavior: returns 404 for unmatched route', async () => {
+    upstreamServer = await Http.createServer((_req, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end('{}')
+    })
+
+    const proxy = ApiProxy.create({
+      services: [
+        stripe({
+          apiKey,
+          baseUrl: upstreamServer.url,
+          routes: {
+            'POST /v1/charges': mppx_server.charge({ amount: '1', decimals: 6 }),
+          },
+        }),
+      ],
+    })
+    proxyServer = await Http.createServer(proxy.listener)
+
+    const res = await fetch(`${proxyServer.url}/stripe/v1/unknown`)
+    expect(res.status).toBe(404)
+  })
+})

package/src/proxy/services/stripe.ts

@@ -20,11 +20,13 @@ import * as Service from '../Service.js'
 export function stripe(config: stripe.Config) {
   return Service.from<stripe.Config>('stripe', {
     baseUrl: config.baseUrl ?? 'https://api.stripe.com',
+    categories: ['payments'],
     description: 'Payment processing, customers, subscriptions, and invoices.',
-    docsLlmsUrl: ({ route }) =>
-      route
-        ? `https://context7.com/websites/stripe/llms.txt?topic=${encodeURIComponent(route)}`
-        : 'https://docs.stripe.com/llms.txt',
+    docs: {
+      apiReference: 'https://docs.stripe.com/api',
+      homepage: 'https://docs.stripe.com',
+      llms: 'https://docs.stripe.com/llms.txt',
+    },
     rewriteRequest(request, ctx) {
       const apiKey = ctx.apiKey ?? config.apiKey
       request.headers.set('Authorization', `Basic ${btoa(`${apiKey}:`)}`)

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

@@ -1,6 +1,6 @@
 import { Method, z } from 'mppx'
 import { Mppx } from 'mppx/server'
-import { assertType, describe, expectTypeOf, test } from 'vitest'
+import { assertType, describe, expectTypeOf, test } from 'vp/test'
 
 const mockChargeA = Method.from({
   name: 'alpha',

package/src/server/Mppx.test.ts

@@ -1,6 +1,6 @@
 import { Challenge, Credential, Method, z } from 'mppx'
 import { Mppx, Transport, tempo } from 'mppx/server'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 import { accounts, asset, client } from '~test/tempo/viem.js'
 
@@ -9,6 +9,7 @@ const secretKey = 'test-secret-key'
 
 const method = tempo({
   getClient: () => client,
+  account: accounts[0],
 })
 
 describe('create', () => {

package/src/server/NodeListener.test.ts

@@ -1,5 +1,5 @@
 import { NodeListener, Request } from 'mppx/server'
-import { afterEach, describe, expect, test } from 'vitest'
+import { afterEach, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 
 let server: Awaited<ReturnType<typeof Http.createServer>> | undefined

package/src/server/Request.test.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from 'node:events'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 
 import { Request } from 'mppx/server'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 function createMockRequest(options: {
   method?: string

package/src/server/Response.test.ts

@@ -1,6 +1,6 @@
 import { Challenge } from 'mppx'
 import { Response } from 'mppx/server'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Errors from '../Errors.js'
 

package/src/server/Transport.test.ts

@@ -1,7 +1,7 @@
 import { Challenge, Credential, Mcp, Receipt } from 'mppx'
 import { Transport } from 'mppx/server'
 import { Methods } from 'mppx/tempo'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import { BadRequestError, ChannelClosedError } from '../Errors.js'
 

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

@@ -1,7 +1,7 @@
 import { Challenge, Credential, Receipt } from 'mppx'
 import { Mppx as Mppx_client, stripe as stripe_client } from 'mppx/client'
 import { Mppx as Mppx_server, stripe as stripe_server } from 'mppx/server'
-import { afterEach, describe, expect, test } from 'vitest'
+import { afterEach, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 
 const stripeSecretKey = process.env.VITE_STRIPE_SECRET_KEY

package/src/stripe/Methods.test.ts

@@ -1,5 +1,5 @@
 import { Methods } from 'mppx/stripe'
-import { describe, expect, expectTypeOf, test } from 'vitest'
+import { describe, expect, expectTypeOf, test } from 'vp/test'
 
 describe('charge', () => {
   test('has correct name and intent', () => {

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

@@ -1,7 +1,7 @@
 import { Challenge, Credential } from 'mppx'
 import { Mppx, stripe } from 'mppx/client'
 import { Mppx as Mppx_server, stripe as stripe_server } from 'mppx/server'
-import { describe, expect, test, vi } from 'vitest'
+import { describe, expect, test, vi } from 'vp/test'
 
 import type { StripeJs } from '../internal/types.js'
 import { charge as clientCharge_ } from './Charge.js'

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

@@ -1,6 +1,6 @@
 import { Challenge, Credential } from 'mppx'
 import { Mppx, stripe } from 'mppx/server'
-import { afterEach, describe, expect, test, vi } from 'vitest'
+import { afterEach, describe, expect, test, vi } from 'vp/test'
 import * as Http from '~test/Http.js'
 
 import type { StripeClient } from '../internal/types.js'

package/src/tempo/Attribution.test.ts

@@ -1,5 +1,5 @@
 import { Bytes, Hash, Hex } from 'ox'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Attribution from './Attribution.js'
 

package/src/tempo/Methods.test.ts

@@ -1,5 +1,5 @@
 import { Methods } from 'mppx/tempo'
-import { describe, expect, expectTypeOf, test } from 'vitest'
+import { describe, expect, expectTypeOf, test } from 'vp/test'
 
 describe('charge', () => {
   test('has correct name and intent', () => {

package/src/tempo/client/ChannelOps.test.ts

@@ -2,10 +2,13 @@ import { Hex } from 'ox'
 import { type Address, createClient } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
 import { Addresses } from 'viem/tempo'
-import { beforeAll, describe, expect, test } from 'vitest'
+import { beforeAll, describe, expect, test } from 'vp/test'
+import { nodeEnv } from '~test/config.js'
 import { deployEscrow, openChannel } from '~test/tempo/session.js'
 import { accounts, asset, chain, client, fundAccount, http } from '~test/tempo/viem.js'
 
+const isLocalnet = nodeEnv === 'localnet'
+
 import type { Challenge } from '../../Challenge.js'
 import * as Credential from '../../Credential.js'
 import {
@@ -166,7 +169,7 @@ describe('createClosePayload', () => {
   })
 })
 
-describe('createOpenPayload', () => {
+describe.runIf(isLocalnet)('createOpenPayload', () => {
   const payer = accounts[2]
   const payee = accounts[1].address
   const currency = asset
@@ -250,7 +253,7 @@ describe('createOpenPayload', () => {
   })
 })
 
-describe('tryRecoverChannel', () => {
+describe.runIf(isLocalnet)('tryRecoverChannel', () => {
   const payer = accounts[3]
   const payee = accounts[1].address
   const currency = asset

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

@@ -1,10 +1,13 @@
 import { type Address, createClient, type Hex, http } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
 import { Addresses } from 'viem/tempo'
-import { beforeAll, describe, expect, test } from 'vitest'
+import { beforeAll, describe, expect, test } from 'vp/test'
+import { nodeEnv } from '~test/config.js'
 import { deployEscrow, openChannel } from '~test/tempo/session.js'
 import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'
 
+const isLocalnet = nodeEnv === 'localnet'
+
 import * as Challenge from '../../Challenge.js'
 import * as Credential from '../../Credential.js'
 import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
@@ -201,7 +204,7 @@ describe('session (pure)', () => {
   })
 })
 
-describe('session (on-chain)', () => {
+describe.runIf(isLocalnet)('session (on-chain)', () => {
   const payer = accounts[2]
   const payee = accounts[1].address
   let escrowContract: Address

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

@@ -1,5 +1,5 @@
 import type { Hex } from 'viem'
-import { describe, expect, test, vi } from 'vitest'
+import { describe, expect, test, vi } from 'vp/test'
 
 import * as Challenge from '../../Challenge.js'
 import { formatNeedVoucherEvent, parseEvent } from '../session/Sse.js'

package/src/tempo/internal/auto-swap.test.ts

@@ -1,5 +1,5 @@
 import type { Address } from 'viem'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import { defaultCurrencies, InsufficientFundsError, resolve } from './auto-swap.js'
 

package/src/tempo/internal/defaults.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import {
   chainId,

package/src/tempo/internal/fee-payer.test.ts

@@ -1,6 +1,6 @@
 import { encodeFunctionData } from 'viem'
 import { Abis, Addresses } from 'viem/tempo'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import { callScopes, FeePayerValidationError, validateCalls } from './fee-payer.js'
 import * as Selectors from './selectors.js'

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

@@ -7,7 +7,7 @@ import { Handler } from 'tempo.ts/server'
 import { createClient, custom, encodeFunctionData, parseUnits } from 'viem'
 import { getTransactionReceipt, prepareTransactionRequest, signTransaction } from 'viem/actions'
 import { Abis, Account, Actions, Addresses, Secp256k1, Tick, Transaction } from 'viem/tempo'
-import { beforeAll, describe, expect, test } from 'vitest'
+import { beforeAll, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 import { closeChannelOnChain, deployEscrow, openChannel } from '~test/tempo/session.js'
 import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'

package/src/tempo/server/Session.test.ts

@@ -4,7 +4,10 @@ import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import { type Address, createClient, type Hex } from 'viem'
 import { waitForTransactionReceipt } from 'viem/actions'
 import { Addresses } from 'viem/tempo'
-import { beforeAll, beforeEach, describe, expect, test } from 'vitest'
+import { beforeAll, beforeEach, describe, expect, expectTypeOf, test } from 'vp/test'
+import { nodeEnv } from '~test/config.js'
+
+const isLocalnet = nodeEnv === 'localnet'
 import {
   deployEscrow,
   requestCloseChannel,
@@ -19,7 +22,6 @@ import {
   ChannelNotFoundError,
   InsufficientBalanceError,
   InvalidSignatureError,
-  VerificationFailedError,
 } from '../../Errors.js'
 import * as Store from '../../Store.js'
 import {
@@ -33,6 +35,7 @@ import { signVoucher } from '../session/Voucher.js'
 import { charge, session, settle } from './Session.js'
 
 const payer = accounts[2]
+const recipientAccount = accounts[0]
 const recipient = accounts[0].address
 const currency = asset
 
@@ -40,12 +43,13 @@ let escrowContract: Address
 let saltCounter = 0
 
 beforeAll(async () => {
+  if (!isLocalnet) return
   escrowContract = await deployEscrow()
   await fundAccount({ address: payer.address, token: Addresses.pathUsd })
   await fundAccount({ address: payer.address, token: currency })
 })
 
-describe('session', () => {
+describe.runIf(isLocalnet)('session', () => {
   let rawStore: Store.Store
   let store: ChannelStore.ChannelStore
 
@@ -58,7 +62,7 @@ describe('session', () => {
     return session({
       store: rawStore,
       getClient: () => client,
-      account: recipient,
+      account: recipientAccount,
       currency,
       escrowContract,
       chainId: chain.id,
@@ -618,7 +622,47 @@ describe('session', () => {
       ).rejects.toThrow(InvalidSignatureError)
     })
 
-    test('rejects exact replay of already-verified voucher (non-increasing)', async () => {
+    test('accepts exact replay of already-verified voucher as idempotent', async () => {
+      const { channelId, serializedTransaction } = await createSignedOpenTransaction(10000000n)
+      const server = createServer()
+      await openServerChannel(server, channelId, serializedTransaction)
+
+      const payload = {
+        action: 'voucher' as const,
+        channelId,
+        cumulativeAmount: '2000000',
+        signature: await signTestVoucher(channelId, 2000000n),
+      }
+
+      await server.verify({
+        credential: {
+          challenge: makeChallenge({ id: 'challenge-2', channelId }),
+          payload,
+        },
+        request: makeRequest(),
+      })
+
+      const channelAfterFirstAccept = await store.getChannel(channelId)
+
+      const replayReceipt = (await server.verify({
+        credential: {
+          challenge: makeChallenge({ id: 'challenge-3', channelId }),
+          payload,
+        },
+        request: makeRequest(),
+      })) as SessionReceipt
+
+      expect(replayReceipt.status).toBe('success')
+      expect(replayReceipt.acceptedCumulative).toBe('2000000')
+      expect(replayReceipt.spent).toBe(channelAfterFirstAccept!.spent.toString())
+      expect(replayReceipt.units).toBe(channelAfterFirstAccept!.units)
+
+      const channelAfterReplay = await store.getChannel(channelId)
+      expect(channelAfterReplay).toEqual(channelAfterFirstAccept)
+      expect(channelAfterReplay!.highestVoucherAmount).toBe(2000000n)
+    })
+
+    test('rejects exact replay with invalid signature', async () => {
       const { channelId, serializedTransaction } = await createSignedOpenTransaction(10000000n)
       const server = createServer()
       await openServerChannel(server, channelId, serializedTransaction)
@@ -642,11 +686,14 @@ describe('session', () => {
         server.verify({
           credential: {
             challenge: makeChallenge({ id: 'challenge-3', channelId }),
-            payload,
+            payload: {
+              ...payload,
+              signature: `0x${'ab'.repeat(65)}` as Hex,
+            },
           },
           request: makeRequest(),
         }),
-      ).rejects.toThrow(VerificationFailedError)
+      ).rejects.toThrow(InvalidSignatureError)
     })
 
     test('rejects replayed voucher at settled amount after on-chain settlement', async () => {
@@ -1191,27 +1238,29 @@ describe('session', () => {
       expect(ch!.finalized).toBe(true)
     })
 
-    test('close throws when client has no account', async () => {
-      const { channelId, serializedTransaction } = await createSignedOpenTransaction(10000000n)
-      const server = createServer({
-        getClient: () => createClient({ chain, transport: http() }),
-      })
-      await openServerChannel(server, channelId, serializedTransaction)
-
-      await expect(
-        server.verify({
-          credential: {
-            challenge: makeChallenge({ id: 'challenge-2', channelId }),
-            payload: {
-              action: 'close' as const,
-              channelId,
-              cumulativeAmount: '1000000',
-              signature: await signTestVoucher(channelId, 1000000n),
-            },
-          },
-          request: makeRequest(),
-        }),
-      ).rejects.toThrow('Cannot close channel: no account available')
+    test('session() throws at initialization when no account provided', () => {
+      expect(() =>
+        session({
+          store: rawStore,
+          getClient: () => client,
+          account: recipient as Address,
+          currency,
+          escrowContract,
+          chainId: chain.id,
+        } as session.Parameters),
+      ).toThrow('tempo.session() requires an `account`')
+    })
+
+    test('session() throws at initialization with no account at all', () => {
+      expect(() =>
+        session({
+          store: rawStore,
+          getClient: () => client,
+          currency,
+          escrowContract,
+          chainId: chain.id,
+        } as session.Parameters),
+      ).toThrow('tempo.session() requires an `account`')
     })
   })
 
@@ -2208,6 +2257,7 @@ describe('monotonicity and TOCTOU (unit tests)', () => {
 })
 
 describe('session default currency resolution', () => {
+  const mockAccount = accounts[0]
   const mockClient = createClient({ transport: http('http://localhost:1') })
   const mockMainnetClient = createClient({
     chain: {
@@ -2232,7 +2282,7 @@ describe('session default currency resolution', () => {
     const server = session({
       store: Store.memory(),
       getClient: () => mockClient,
-      account: '0x0000000000000000000000000000000000000001',
+      account: mockAccount,
       escrowContract: '0x0000000000000000000000000000000000000002',
     } as session.Parameters)
     expect(server.defaults?.currency).toBe('0x20C000000000000000000000b9537d11c60E8b50')
@@ -2242,7 +2292,7 @@ describe('session default currency resolution', () => {
     const server = session({
       store: Store.memory(),
       getClient: () => mockClient,
-      account: '0x0000000000000000000000000000000000000001',
+      account: mockAccount,
       escrowContract: '0x0000000000000000000000000000000000000002',
       testnet: true,
     } as session.Parameters)
@@ -2253,7 +2303,7 @@ describe('session default currency resolution', () => {
     const server = session({
       store: Store.memory(),
       getClient: () => mockClient,
-      account: '0x0000000000000000000000000000000000000001',
+      account: mockAccount,
       escrowContract: '0x0000000000000000000000000000000000000002',
       chainId: 69420,
     } as session.Parameters)
@@ -2264,7 +2314,7 @@ describe('session default currency resolution', () => {
     const server = session({
       store: Store.memory(),
       getClient: () => mockClient,
-      account: '0x0000000000000000000000000000000000000001',
+      account: mockAccount,
       currency: '0xcustom',
       escrowContract: '0x0000000000000000000000000000000000000002',
       chainId: 4217,
@@ -2277,7 +2327,7 @@ describe('session default currency resolution', () => {
     const server = session({
       store: Store.memory(),
       getClient: () => mockClient,
-      account: '0x0000000000000000000000000000000000000001',
+      account: mockAccount,
       escrowContract: '0x0000000000000000000000000000000000000002',
       chainId: 42431,
     } as session.Parameters)
@@ -2290,7 +2340,7 @@ describe('session default currency resolution', () => {
         tempo_server.session({
           store: Store.memory(),
           getClient: () => mockMainnetClient,
-          account: '0x0000000000000000000000000000000000000001',
+          account: mockAccount,
           escrowContract: '0x0000000000000000000000000000000000000002',
           chainId: 4217,
           testnet: false,
@@ -2317,7 +2367,7 @@ describe('session default currency resolution', () => {
         tempo_server.session({
           store: Store.memory(),
           getClient: () => mockTestnetClient,
-          account: '0x0000000000000000000000000000000000000001',
+          account: mockAccount,
           escrowContract: '0x0000000000000000000000000000000000000002',
           testnet: true,
         }),
@@ -2344,7 +2394,7 @@ describe('session default currency resolution', () => {
         tempo_server.session({
           store: Store.memory(),
           getClient: () => mockTestnetClient,
-          account: '0x0000000000000000000000000000000000000001',
+          account: mockAccount,
           escrowContract: '0x0000000000000000000000000000000000000002',
           chainId: 69420,
         }),
@@ -2370,7 +2420,7 @@ describe('session default currency resolution', () => {
         tempo_server.session({
           store: Store.memory(),
           getClient: () => mockClient,
-          account: '0x0000000000000000000000000000000000000001',
+          account: mockAccount,
           currency: '0xcustom',
           escrowContract: '0x0000000000000000000000000000000000000002',
           chainId: 4217,