mppx 0.3.5 → 0.3.7

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

@@ -656,6 +656,156 @@ describe('tempo', () => {
     })
   })
 
+  describe('default currency resolution', () => {
+    test('mainnet (default) resolves to USDC', () => {
+      const method = tempo_server.charge({
+        getClient: () => client,
+        account: accounts[0].address,
+      })
+      expect((method.defaults as Record<string, unknown>)?.currency).toBe(
+        '0x20C000000000000000000000b9537d11c60E8b50',
+      )
+    })
+
+    test('testnet: true defaults to pathUSD', () => {
+      const method = tempo_server.charge({
+        getClient: () => client,
+        account: accounts[0].address,
+        testnet: true,
+      })
+      expect((method.defaults as Record<string, unknown>)?.currency).toBe(
+        '0x20c0000000000000000000000000000000000000',
+      )
+    })
+
+    test('unknown chain defaults to pathUSD', () => {
+      const method = tempo_server.charge({
+        getClient: () => client,
+        account: accounts[0].address,
+        chainId: 69420,
+      })
+      expect((method.defaults as Record<string, unknown>)?.currency).toBe(
+        '0x20c0000000000000000000000000000000000000',
+      )
+    })
+
+    test('explicit currency overrides default', () => {
+      const method = tempo_server.charge({
+        getClient: () => client,
+        account: accounts[0].address,
+        testnet: false,
+        currency: '0xcustom',
+      })
+      expect(method.defaults?.currency).toBe('0xcustom')
+    })
+
+    test('decimals defaults to 6', () => {
+      const method = tempo_server.charge({
+        getClient: () => client,
+        account: accounts[0].address,
+      })
+      expect((method.defaults as Record<string, unknown>)?.decimals).toBe(6)
+    })
+
+    test('challenge contains USDC currency (mainnet default)', async () => {
+      const handler = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient: () => client,
+            account: accounts[0].address,
+          }),
+        ],
+        realm,
+        secretKey,
+      })
+
+      const result = await (handler.charge as Function)({ amount: '1' })(
+        new Request('https://example.com'),
+      )
+      expect(result.status).toBe(402)
+      if (result.status !== 402) throw new Error()
+
+      const challenge = Challenge.fromResponse(result.challenge, {
+        methods: [tempo_client.charge()],
+      })
+      expect(challenge.request.currency).toBe('0x20C000000000000000000000b9537d11c60E8b50')
+    })
+
+    test('challenge contains pathUSD currency when testnet: true', async () => {
+      const handler = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient: () => client,
+            account: accounts[0].address,
+            testnet: true,
+          }),
+        ],
+        realm,
+        secretKey,
+      })
+
+      const result = await (handler.charge as Function)({ amount: '1', chainId: chain.id })(
+        new Request('https://example.com'),
+      )
+      expect(result.status).toBe(402)
+      if (result.status !== 402) throw new Error()
+
+      const challenge = Challenge.fromResponse(result.challenge, {
+        methods: [tempo_client.charge()],
+      })
+      expect(challenge.request.currency).toBe('0x20c0000000000000000000000000000000000000')
+    })
+
+    test('challenge contains pathUSD currency (unknown chain)', async () => {
+      const handler = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient: () => client,
+            account: accounts[0].address,
+            chainId: 69420,
+          }),
+        ],
+        realm,
+        secretKey,
+      })
+
+      const result = await (handler.charge as Function)({ amount: '1' })(
+        new Request('https://example.com'),
+      )
+      expect(result.status).toBe(402)
+      if (result.status !== 402) throw new Error()
+
+      const challenge = Challenge.fromResponse(result.challenge, {
+        methods: [tempo_client.charge()],
+      })
+      expect(challenge.request.currency).toBe('0x20c0000000000000000000000000000000000000')
+    })
+
+    test('explicit currency in challenge overrides testnet default', async () => {
+      const handler = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient: () => client,
+            account: accounts[0].address,
+            testnet: false,
+            currency: asset,
+          }),
+        ],
+        realm,
+        secretKey,
+      })
+
+      const result = await handler.charge({ amount: '1' })(new Request('https://example.com'))
+      expect(result.status).toBe(402)
+      if (result.status !== 402) throw new Error()
+
+      const challenge = Challenge.fromResponse(result.challenge, {
+        methods: [tempo_client.charge()],
+      })
+      expect(challenge.request.currency).toBe(asset)
+    })
+  })
+
   describe('attribution memo', () => {
     test('client always generates attribution memo (hash credential)', async () => {
       const httpServer = await Http.createServer(async (req, res) => {

package/src/tempo/server/Charge.ts

@@ -40,7 +40,7 @@ export function charge<const parameters extends charge.Parameters>(
 ) {
   const {
     amount,
-    currency,
+    currency = defaults.resolveCurrency(parameters),
     decimals = defaults.decimals,
     description,
     externalId,
@@ -71,7 +71,7 @@ export function charge<const parameters extends charge.Parameters>(
     async request({ credential, request }) {
       const chainId = await (async () => {
         if (request.chainId) return request.chainId
-        if (parameters.testnet) return defaults.testnetChainId
+        if (parameters.testnet) return defaults.chainId.testnet
         return (await getClient({})).chain?.id
       })()
 

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

@@ -1,4 +1,5 @@
-import type { Challenge, z } from 'mppx'
+import type { z } from 'mppx'
+import { Challenge } from 'mppx'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import { type Address, createClient, type Hex } from 'viem'
 import { Addresses } from 'viem/tempo'
@@ -1334,6 +1335,193 @@ describe('monotonicity and TOCTOU (unit tests)', () => {
   })
 })
 
+describe('session default currency resolution', () => {
+  const mockClient = createClient({ transport: http('http://localhost:1') })
+  const mockMainnetClient = createClient({
+    chain: {
+      id: 4217,
+      name: 'Tempo',
+      nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+      rpcUrls: { default: { http: ['http://localhost:1'] } },
+    },
+    transport: http('http://localhost:1'),
+  })
+  const mockTestnetClient = createClient({
+    chain: {
+      id: 42431,
+      name: 'Tempo Testnet',
+      nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+      rpcUrls: { default: { http: ['http://localhost:1'] } },
+    },
+    transport: http('http://localhost:1'),
+  })
+
+  test('mainnet (default) resolves to USDC', () => {
+    const server = session({
+      store: Store.memory(),
+      getClient: () => mockClient,
+      account: '0x0000000000000000000000000000000000000001',
+      escrowContract: '0x0000000000000000000000000000000000000002',
+    } as session.Parameters)
+    expect(server.defaults?.currency).toBe('0x20C000000000000000000000b9537d11c60E8b50')
+  })
+
+  test('testnet: true defaults to pathUSD', () => {
+    const server = session({
+      store: Store.memory(),
+      getClient: () => mockClient,
+      account: '0x0000000000000000000000000000000000000001',
+      escrowContract: '0x0000000000000000000000000000000000000002',
+      testnet: true,
+    } as session.Parameters)
+    expect(server.defaults?.currency).toBe('0x20c0000000000000000000000000000000000000')
+  })
+
+  test('unknown chain defaults to pathUSD', () => {
+    const server = session({
+      store: Store.memory(),
+      getClient: () => mockClient,
+      account: '0x0000000000000000000000000000000000000001',
+      escrowContract: '0x0000000000000000000000000000000000000002',
+      chainId: 69420,
+    } as session.Parameters)
+    expect(server.defaults?.currency).toBe('0x20c0000000000000000000000000000000000000')
+  })
+
+  test('explicit currency overrides default', () => {
+    const server = session({
+      store: Store.memory(),
+      getClient: () => mockClient,
+      account: '0x0000000000000000000000000000000000000001',
+      currency: '0xcustom',
+      escrowContract: '0x0000000000000000000000000000000000000002',
+      chainId: 4217,
+      testnet: false,
+    } as session.Parameters)
+    expect(server.defaults?.currency).toBe('0xcustom')
+  })
+
+  test('decimals defaults to 6', () => {
+    const server = session({
+      store: Store.memory(),
+      getClient: () => mockClient,
+      account: '0x0000000000000000000000000000000000000001',
+      escrowContract: '0x0000000000000000000000000000000000000002',
+      chainId: 42431,
+    } as session.Parameters)
+    expect(server.defaults?.decimals).toBe(6)
+  })
+
+  test('challenge contains USDC currency (mainnet default)', async () => {
+    const handler = Mppx_server.create({
+      methods: [
+        tempo_server.session({
+          store: Store.memory(),
+          getClient: () => mockMainnetClient,
+          account: '0x0000000000000000000000000000000000000001',
+          escrowContract: '0x0000000000000000000000000000000000000002',
+          chainId: 4217,
+          testnet: false,
+        }),
+      ],
+      realm: 'api.example.com',
+      secretKey: 'secret',
+    })
+
+    const result = await (handler.session as Function)({
+      amount: '1',
+      decimals: 6,
+      unitType: 'token',
+    })(new Request('https://example.com'))
+    expect(result.status).toBe(402)
+
+    const challenge = Challenge.fromResponse(result.challenge)
+    expect(challenge.request.currency).toBe('0x20C000000000000000000000b9537d11c60E8b50')
+  })
+
+  test('challenge contains pathUSD currency when testnet: true', async () => {
+    const handler = Mppx_server.create({
+      methods: [
+        tempo_server.session({
+          store: Store.memory(),
+          getClient: () => mockTestnetClient,
+          account: '0x0000000000000000000000000000000000000001',
+          escrowContract: '0x0000000000000000000000000000000000000002',
+          testnet: true,
+        }),
+      ],
+      realm: 'api.example.com',
+      secretKey: 'secret',
+    })
+
+    const result = await (handler.session as Function)({
+      amount: '1',
+      decimals: 6,
+      unitType: 'token',
+      chainId: 42431,
+    })(new Request('https://example.com'))
+    expect(result.status).toBe(402)
+
+    const challenge = Challenge.fromResponse(result.challenge)
+    expect(challenge.request.currency).toBe('0x20c0000000000000000000000000000000000000')
+  })
+
+  test('challenge contains pathUSD currency (unknown chain)', async () => {
+    const handler = Mppx_server.create({
+      methods: [
+        tempo_server.session({
+          store: Store.memory(),
+          getClient: () => mockTestnetClient,
+          account: '0x0000000000000000000000000000000000000001',
+          escrowContract: '0x0000000000000000000000000000000000000002',
+          chainId: 69420,
+        }),
+      ],
+      realm: 'api.example.com',
+      secretKey: 'secret',
+    })
+
+    const result = await (handler.session as Function)({
+      amount: '1',
+      decimals: 6,
+      unitType: 'token',
+    })(new Request('https://example.com'))
+    expect(result.status).toBe(402)
+
+    const challenge = Challenge.fromResponse(result.challenge)
+    expect(challenge.request.currency).toBe('0x20c0000000000000000000000000000000000000')
+  })
+
+  test('explicit currency in challenge overrides testnet default', async () => {
+    const handler = Mppx_server.create({
+      methods: [
+        tempo_server.session({
+          store: Store.memory(),
+          getClient: () => mockClient,
+          account: '0x0000000000000000000000000000000000000001',
+          currency: '0xcustom',
+          escrowContract: '0x0000000000000000000000000000000000000002',
+          chainId: 4217,
+          testnet: false,
+        }),
+      ],
+      realm: 'api.example.com',
+      secretKey: 'secret',
+    })
+
+    const result = await handler.session({
+      amount: '1',
+      decimals: 6,
+      unitType: 'token',
+    })(new Request('https://example.com'))
+    expect(result.status).toBe(402)
+    if (result.status !== 402) throw new Error()
+
+    const challenge = Challenge.fromResponse(result.challenge)
+    expect(challenge.request.currency).toBe('0xcustom')
+  })
+})
+
 function nextSalt(): Hex {
   saltCounter++
   return `0x${saltCounter.toString(16).padStart(64, '0')}` as Hex

package/src/tempo/server/Session.ts

@@ -85,7 +85,7 @@ export function session<const parameters extends session.Parameters>(p?: paramet
   const parameters = p as parameters
   const {
     amount,
-    currency,
+    currency = defaults.resolveCurrency(parameters),
     decimals = defaults.decimals,
     store: rawStore = Store.memory(),
     suggestedDeposit,
@@ -127,7 +127,7 @@ export function session<const parameters extends session.Parameters>(p?: paramet
       // Extract chainId from request or default.
       const chainId = await (async () => {
         if (request.chainId) return request.chainId
-        if (parameters.testnet) return defaults.testnetChainId
+        if (parameters.testnet) return defaults.chainId.testnet
         return (await getClient({})).chain?.id
       })()
 
@@ -156,7 +156,12 @@ export function session<const parameters extends session.Parameters>(p?: paramet
         return undefined
       })()
 
-      return { ...request, chainId, escrowContract: resolvedEscrow, feePayer: resolvedFeePayer }
+      return {
+        ...request,
+        chainId,
+        escrowContract: resolvedEscrow,
+        feePayer: resolvedFeePayer,
+      }
     },
 
     async verify({ credential }) {

package/src/tempo/session/Voucher.test.ts

@@ -131,4 +131,50 @@ describe('Voucher', () => {
     expect(voucher.cumulativeAmount).toBe(5000000n)
     expect(voucher.signature).toBe(sig)
   })
+
+  test('parseVoucherFromPayload with zero amount', () => {
+    const sig =
+      '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890ab' as const
+    const voucher = parseVoucherFromPayload(channelId, '0', sig)
+    expect(voucher.cumulativeAmount).toBe(0n)
+  })
+
+  test('verifyVoucher rejects wrong escrow contract', async () => {
+    const signature = await signVoucher(
+      client,
+      account,
+      { channelId, cumulativeAmount },
+      escrowContract,
+      chainId,
+    )
+
+    const wrongEscrow = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd' as const
+    const isValid = await verifyVoucher(
+      wrongEscrow,
+      chainId,
+      { channelId, cumulativeAmount, signature },
+      account.address,
+    )
+    expect(isValid).toBe(false)
+  })
+
+  test('signVoucher and verifyVoucher round-trip with zero amount', async () => {
+    const zeroAmount = 0n
+    const signature = await signVoucher(
+      client,
+      account,
+      { channelId, cumulativeAmount: zeroAmount },
+      escrowContract,
+      chainId,
+    )
+    expect(signature).toMatch(/^0x/)
+
+    const isValid = await verifyVoucher(
+      escrowContract,
+      chainId,
+      { channelId, cumulativeAmount: zeroAmount, signature },
+      account.address,
+    )
+    expect(isValid).toBe(true)
+  })
 })