mppx 0.6.12 → 0.6.14

package/src/tempo/server/Session.ts

@@ -168,9 +168,10 @@ export function session<const parameters extends session.Parameters>(
 
       // Extract feePayer.
       const resolvedFeePayer = (() => {
+        if (request.feePayer === false) return credential ? false : undefined
         const account = typeof request.feePayer === 'object' ? request.feePayer : feePayer
-        const requested = request.feePayer !== false && (account ?? feePayer ?? feePayerUrl)
-        if (credential) return account
+        const requested = account ?? feePayer ?? feePayerUrl
+        if (credential) return account ?? (feePayerUrl ? true : undefined)
         if (requested) return true
         return undefined
       })()
@@ -196,7 +197,17 @@ export function session<const parameters extends session.Parameters>(
       const methodDetails = resolvedRequest.methodDetails as SessionMethodDetails
       const client = await getClient({ chainId: methodDetails.chainId })
 
-      const resolvedFeePayer = methodDetails.feePayer === true ? feePayer : undefined
+      const requestAllowsFeePayer =
+        request.feePayer !== false &&
+        (request.feePayer === undefined ||
+          request.feePayer === true ||
+          typeof request.feePayer === 'object')
+      const resolvedFeePayer =
+        methodDetails.feePayer === true && requestAllowsFeePayer
+          ? typeof request.feePayer === 'object'
+            ? request.feePayer
+            : feePayer
+          : undefined
       const minVoucherDelta = parseUnits(parameters.minVoucherDelta ?? '0', decimals)
       const effectiveMinVoucherDelta = methodDetails.minVoucherDelta
         ? BigInt(methodDetails.minVoucherDelta)
@@ -268,7 +279,6 @@ export function session<const parameters extends session.Parameters>(
       // This keeps equal-voucher replays bounded by the voucher's remaining
       // balance instead of serving repeated responses for free.
       if (
-        !parameters.sse &&
         envelope &&
         isSessionContentRequest(envelope.capturedRequest) &&
         (payload.action === 'open' || payload.action === 'voucher')
@@ -283,6 +293,7 @@ export function session<const parameters extends session.Parameters>(
           spent: charged.spent.toString(),
           units: charged.units,
         }
+        if (parameters.sse) sessionReceipt = Transport.markPrepaidSessionTick(sessionReceipt)
       }
 
       return sessionReceipt
@@ -454,6 +465,9 @@ export async function charge(
     throw new ChannelClosedError({ reason: 'channel not found' })
   }
   if (!result.ok) {
+    if (result.channel.finalized) throw new ChannelClosedError({ reason: 'channel is finalized' })
+    if (result.channel.closeRequestedAt !== 0n)
+      throw new ChannelClosedError({ reason: 'channel has a pending close request' })
     const available = result.channel.highestVoucherAmount - result.channel.spent
     throw new InsufficientBalanceError({
       reason: `requested ${amount}, available ${available}`,
@@ -622,6 +636,38 @@ async function handleOpen(
   const currency = challenge.request.currency as Address
   const amount = challenge.request.amount ? BigInt(challenge.request.amount as string) : undefined
 
+  const validateOpenVoucher = async (onChain: OnChainChannel) => {
+    validateOnChainChannel(onChain, recipient, currency, amount)
+
+    const authorizedSigner =
+      onChain.authorizedSigner === '0x0000000000000000000000000000000000000000'
+        ? onChain.payer
+        : onChain.authorizedSigner
+
+    if (voucher.cumulativeAmount > onChain.deposit) {
+      throw new AmountExceedsDepositError({ reason: 'voucher amount exceeds on-chain deposit' })
+    }
+
+    if (voucher.cumulativeAmount <= onChain.settled) {
+      throw new VerificationFailedError({
+        reason: 'voucher cumulativeAmount is below on-chain settled amount',
+      })
+    }
+
+    const isValid = await verifyVoucher(
+      methodDetails.escrowContract,
+      methodDetails.chainId,
+      voucher,
+      authorizedSigner,
+    )
+
+    if (!isValid) {
+      throw new InvalidSignatureError({ reason: 'invalid voucher signature' })
+    }
+
+    return authorizedSigner
+  }
+
   const { onChain, txHash } = await broadcastOpenTransaction({
     client,
     serializedTransaction: payload.transaction,
@@ -632,36 +678,13 @@ async function handleOpen(
     challengeExpires: challenge.expires,
     feePayerPolicy,
     feePayer,
+    beforeBroadcast: async (pendingOnChain) => {
+      await validateOpenVoucher(pendingOnChain)
+    },
     waitForConfirmation,
   })
 
-  validateOnChainChannel(onChain, recipient, currency, amount)
-
-  const authorizedSigner =
-    onChain.authorizedSigner === '0x0000000000000000000000000000000000000000'
-      ? onChain.payer
-      : onChain.authorizedSigner
-
-  if (voucher.cumulativeAmount > onChain.deposit) {
-    throw new AmountExceedsDepositError({ reason: 'voucher amount exceeds on-chain deposit' })
-  }
-
-  if (voucher.cumulativeAmount <= onChain.settled) {
-    throw new VerificationFailedError({
-      reason: 'voucher cumulativeAmount is below on-chain settled amount',
-    })
-  }
-
-  const isValid = await verifyVoucher(
-    methodDetails.escrowContract,
-    methodDetails.chainId,
-    voucher,
-    authorizedSigner,
-  )
-
-  if (!isValid) {
-    throw new InvalidSignatureError({ reason: 'invalid voucher signature' })
-  }
+  const authorizedSigner = await validateOpenVoucher(onChain)
 
   const updated = await store.updateChannel(channelId, (existing) => {
     if (existing) {
@@ -914,16 +937,45 @@ async function handleClose(
     throw new InvalidSignatureError({ reason: 'invalid voucher signature' })
   }
 
-  assertSettlementSender({
-    operation: 'close',
-    channelId: payload.channelId,
-    payee: onChain.payee,
-    sender: account?.address ?? client.account?.address,
+  const pendingCloseStartedAt = BigInt(Math.floor(Date.now() / 1000) || 1)
+  const previousCloseRequestedAt = channel.closeRequestedAt
+  let pendingCloseMarked = false
+  await store.updateChannel(channelId, (current) => {
+    if (!current) return null
+    if (current.finalized) throw new ChannelClosedError({ reason: 'channel is already finalized' })
+    if (current.closeRequestedAt !== 0n)
+      throw new ChannelClosedError({ reason: 'channel has a pending close request' })
+    if (voucher.cumulativeAmount < current.spent) {
+      throw new VerificationFailedError({
+        reason: `close voucher amount must be >= ${current.spent} (spent)`,
+      })
+    }
+    pendingCloseMarked = true
+    return { ...current, closeRequestedAt: pendingCloseStartedAt }
   })
 
-  const txHash = await closeOnChain(client, methodDetails.escrowContract, voucher, {
-    ...(feePayer && account ? { feePayer, account } : { account }),
-  })
+  let txHash: Hex | undefined
+  try {
+    assertSettlementSender({
+      operation: 'close',
+      channelId: payload.channelId,
+      payee: onChain.payee,
+      sender: account?.address ?? client.account?.address,
+    })
+
+    txHash = await closeOnChain(client, methodDetails.escrowContract, voucher, {
+      ...(feePayer && account ? { feePayer, account } : { account }),
+    })
+  } catch (error) {
+    if (pendingCloseMarked) {
+      await store.updateChannel(channelId, (current) =>
+        current && current.closeRequestedAt === pendingCloseStartedAt
+          ? { ...current, closeRequestedAt: previousCloseRequestedAt }
+          : current,
+      )
+    }
+    throw error
+  }
 
   const updated = await store.updateChannel(channelId, (current) => {
     if (!current) return null