mppx 0.6.31 → 0.7.0

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

@@ -3,8 +3,8 @@ 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 { P256, type Hex, WebAuthnP256 } from 'ox'
 import { SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
-import { Handler } from 'tempo.ts/server'
-import { createClient, custom, encodeFunctionData, parseUnits } from 'viem'
+import { createClient, custom, encodeFunctionData, parseSignature, parseUnits } from 'viem'
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import {
   getTransactionReceipt,
   prepareTransactionRequest,
@@ -15,17 +15,37 @@ import {
 import { Abis, Account, Actions, Addresses, Secp256k1, Tick, Transaction } from 'viem/tempo'
 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 {
+  closeChannelOnChain,
+  deployEscrow,
+  openChannel,
+  signVoucher,
+} from '~test/tempo/legacy/session.js'
 import { accounts, asset, chain, client, fundAccount, http } from '~test/tempo/viem.js'
 
 import * as Store from '../../Store.js'
 import * as Attribution from '../Attribution.js'
+import * as defaults from '../internal/defaults.js'
 import * as Proof from '../internal/proof.js'
-import { signVoucher } from '../session/Voucher.js'
 
 const realm = 'api.example.com'
 const secretKey = 'test-secret-key'
 
+function isPairAlreadyExistsError(error: unknown) {
+  if (typeof error !== 'object' || error === null) return false
+  const candidate = error as {
+    details?: string | undefined
+    shortMessage?: string | undefined
+  }
+  return [candidate.details, candidate.shortMessage].some((message) =>
+    message?.includes('PairAlreadyExists'),
+  )
+}
+
+function testAccount() {
+  return privateKeyToAccount(generatePrivateKey())
+}
+
 type ProofAccessKeyContext = {
   accessKey: ReturnType<typeof Account.fromSecp256k1>
   rootAccount: (typeof accounts)[number]
@@ -1796,11 +1816,64 @@ describe('tempo', () => {
     })
 
     test('behavior: fee payer URL (withFeePayer transport)', async () => {
-      const feePayerHandler = Handler.feePayer({
-        account: accounts[0],
-        client,
+      const feePayerRequests: any[] = []
+      const feePayerServer = await Http.createServer(async (req, res) => {
+        let requestBody = ''
+        for await (const chunk of req) requestBody += chunk
+        const request = JSON.parse(requestBody)
+        feePayerRequests.push(request)
+
+        const transaction = request.params[0]
+        const quantity = (value: unknown) =>
+          value === undefined ? undefined : BigInt(value as string | number | bigint | boolean)
+        const envelope = TxEnvelopeTempo.from({
+          accessList: transaction.accessList,
+          calls: transaction.calls.map(({ value, ...call }: any) => ({
+            ...call,
+            ...(value && value !== '0x' ? { value: BigInt(value) } : {}),
+          })),
+          chainId: chain.id,
+          feeToken: defaults.tokens.pathUsd,
+          from: transaction.from,
+          ...(quantity(transaction.gas) !== undefined ? { gas: quantity(transaction.gas) } : {}),
+          ...(quantity(transaction.maxFeePerGas) !== undefined
+            ? { maxFeePerGas: quantity(transaction.maxFeePerGas) }
+            : {}),
+          ...(quantity(transaction.maxPriorityFeePerGas) !== undefined
+            ? { maxPriorityFeePerGas: quantity(transaction.maxPriorityFeePerGas) }
+            : {}),
+          ...(quantity(transaction.nonce) !== undefined
+            ? { nonce: quantity(transaction.nonce) }
+            : {}),
+          ...(quantity(transaction.nonceKey) !== undefined
+            ? { nonceKey: quantity(transaction.nonceKey) }
+            : {}),
+          type: 'tempo',
+          ...(transaction.validAfter ? { validAfter: Number(BigInt(transaction.validAfter)) } : {}),
+          ...(transaction.validBefore
+            ? { validBefore: Number(BigInt(transaction.validBefore)) }
+            : {}),
+        })
+        const hash = TxEnvelopeTempo.getFeePayerSignPayload(envelope, {
+          sender: transaction.from,
+        })
+        const { r, s, yParity } = parseSignature(await accounts[0].sign!({ hash }))
+        const feePayerSignature = { r, s, yParity }
+
+        res.setHeader('content-type', 'application/json')
+        res.end(
+          JSON.stringify({
+            id: request.id,
+            jsonrpc: '2.0',
+            result: {
+              tx: {
+                feePayerSignature,
+                feeToken: defaults.tokens.pathUsd,
+              },
+            },
+          }),
+        )
       })
-      const feePayerServer = await Http.createServer(feePayerHandler.listener)
 
       const serverWithFeePayer = Mppx_server.create({
         methods: [
@@ -1838,6 +1911,7 @@ describe('tempo', () => {
 
       const response = await mppx.fetch(httpServer.url)
       expect(response.status).toBe(200)
+      expect(feePayerRequests.map(({ method }) => method)).toEqual(['eth_fillTransaction'])
 
       const receipt = Receipt.fromResponse(response)
       expect(receipt.status).toBe('success')
@@ -4931,19 +5005,21 @@ describe('tempo', () => {
 
   describe('auto-swap', () => {
     // Use accounts[3] as payer with pathUsd only (no asset).
-    // Use accounts[4] as payer with zero balance.
     const swapPayer = accounts[3]!
-    const brokePayer = accounts[4]!
 
     beforeAll(async () => {
       // Fund swap payer with pathUsd only
       await fundAccount({ address: swapPayer.address, token: Addresses.pathUsd as Hex.Hex })
 
       // Seed DEX liquidity: create pair, then place a sell order for `asset`.
-      await Actions.dex.createPair(client, {
-        account: accounts[0]!,
-        base: asset,
-      })
+      await Actions.dex
+        .createPair(client, {
+          account: accounts[0]!,
+          base: asset,
+        })
+        .catch((error) => {
+          if (!isPairAlreadyExistsError(error)) throw error
+        })
       await fundAccount({ address: accounts[0]!.address, token: asset })
       await Actions.token.approveSync(client, {
         account: accounts[0]!,
@@ -5171,6 +5247,7 @@ describe('tempo', () => {
     })
 
     test('error: throws when no fallback currency has sufficient balance', async () => {
+      const brokePayer = testAccount()
       const mppx = Mppx_client.create({
         polyfill: false,
         methods: [
@@ -5234,6 +5311,7 @@ describe('tempo', () => {
 
     test('error: throws when tokenIn list has no viable candidates', async () => {
       const bogusToken = '0x0000000000000000000000000000000000099999' as const
+      const brokePayer = testAccount()
 
       const mppx = Mppx_client.create({
         polyfill: false,

package/src/tempo/server/Charge.ts

@@ -400,35 +400,39 @@ export function charge<const parameters extends charge.Parameters>(
               )
             }
 
-            const expectedFeeToken = defaults.currency[chainId as keyof typeof defaults.currency]
-            const resolvedFeeToken = transaction.feeToken ?? expectedFeeToken
+            const allowedFeeTokens = FeePayer.defaultAllowedFeeTokens(chainId)
+            if (isFeePayerTx) FeePayer.assertAllowedFeeToken(transaction, allowedFeeTokens)
 
             const serializedTransaction_final = await (async () => {
               if (feePayerAccount && methodDetails?.feePayer !== false) {
                 const sponsored = FeePayer.prepareSponsoredTransaction({
                   account: feePayerAccount,
+                  allowedFeeTokens,
                   challengeExpires: expires,
                   chainId: chainId ?? client.chain!.id,
                   details: { amount, currency, recipient },
-                  expectedFeeToken,
                   policy: feePayerPolicy,
                   transaction: {
                     ...transaction,
-                    ...(resolvedFeeToken ? { feeToken: resolvedFeeToken } : {}),
+                    feeToken: transaction.feeToken ?? defaults.tokens.pathUsd,
                   },
                 })
                 return signTransaction(client, sponsored as never)
               }
+              if (feePayerUrl && isFeePayerTx)
+                return FeePayer.fillHostedFeePayerTransaction({
+                  allowedFeeTokens,
+                  transaction,
+                  url: feePayerUrl,
+                })
               return serializedTransaction
             })()
 
             if (waitForConfirmation) {
-              await viem_call(client, {
-                ...transaction,
-                account: transaction.from,
-                calls: transaction.calls,
-                feePayerSignature: undefined,
-              } as never)
+              await viem_call(
+                client,
+                FeePayer.simulationTransaction(transaction, { feePayer: isFeePayerTx }),
+              )
               const receipt = await sendRawTransactionSync(client, {
                 serializedTransaction: serializedTransaction_final,
               })
@@ -461,12 +465,10 @@ export function charge<const parameters extends charge.Parameters>(
             // Optimistic path: simulate to catch obvious reverts, then broadcast
             // without waiting for on-chain confirmation. The returned receipt
             // assumes success — callers opt into this risk via waitForConfirmation: false.
-            await viem_call(client, {
-              ...transaction,
-              account: transaction.from,
-              calls: transaction.calls,
-              feePayerSignature: undefined,
-            } as never)
+            await viem_call(
+              client,
+              FeePayer.simulationTransaction(transaction, { feePayer: isFeePayerTx }),
+            )
             const reference = await sendRawTransaction(client, {
               serializedTransaction: serializedTransaction_final,
             })

package/src/tempo/server/Methods.ts

@@ -1,8 +1,53 @@
-import * as Ws_ from '../session/Ws.js'
+import { session as sessionLegacy_, settle as settleLegacy_ } from '../legacy/server/index.js'
+import {
+  charge as sessionCharge_,
+  session as session_,
+  settle as settle_,
+  settleBatch as settleBatch_,
+} from '../session/server/Session.js'
+import * as Ws_ from '../session/server/Ws.js'
 import { charge as charge_ } from './Charge.js'
-import { session as session_, settle as settle_ } from './Session.js'
 import { renew as renewSubscription_, subscription as subscription_ } from './Subscription.js'
 
+const sessionServer = Object.assign(session_, {
+  charge: sessionCharge_,
+  settle: settle_,
+  settleBatch: settleBatch_,
+})
+
+function createSessionLegacyMethod<
+  const parameters extends NonNullable<Parameters<typeof sessionLegacy_>[0]>,
+>(parameters?: parameters) {
+  return Object.assign(sessionLegacy_(parameters as never), { alias: 'sessionLegacy' as const })
+}
+
+const sessionLegacyServer = Object.assign(createSessionLegacyMethod, {
+  settle: settleLegacy_,
+  Ws: Ws_,
+})
+
+/** Creates a legacy contract-backed Tempo `session` server method. */
+export const sessionLegacy = sessionLegacyServer
+
+/** Settles a legacy contract-backed Tempo session channel. */
+export const settleLegacy = settleLegacy_
+
+function createChargeMethod<const parameters extends tempo.Parameters>(
+  parameters: parameters | undefined,
+) {
+  // `tempo()` accepts the intersection of charge/session parameters, then
+  // forwards only the fields each method understands. Keep the generic bridge
+  // out of the public control-flow body.
+  return tempo.charge(parameters as charge_.Parameters)
+}
+
+function createSessionMethod<const parameters extends tempo.Parameters>(
+  parameters: parameters | undefined,
+) {
+  // See `createChargeMethod()`: session receives the same shared parameter bag.
+  return sessionServer(parameters as session_.Parameters)
+}
+
 /**
  * Creates both Tempo `charge` and `session` methods from shared parameters.
  *
@@ -16,10 +61,7 @@ import { renew as renewSubscription_, subscription as subscription_ } from './Su
  * ```
  */
 export function tempo<const parameters extends tempo.Parameters>(parameters?: parameters) {
-  return [
-    tempo.charge(parameters as charge_.Parameters as never),
-    tempo.session(parameters as session_.Parameters as never),
-  ] as const
+  return [createChargeMethod(parameters), createSessionMethod(parameters)] as const
 }
 
 export namespace tempo {
@@ -27,14 +69,18 @@ export namespace tempo {
 
   /** Creates a Tempo `charge` method for one-time TIP-20 token transfers. */
   export const charge = charge_
-  /** Creates a Tempo `session` method for session-based TIP-20 token payments. */
-  export const session = session_
+  /** Creates a TIP-1034 Tempo `session` method for session-based TIP-20 token payments. */
+  export const session = sessionServer
+  /** @deprecated Use `tempo.session()` for the TIP-1034 session server method. */
+  export const sessionLegacy = sessionLegacyServer
   /** Creates a Tempo `subscription` method for recurring TIP-20 token payments. */
   export const subscription = subscription_
   /** Renews an overdue Tempo subscription outside of the HTTP request path. */
   export const renewSubscription = renewSubscription_
   /** One-shot settle: reads highest voucher from storage and submits on-chain. */
   export const settle = settle_
+  /** Batch-settle precompile-backed session channels. */
+  export const settleBatch = settleBatch_
   /** Experimental websocket helpers for Tempo sessions. */
   export const Ws = Ws_
 }

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

@@ -2,8 +2,8 @@ import type { Address, Hex } from 'viem'
 import { describe, expect, test } from 'vp/test'
 
 import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
-import type * as ChannelStore from '../session/ChannelStore.js'
-import { serve, toResponse } from '../session/Sse.js'
+import type * as ChannelStore from '../session/server/ChannelStore.js'
+import { serve, toResponse } from '../session/server/Sse.js'
 
 const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
 const challengeId = 'test-challenge-id'

package/src/tempo/server/index.ts

@@ -1,7 +1,8 @@
-export * as ChannelStore from '../session/ChannelStore.js'
-export * as Sse from '../session/Sse.js'
-export * as Ws from '../session/Ws.js'
+export * as ChannelStore from '../session/server/ChannelStore.js'
+export * as Sse from '../session/server/Sse.js'
+export * as Ws from '../session/server/Ws.js'
 export { charge } from './Charge.js'
-export { tempo } from './Methods.js'
-export { session, settle } from './Session.js'
+export { sessionLegacy, settleLegacy, tempo } from './Methods.js'
+export { session, settle, settleBatch } from '../session/server/Session.js'
+export type { SettlementSchedule } from '../session/server/Session.js'
 export { renew as renewSubscription, subscription } from './Subscription.js'