mppx 0.6.31 → 0.8.0

package/src/tempo/server/Charge.ts

@@ -2,7 +2,6 @@ import * as SignatureEnvelope from 'ox/tempo/SignatureEnvelope'
 import {
   decodeFunctionData,
   formatUnits,
-  hashTypedData,
   keccak256,
   parseEventLogs,
   type TransactionReceipt,
@@ -292,11 +291,15 @@ export function charge<const parameters extends charge.Parameters>(
           }
 
           const valid = await verifyTypedData(client, {
+            // Bind verification to the claimed payer (`source.address`): the
+            // signer may be the payer itself or an access key authorized for it.
             address: source.address,
-            domain: Proof.domain(resolvedChainId),
-            types: Proof.types,
-            primaryType: 'Proof',
-            message: Proof.message(challenge.id, challenge.realm),
+            ...Proof.typedData({
+              account: source.address,
+              chainId: resolvedChainId,
+              challengeId: challenge.id,
+              realm: challenge.realm,
+            }),
             signature: payload.signature as `0x${string}`,
           })
           if (!valid) {
@@ -400,35 +403,67 @@ 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)
+
+            // Request for the pre-broadcast simulation; for sponsored payments
+            // this is overwritten below with the co-signed shape.
+            let simulationRequest: Record<string, unknown> = FeePayer.simulationTransaction(
+              transaction,
+              { feePayer: isFeePayerTx },
+            )
 
             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,
                   },
                 })
+                // `account` is the sender (eth_call `from`); `feePayer` is the
+                // sponsor that pays gas.
+                simulationRequest = {
+                  ...sponsored,
+                  account: transaction.from,
+                  feePayer: feePayerAccount.address,
+                  feePayerSignature: undefined,
+                  signature: undefined,
+                }
                 return signTransaction(client, sponsored as never)
               }
+              if (feePayerUrl && isFeePayerTx) {
+                const hosted = await FeePayer.fillHostedFeePayerTransaction({
+                  allowedFeeTokens,
+                  transaction,
+                  url: feePayerUrl,
+                })
+                // Simulate the co-signed envelope (concrete fee payer + chosen
+                // fee token), mirroring the local-sponsor path.
+                simulationRequest = {
+                  ...transaction,
+                  account: transaction.from,
+                  feePayer: hosted.feePayer,
+                  feePayerSignature: undefined,
+                  feeToken: hosted.feeToken,
+                  signature: undefined,
+                }
+                return hosted.serializedTransaction
+              }
               return serializedTransaction
             })()
 
+            // Pre-broadcast simulation: fail closed before broadcast so the
+            // sponsor never pays gas for a transaction that would revert.
+            await viem_call(client, simulationRequest as never)
+
             if (waitForConfirmation) {
-              await viem_call(client, {
-                ...transaction,
-                account: transaction.from,
-                calls: transaction.calls,
-                feePayerSignature: undefined,
-              } as never)
               const receipt = await sendRawTransactionSync(client, {
                 serializedTransaction: serializedTransaction_final,
               })
@@ -458,15 +493,9 @@ export function charge<const parameters extends charge.Parameters>(
               return toReceipt(receipt)
             }
 
-            // 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)
+            // Optimistic path: broadcast without waiting for confirmation
+            // (simulation above already ran). The returned receipt assumes
+            // success — callers opt in via waitForConfirmation: false.
             const reference = await sendRawTransaction(client, {
               serializedTransaction: serializedTransaction_final,
             })
@@ -1005,12 +1034,7 @@ function recoverAuthorizedProofSigner(parameters: {
 
   try {
     const envelope = SignatureEnvelope.from(signature)
-    const proofHash = hashTypedData({
-      domain: Proof.domain(chainId),
-      types: Proof.types,
-      primaryType: 'Proof',
-      message: Proof.message(challengeId, realm),
-    })
+    const proofHash = Proof.hash({ account: sourceAddress, chainId, challengeId, realm })
 
     if (envelope.type === 'keychain') {
       if (!TempoAddress.isEqual(envelope.userAddress, sourceAddress)) return null

package/src/tempo/server/Methods.ts

@@ -1,25 +1,67 @@
-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.
+ * Creates the common Tempo `charge` and `session` methods from shared parameters.
  *
  * @example
  * ```ts
  * import { Mppx, tempo } from 'mppx/server'
  *
  * const mppx = Mppx.create({
- *   methods: [tempo({ currency: '0x...', recipient: '0x...' })],
+ *   methods: [tempo.common({ currency: '0x...', recipient: '0x...' })],
  * })
  * ```
  */
 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,20 @@ 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 the common Tempo `charge` and `session` methods from shared parameters. */
+  export const common = tempo
+  /** 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'