mppx 0.8.11 → 0.8.13

package/src/tempo/session/precompile/Chain.ts

@@ -1001,8 +1001,11 @@ async function sendPrecompileTransaction(
   label: string,
   options?: ChannelTransactionOptions,
 ): Promise<Hex> {
-  if (options?.feePayer) {
-    const account = options.account ?? client.account
+  const account = options?.account ?? client.account
+  const selfSponsored =
+    account && options?.feePayer && isAddressEqual(account.address, options.feePayer.address)
+
+  if (options?.feePayer && !selfSponsored) {
     if (!account) throw new Error(`Cannot ${label} precompile channel: no account available.`)
     const feeToken =
       options.feeToken ??
@@ -1033,10 +1036,20 @@ async function sendPrecompileTransaction(
     return receipt.transactionHash
   }
 
+  const feeToken =
+    options?.feeToken ??
+    (selfSponsored
+      ? await resolveFeeToken({
+          account: account.address,
+          candidateTokens: options?.candidateFeeTokens,
+          client,
+        })
+      : undefined)
+
   return sendPrecompileContractCall(client, {
-    account: options?.account,
+    account,
     to,
     data,
-    feeToken: options?.feeToken,
+    feeToken,
   })
 }

package/src/tempo/session/server/CredentialVerification.ts

@@ -30,7 +30,7 @@ import {
 import * as Voucher from '../precompile/Voucher.js'
 import * as ChannelStore from './ChannelStore.js'
 import { getChallengePaymentFields } from './RequestState.js'
-import { assertSettlementSender, getClientAccount } from './Settlement.js'
+import { assertSettlementSender, getClientAccount, type OnSessionSettlement } from './Settlement.js'
 
 /** Returns the effective voucher signer for a TIP-1034 descriptor. */
 export function authorizedSigner(descriptor: Channel.ChannelDescriptor): Address {
@@ -344,6 +344,8 @@ export type VerifyCredentialPayloadParameters = {
   lastOnChainVerified: Map<Hex, number>
   /** Minimum allowed voucher delta in raw units. */
   minVoucherDelta: bigint
+  /** Callback invoked after an on-chain settlement or close transaction is confirmed. */
+  onSessionSettlement?: OnSessionSettlement | undefined
   /** Discriminated session credential payload to verify. */
   payload: SessionCredentialPayload
   /** Server-side channel store. */
@@ -747,6 +749,21 @@ async function handleCloseCredential(
       signature: payload.signature,
     }),
   )
+  if (parameters.onSessionSettlement && txHash) {
+    try {
+      await parameters.onSessionSettlement(
+        Object.freeze({
+          txHash,
+          channelId,
+          trigger: 'close' as const,
+          amount: settledToPayee,
+          delta: settledToPayee - state.settled,
+        }),
+      )
+    } catch {
+      // Errors are isolated — observers cannot break the settlement flow.
+    }
+  }
   return createSessionReceipt({
     challengeId: challenge.id,
     channelId,

package/src/tempo/session/server/MeteredStream.ts

@@ -12,8 +12,14 @@ export type SessionController = {
    * The reservation blocks until sufficient voucher headroom exists, but the
    * charge is only committed once a chunk is actually emitted. If the stream
    * ends or aborts before that emission, the reservation is dropped.
+   *
+   * Pass an explicit raw-unit `amount` for request-aware or otherwise dynamic
+   * pricing. When omitted, the session challenge's configured tick cost is
+   * used.
    */
-  charge(): Promise<void>
+  charge(amount?: bigint): Promise<void>
+  /** Aborted when the client closes or requests the final session receipt. */
+  signal: AbortSignal
 }
 
 /** Async stream source accepted by paid session transports. */
@@ -49,7 +55,7 @@ export async function* meterIterable(options: MeteredStreamOptions): AsyncGenera
   let reservedAmount = 0n
   let reservedUnits = 0
 
-  const charge = async () => {
+  const charge = async (amount = options.tickCost) => {
     if (prepaidUnits > 0) {
       prepaidUnits -= 1
       return
@@ -58,19 +64,20 @@ export async function* meterIterable(options: MeteredStreamOptions): AsyncGenera
     await reserveChargeOrWait({
       store: options.store,
       channelId: options.channelId,
-      amount: options.tickCost,
+      amount,
       reservedAmount,
       emit: options.emitNeedVoucher,
       formatNeedVoucher: options.formatNeedVoucher,
       pollIntervalMs: options.pollIntervalMs,
       signal: options.signal,
     })
-    reservedAmount += options.tickCost
+    reservedAmount += amount
     reservedUnits += 1
   }
 
+  const signal = options.signal ?? new AbortController().signal
   const iterable =
-    typeof options.generate === 'function' ? options.generate({ charge }) : options.generate
+    typeof options.generate === 'function' ? options.generate({ charge, signal }) : options.generate
 
   for await (const value of iterable) {
     if (options.signal?.aborted) break

package/src/tempo/session/server/RequestState.test.ts

@@ -316,7 +316,11 @@ describe('SessionSnapshotHints', () => {
       escrowContract,
       expiringNonceHash: descriptor.expiringNonceHash,
       finalized: false,
-      highestVoucher: null,
+      highestVoucher: {
+        channelId,
+        cumulativeAmount: 500n,
+        signature: `0x${'44'.repeat(64)}`,
+      },
       highestVoucherAmount: 500n,
       operator: descriptor.operator,
       payee: descriptor.payee,
@@ -451,6 +455,11 @@ describe('SessionSnapshotHints', () => {
         deposit: '1000',
         descriptor,
         escrow: escrowContract,
+        highestVoucher: {
+          channelId,
+          cumulativeAmount: '500',
+          signature: `0x${'44'.repeat(64)}`,
+        },
         requiredCumulative: '350',
         settled: '100',
         spent: '300',
@@ -458,7 +467,7 @@ describe('SessionSnapshotHints', () => {
       })
     })
 
-    test('raises accepted cumulative when next request exceeds current authorization', async () => {
+    test('keeps accepted cumulative at the signed voucher when the next request needs more', async () => {
       const snapshot = await resolveSessionSnapshot({
         amount: 300n,
         channelId,
@@ -466,7 +475,34 @@ describe('SessionSnapshotHints', () => {
       })
 
       expect(snapshot?.requiredCumulative).toBe('600')
-      expect(snapshot?.acceptedCumulative).toBe('600')
+      expect(snapshot?.acceptedCumulative).toBe('500')
+      expect(snapshot?.highestVoucher?.cumulativeAmount).toBe('500')
+    })
+
+    test('omits reusable channel hints without a matching signed highest voucher', async () => {
+      await expect(
+        resolveSessionSnapshot({
+          amount: 50n,
+          channelId,
+          store: store(channel({ highestVoucher: null })),
+        }),
+      ).resolves.toBeUndefined()
+
+      await expect(
+        resolveSessionSnapshot({
+          amount: 50n,
+          channelId,
+          store: store(
+            channel({
+              highestVoucher: {
+                channelId,
+                cumulativeAmount: 499n,
+                signature: `0x${'44'.repeat(64)}`,
+              },
+            }),
+          ),
+        }),
+      ).resolves.toBeUndefined()
     })
 
     test('omits reusable channel hints when payment fields do not match', async () => {

package/src/tempo/session/server/RequestState.ts

@@ -80,7 +80,11 @@ export type ResolveSessionChannelIdParameters = {
   store: ChannelStore.ChannelStore
 }
 
-/** Application hook for mapping request identity to an existing session channel. */
+/**
+ * Application-owned lookup from authenticated identity and payment scope to an existing session
+ * channel. MPPx does not derive a storage key or scan the channel store; the returned channel ID is
+ * loaded and independently validated before its snapshot is advertised.
+ */
 export type ResolveSessionChannelId = (
   parameters: ResolveSessionChannelIdParameters,
 ) => Promise<string | null | undefined> | string | null | undefined
@@ -139,14 +143,12 @@ export async function resolveSessionSnapshot(
   const channel = await store.getChannel(ChannelStore.normalizeChannelId(channelId))
   if (!channel || !ChannelStore.isPrecompileState(channel)) return undefined
   if (channel.finalized) return undefined
+  if (!channel.highestVoucher) return undefined
+  if (channel.highestVoucher.cumulativeAmount !== channel.highestVoucherAmount) return undefined
   if (expected && !matchesSnapshotPaymentFields(channel, expected)) return undefined
   const requiredCumulative = channel.spent + amount
-  const acceptedCumulative =
-    channel.highestVoucherAmount > requiredCumulative
-      ? channel.highestVoucherAmount
-      : requiredCumulative
   return {
-    acceptedCumulative: acceptedCumulative.toString(),
+    acceptedCumulative: channel.highestVoucherAmount.toString(),
     chainId: channel.chainId,
     channelId: channel.channelId,
     closeRequestedAt:
@@ -154,6 +156,11 @@ export async function resolveSessionSnapshot(
     deposit: channel.deposit.toString(),
     descriptor: channel.descriptor,
     escrow: channel.escrowContract,
+    highestVoucher: {
+      channelId: channel.highestVoucher.channelId,
+      cumulativeAmount: channel.highestVoucher.cumulativeAmount.toString(),
+      signature: channel.highestVoucher.signature,
+    },
     requiredCumulative: requiredCumulative.toString(),
     settled: channel.settledOnChain.toString(),
     spent: channel.spent.toString(),