mppx 0.6.31 → 0.8.0

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

@@ -1,8 +1,17 @@
 import { Challenge, Credential, Receipt } from 'mppx'
 import { Mppx } from 'mppx/server'
 import { KeyAuthorization } from 'ox/tempo'
-import { createClient, custom } from 'viem'
+import {
+  createClient,
+  custom,
+  decodeFunctionData,
+  encodeAbiParameters,
+  encodeEventTopics,
+  type Address,
+  type Hex,
+} from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
+import { Abis, Transaction } from 'viem/tempo'
 import { tempo as tempo_chain } from 'viem/tempo/chains'
 import { describe, expect, test } from 'vp/test'
 
@@ -15,7 +24,7 @@ import type { SubscriptionRecord } from '../subscription/Types.js'
 import { renew, subscription } from './Subscription.js'
 
 const realm = 'api.example.com'
-const secretKey = 'test-secret-key'
+const secretKey = 'test-secret-key-test-secret-key-32'
 const activeBillingAnchor = new Date(Math.floor(Date.now() / 1_000) * 1_000).toISOString()
 const activeSubscriptionExpires = new Date(
   Math.ceil((Date.now() + 365 * 24 * 60 * 60 * 1_000) / 1_000) * 1_000,
@@ -32,6 +41,9 @@ const subscriptionRecipient = '0x1234567890abcdef1234567890abcdef12345678'
 const rootAccount = privateKeyToAccount(
   '0x0000000000000000000000000000000000000000000000000000000000000001',
 )
+const otherRootAccount = privateKeyToAccount(
+  '0x0000000000000000000000000000000000000000000000000000000000000004',
+)
 const accessAccount = privateKeyToAccount(
   '0x0000000000000000000000000000000000000000000000000000000000000002',
 )
@@ -81,10 +93,11 @@ async function createCredential(
   challenge: Challenge.Challenge,
   source = rootAccount.address,
   key: SubscriptionAccessKey = accessKey,
+  account = rootAccount,
 ) {
   const keyAuthorization = await signSubscriptionKeyAuthorization({
     accessKey: key,
-    account: rootAccount,
+    account,
     chainId,
     request: challenge.request as ReturnType<typeof Methods.subscription.schema.request.parse>,
   })
@@ -117,6 +130,109 @@ function createBillingClient(hashes: readonly string[]) {
   return { client, rpcMethods }
 }
 
+const confirmedBlockHash = `0x${'f'.repeat(64)}` as const
+// Canonical TIP-1028 ReceivePolicyGuard precompile address.
+const receivePolicyGuard = '0xB10C000000000000000000000000000000000000' as Address
+
+/**
+ * Mock client whose `eth_sendRawTransactionSync` returns a confirmed receipt
+ * with a `TransferWithMemo` log derived from the broadcast transaction.
+ *
+ * `redirectTo` simulates a T6 (TIP-1028) held transfer (credits the guard, not
+ * the recipient); `addUnrelatedTransfer` adds a memo-less `Transfer` to the
+ * recipient. By default only the renewal (second) broadcast is affected so
+ * activation succeeds; `redirectActivation` also holds the first broadcast.
+ */
+function createConfirmingBillingClient(options?: {
+  addUnrelatedTransfer?: boolean
+  redirectActivation?: boolean
+  redirectTo?: Address
+}) {
+  const rpcMethods: string[] = []
+  let broadcastIndex = 0
+  const client = createClient({
+    chain: { ...tempo_chain, id: chainId },
+    transport: custom({
+      async request({ method, params }) {
+        rpcMethods.push(method)
+        if (method === 'eth_chainId') return `0x${chainId.toString(16)}`
+        if (method === 'eth_call') return '0x'
+        if (method === 'eth_sendRawTransactionSync') {
+          const index = broadcastIndex++
+          const isRenewal = index >= 1
+          const serialized = (params as [Hex])[0]
+          const transaction = Transaction.deserialize(
+            serialized as Transaction.TransactionSerializedTempo,
+          ) as unknown as {
+            from: Address
+            calls: readonly { data: Hex; to: Address }[]
+          }
+          const call = transaction.calls[0]!
+          const { args } = decodeFunctionData({
+            abi: Abis.tip20,
+            data: call.data,
+          })
+          const [recipient, amount, memo] = args as [Address, bigint, Hex]
+          const shouldRedirect = options?.redirectTo && (isRenewal || options?.redirectActivation)
+          const creditedTo = shouldRedirect ? options!.redirectTo! : recipient
+          const hash = `0x${index.toString(16).padStart(64, '0')}` as Hex
+          const baseLog = {
+            blockHash: confirmedBlockHash,
+            blockNumber: '0x1',
+            data: encodeAbiParameters([{ type: 'uint256' }], [amount]),
+            logIndex: '0x0',
+            removed: false,
+            transactionHash: hash,
+            transactionIndex: '0x0',
+          } as const
+          const logs: unknown[] = [
+            {
+              ...baseLog,
+              address: call.to,
+              topics: encodeEventTopics({
+                abi: Abis.tip20,
+                args: { from: transaction.from, memo, to: creditedTo },
+                eventName: 'TransferWithMemo',
+              }),
+            },
+          ]
+          // Memo-less Transfer to the recipient: must not satisfy the check.
+          if (isRenewal && options?.addUnrelatedTransfer) {
+            logs.push({
+              ...baseLog,
+              address: call.to,
+              logIndex: '0x1',
+              topics: encodeEventTopics({
+                abi: Abis.tip20,
+                args: { from: transaction.from, to: recipient },
+                eventName: 'Transfer',
+              }),
+            })
+          }
+          return {
+            blockHash: confirmedBlockHash,
+            blockNumber: '0x1',
+            contractAddress: null,
+            cumulativeGasUsed: '0x0',
+            effectiveGasPrice: '0x0',
+            from: transaction.from,
+            gasUsed: '0x0',
+            logs,
+            logsBloom: `0x${'0'.repeat(512)}`,
+            status: '0x1',
+            to: call.to,
+            transactionHash: hash,
+            transactionIndex: '0x0',
+            type: '0x0',
+          }
+        }
+        throw new Error(`unexpected rpc method: ${method}`)
+      },
+    }),
+  })
+  return { client, rpcMethods }
+}
+
 describe('tempo.subscription', () => {
   test('stores an activated subscription and reuses it on later requests', async () => {
     const store = Store.memory()
@@ -271,6 +387,211 @@ describe('tempo.subscription', () => {
     expect(rpcMethods.filter((method) => method === 'eth_sendRawTransaction')).toHaveLength(1)
   })
 
+  test('requires a fresh credential for active subscription reuse when configured', async () => {
+    const store = Store.memory()
+    const subscriptions = SubscriptionStore.fromStore(store)
+    await subscriptions.put(
+      createRecord({
+        accessKey,
+        payer: { address: rootAccount.address, chainId },
+      }),
+    )
+    const method = subscription({
+      activate: async () => {
+        throw new Error('active subscription reuse should not activate')
+      },
+      amount: subscriptionAmount,
+      chainId,
+      currency: subscriptionCurrency,
+      periodCount: subscriptionPeriodCount,
+      periodUnit: subscriptionPeriodUnit,
+      recipient: subscriptionRecipient,
+      requireCredential: true,
+      resolve: async () => ({ accessKey, key: subscriptionKey }),
+      store,
+      subscriptionExpires: activeSubscriptionExpires,
+    })
+
+    const mppx = Mppx.create({ methods: [method], realm, secretKey })
+    const unauthenticated = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource'),
+    )
+
+    expect(unauthenticated.status).toBe(402)
+    if (unauthenticated.status !== 402) throw new Error('expected reuse challenge')
+
+    const challenge = Challenge.fromResponse(unauthenticated.challenge)
+    const credential = await createCredential(challenge)
+    const reused = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource', {
+        headers: { Authorization: Credential.serialize(credential) },
+      }),
+    )
+
+    expect(reused.status).toBe(200)
+  })
+
+  test('can derive the subscription lookup key only from the signed credential source', async () => {
+    const store = Store.memory()
+    const subscriptions = SubscriptionStore.fromStore(store)
+    const { client, rpcMethods } = createBillingClient([hashActivate])
+    const sourceKey = (source: { address: string; chainId: number }) =>
+      `payer:${source.chainId}:${source.address.toLowerCase()}:pro`
+    const method = subscription({
+      amount: subscriptionAmount,
+      chainId,
+      currency: subscriptionCurrency,
+      getClient: async () => client,
+      periodCount: subscriptionPeriodCount,
+      periodUnit: subscriptionPeriodUnit,
+      recipient: subscriptionRecipient,
+      requireCredential: true,
+      resolve: async ({ source }) => {
+        if (!source) return null
+        return { key: sourceKey(source) }
+      },
+      store,
+      subscriptionExpires: activeSubscriptionExpires,
+      waitForConfirmation: false,
+    })
+
+    const mppx = Mppx.create({ methods: [method], realm, secretKey })
+    const challengeResult = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource'),
+    )
+
+    expect(challengeResult.status).toBe(402)
+    if (challengeResult.status !== 402) throw new Error('expected source challenge')
+
+    const challenge = Challenge.fromResponse(challengeResult.challenge)
+    const challengeAccessKey = (
+      challenge.request as ReturnType<typeof Methods.subscription.schema.request.parse>
+    ).methodDetails?.accessKey
+    if (!challengeAccessKey) throw new Error('expected challenge access key')
+
+    const credential = await createCredential(challenge, rootAccount.address, challengeAccessKey)
+    const activated = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource', {
+        headers: { Authorization: Credential.serialize(credential) },
+      }),
+    )
+
+    expect(activated.status).toBe(200)
+    const lookupKey = sourceKey({ address: rootAccount.address, chainId })
+    const record = await subscriptions.getByKey(lookupKey)
+    expect(record?.lookupKey).toBe(lookupKey)
+    expect(record?.payer?.address.toLowerCase()).toBe(rootAccount.address.toLowerCase())
+    expect(record?.accessKey).toEqual(challengeAccessKey)
+    expect(rpcMethods.filter((method) => method === 'eth_sendRawTransaction')).toHaveLength(1)
+  })
+
+  test('rejects credential reuse when the signer does not match the stored payer', async () => {
+    const store = Store.memory()
+    const subscriptions = SubscriptionStore.fromStore(store)
+    await subscriptions.put(
+      createRecord({
+        accessKey,
+        payer: { address: rootAccount.address, chainId },
+      }),
+    )
+    const method = subscription({
+      activate: async () => {
+        throw new Error('active subscription reuse should not activate')
+      },
+      amount: subscriptionAmount,
+      chainId,
+      currency: subscriptionCurrency,
+      periodCount: subscriptionPeriodCount,
+      periodUnit: subscriptionPeriodUnit,
+      recipient: subscriptionRecipient,
+      requireCredential: true,
+      resolve: async () => ({ accessKey, key: subscriptionKey }),
+      store,
+      subscriptionExpires: activeSubscriptionExpires,
+    })
+
+    const mppx = Mppx.create({ methods: [method], realm, secretKey })
+    const challengeResult = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource'),
+    )
+    if (challengeResult.status !== 402) throw new Error('expected reuse challenge')
+
+    const challenge = Challenge.fromResponse(challengeResult.challenge)
+    const credential = await createCredential(
+      challenge,
+      otherRootAccount.address,
+      accessKey,
+      otherRootAccount,
+    )
+    const rejected = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource', {
+        headers: { Authorization: Credential.serialize(credential) },
+      }),
+    )
+
+    expect(rejected.status).toBe(402)
+    if (rejected.status !== 402) throw new Error('expected payer mismatch challenge')
+    const body = await rejected.challenge.json()
+    expect(body.detail).toBe('Payment verification failed: subscription payer mismatch.')
+  })
+
+  test('renews an overdue active subscription after credential-required payer proof', async () => {
+    const store = Store.memory()
+    const subscriptions = SubscriptionStore.fromStore(store)
+    await subscriptions.put(
+      createRecord({
+        accessKey,
+        billingAnchor: new Date(Date.now() - 3 * subscriptionPeriodMilliseconds).toISOString(),
+        lastChargedPeriod: 0,
+        payer: { address: rootAccount.address, chainId },
+        reference: hashStale,
+      }),
+    )
+    const method = subscription({
+      activate: async () => {
+        throw new Error('active subscription renewal should not activate')
+      },
+      amount: subscriptionAmount,
+      chainId,
+      currency: subscriptionCurrency,
+      periodCount: subscriptionPeriodCount,
+      periodUnit: subscriptionPeriodUnit,
+      recipient: subscriptionRecipient,
+      renew: async ({ periodIndex, subscription }) => ({
+        receipt: createReceipt(subscription.subscriptionId, hashRenewed),
+        subscription: {
+          ...subscription,
+          lastChargedPeriod: periodIndex,
+          reference: hashRenewed,
+        },
+      }),
+      requireCredential: true,
+      resolve: async () => ({ accessKey, key: subscriptionKey }),
+      store,
+      subscriptionExpires: activeSubscriptionExpires,
+    })
+
+    const mppx = Mppx.create({ methods: [method], realm, secretKey })
+    const challengeResult = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource'),
+    )
+    if (challengeResult.status !== 402) throw new Error('expected reuse challenge')
+
+    const challenge = Challenge.fromResponse(challengeResult.challenge)
+    const credential = await createCredential(challenge)
+    const renewed = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource', {
+        headers: { Authorization: Credential.serialize(credential) },
+      }),
+    )
+
+    expect(renewed.status).toBe(200)
+    if (renewed.status !== 200) throw new Error('expected credential renewal')
+    const receipt = Receipt.fromResponse(renewed.withReceipt(new Response('OK')))
+    expect(receipt.reference).toBe(hashRenewed)
+    expect((await subscriptions.getByKey(subscriptionKey))?.lastChargedPeriod).toBeGreaterThan(0)
+  })
+
   test('verifyCredential activates a subscription credential with a canonical challenge request', async () => {
     const store = Store.memory()
     const { client } = createBillingClient([hashActivate])
@@ -357,6 +678,147 @@ describe('tempo.subscription', () => {
     expect((await subscriptions.get(record.subscriptionId))?.lastChargedPeriod).toBeGreaterThan(0)
   })
 
+  async function activateConfirmedSubscription(parameters: {
+    client: ReturnType<typeof createConfirmingBillingClient>['client']
+    store: ReturnType<typeof Store.memory>
+  }) {
+    const { client, store } = parameters
+    const method = subscription({
+      amount: subscriptionAmount,
+      chainId,
+      currency: subscriptionCurrency,
+      getClient: async () => client,
+      periodCount: subscriptionPeriodCount,
+      periodUnit: subscriptionPeriodUnit,
+      recipient: subscriptionRecipient,
+      resolve: async () => ({ key: subscriptionKey }),
+      store,
+      subscriptionExpires: activeSubscriptionExpires,
+    })
+    const mppx = Mppx.create({ methods: [method], realm, secretKey })
+    const challengeResult = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource'),
+    )
+    if (challengeResult.status !== 402) throw new Error('expected activation challenge')
+    const challenge = Challenge.fromResponse(challengeResult.challenge)
+    const accessKey = (
+      challenge.request as ReturnType<typeof Methods.subscription.schema.request.parse>
+    ).methodDetails?.accessKey
+    if (!accessKey) throw new Error('expected generated access key')
+    const credential = await createCredential(challenge, rootAccount.address, accessKey)
+    const activated = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource', {
+        headers: { Authorization: Credential.serialize(credential) },
+      }),
+    )
+    expect(activated.status).toBe(200)
+    return { mppx }
+  }
+
+  test('renews when the confirmed receipt credits the recipient', async () => {
+    const store = Store.memory()
+    const subscriptions = SubscriptionStore.fromStore(store)
+    const { client } = createConfirmingBillingClient()
+    const { mppx } = await activateConfirmedSubscription({ client, store })
+
+    const record = await subscriptions.getByKey(subscriptionKey)
+    if (!record) throw new Error('expected subscription record')
+    await subscriptions.put({
+      ...record,
+      billingAnchor: new Date(Date.now() - 3 * subscriptionPeriodMilliseconds).toISOString(),
+      lastChargedPeriod: 0,
+    })
+
+    const renewed = await mppx.tempo.subscription({})(new Request('https://example.com/resource'))
+    expect(renewed.status).toBe(200)
+    expect((await subscriptions.get(record.subscriptionId))?.lastChargedPeriod).toBeGreaterThan(0)
+  })
+
+  test('rejects renewal when a receive policy holds the confirmed transfer', async () => {
+    const store = Store.memory()
+    const subscriptions = SubscriptionStore.fromStore(store)
+    const { client } = createConfirmingBillingClient({ redirectTo: receivePolicyGuard })
+    const { mppx } = await activateConfirmedSubscription({ client, store })
+
+    const record = await subscriptions.getByKey(subscriptionKey)
+    if (!record) throw new Error('expected subscription record')
+    await subscriptions.put({
+      ...record,
+      billingAnchor: new Date(Date.now() - 3 * subscriptionPeriodMilliseconds).toISOString(),
+      lastChargedPeriod: 0,
+    })
+
+    const renewed = await mppx.tempo.subscription({})(new Request('https://example.com/resource'))
+    expect(renewed.status).toBe(402)
+    // The held renewal must not advance the billing period.
+    expect((await subscriptions.get(record.subscriptionId))?.lastChargedPeriod).toBe(0)
+  })
+
+  test('rejects a held renewal even when a memo-less Transfer credits the recipient', async () => {
+    const store = Store.memory()
+    const subscriptions = SubscriptionStore.fromStore(store)
+    // Settlement is held, but the receipt also has a memo-less Transfer to the
+    // recipient; the memo-bound check must still reject it.
+    const { client } = createConfirmingBillingClient({
+      addUnrelatedTransfer: true,
+      redirectTo: receivePolicyGuard,
+    })
+    const { mppx } = await activateConfirmedSubscription({ client, store })
+
+    const record = await subscriptions.getByKey(subscriptionKey)
+    if (!record) throw new Error('expected subscription record')
+    await subscriptions.put({
+      ...record,
+      billingAnchor: new Date(Date.now() - 3 * subscriptionPeriodMilliseconds).toISOString(),
+      lastChargedPeriod: 0,
+    })
+
+    const renewed = await mppx.tempo.subscription({})(new Request('https://example.com/resource'))
+    expect(renewed.status).toBe(402)
+    expect((await subscriptions.get(record.subscriptionId))?.lastChargedPeriod).toBe(0)
+  })
+
+  test('rejects activation when a receive policy holds the confirmed transfer', async () => {
+    const store = Store.memory()
+    const subscriptions = SubscriptionStore.fromStore(store)
+    const { client } = createConfirmingBillingClient({
+      redirectActivation: true,
+      redirectTo: receivePolicyGuard,
+    })
+    const method = subscription({
+      amount: subscriptionAmount,
+      chainId,
+      currency: subscriptionCurrency,
+      getClient: async () => client,
+      periodCount: subscriptionPeriodCount,
+      periodUnit: subscriptionPeriodUnit,
+      recipient: subscriptionRecipient,
+      resolve: async () => ({ key: subscriptionKey }),
+      store,
+      subscriptionExpires: activeSubscriptionExpires,
+    })
+    const mppx = Mppx.create({ methods: [method], realm, secretKey })
+    const challengeResult = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource'),
+    )
+    if (challengeResult.status !== 402) throw new Error('expected activation challenge')
+    const challenge = Challenge.fromResponse(challengeResult.challenge)
+    const generatedAccessKey = (
+      challenge.request as ReturnType<typeof Methods.subscription.schema.request.parse>
+    ).methodDetails?.accessKey
+    if (!generatedAccessKey) throw new Error('expected generated access key')
+    const credential = await createCredential(challenge, rootAccount.address, generatedAccessKey)
+    const activated = await mppx.tempo.subscription({})(
+      new Request('https://example.com/resource', {
+        headers: { Authorization: Credential.serialize(credential) },
+      }),
+    )
+
+    expect(activated.status).toBe(402)
+    // A held activation must not persist an active subscription.
+    expect(await subscriptions.getByKey(subscriptionKey)).toBeNull()
+  })
+
   test('returns a management response while renewal is already in flight', async () => {
     const store = Store.memory()
     const subscriptions = SubscriptionStore.fromStore(store)