mppx 0.6.31 → 0.8.0

package/src/cli/plugins/tempo.ts

@@ -11,10 +11,15 @@ import { createClient, http } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
 
 import { normalizeHeaders } from '../../client/internal/Fetch.js'
+import * as Constants from '../../Constants.js'
 import * as Credential from '../../Credential.js'
 import { tempo as tempoMethods } from '../../tempo/client/index.js'
-import type { SessionCredentialPayload } from '../../tempo/session/Types.js'
-import { signVoucher } from '../../tempo/session/Voucher.js'
+import { tip20ChannelEscrow } from '../../tempo/session/precompile/Protocol.js'
+import type {
+  ChannelDescriptor,
+  SessionCredentialPayload,
+} from '../../tempo/session/precompile/Protocol.js'
+import { signVoucher } from '../../tempo/session/precompile/Voucher.js'
 import { createDefaultStore, createKeychain, resolveAccountName } from '../account.js'
 import {
   fetchTokenInfo,
@@ -40,6 +45,7 @@ export function tempo() {
           chainId: number
           action?: 'voucher' | 'close'
         }): Promise<string>
+        descriptor?: ChannelDescriptor | undefined
         source: string
       }
     | undefined
@@ -176,7 +182,7 @@ export function tempo() {
         account,
         getClient: () => client!,
         ...(autoSwap !== undefined ? { autoSwap } : {}),
-        deposit: (() => {
+        maxDeposit: (() => {
           if (challenge.intent !== 'session') return undefined
           const suggestedDeposit = (challenge.request as Record<string, unknown>)
             .suggestedDeposit as string | undefined
@@ -209,6 +215,7 @@ export function tempo() {
 
       // Store session support for use in lifecycle hooks
       _session = {
+        descriptor: undefined,
         async signVoucher({
           channelId,
           cumulativeAmount,
@@ -216,11 +223,14 @@ export function tempo() {
           chainId,
           action = 'voucher',
         }) {
+          const descriptor = _session?.descriptor
+          if (!descriptor) throw new Error('session descriptor not available')
           return Credential.serialize({
             challenge,
             payload: {
               action,
               channelId,
+              descriptor,
               cumulativeAmount: cumulativeAmount.toString(),
               signature: await signVoucher(
                 client!,
@@ -260,16 +270,19 @@ export function tempo() {
       const parsed = Credential.deserialize<SessionCredentialPayload>(credential)
       const challengeRequest = challenge.request as Record<string, unknown>
       const sessionMd = challengeRequest.methodDetails as
-        | { escrowContract?: string; chainId?: number }
+        | { escrow?: string; escrowContract?: string; chainId?: number }
         | undefined
       const channelId = parsed.payload.channelId
-      const escrowContract = sessionMd?.escrowContract as Address | undefined
+      const escrowContract = (sessionMd?.escrowContract ??
+        sessionMd?.escrow ??
+        tip20ChannelEscrow) as Address
       const chainId = sessionMd?.chainId ?? 0
       const tickCost = BigInt(challengeRequest.amount as string)
       let cumulativeAmount =
         'cumulativeAmount' in parsed.payload && parsed.payload.cumulativeAmount
           ? BigInt(parsed.payload.cumulativeAmount)
           : 0n
+      if ('descriptor' in parsed.payload) _session.descriptor = parsed.payload.descriptor
 
       if (verbose >= 1) {
         if (parsed.payload.action === 'open') {
@@ -302,7 +315,7 @@ export function tempo() {
       }
 
       // Print receipt from initial response headers
-      const receiptHeader = credentialResponse.headers.get('Payment-Receipt')
+      const receiptHeader = credentialResponse.headers.get(Constants.Headers.paymentReceipt)
       if (receiptHeader) {
         try {
           const receiptJson = JSON.parse(Base64.toString(receiptHeader)) as Record<string, unknown>
@@ -556,7 +569,7 @@ async function handleSseStream(
           })
           await globalThis.fetch(opts.fetchUrl, {
             method: 'POST',
-            headers: { Authorization: voucherCred },
+            headers: { [Constants.Headers.authorization]: voucherCred },
           })
         } catch (e) {
           opts.info(pc.dim(pc.yellow(` [voucher failed: ${e instanceof Error ? e.message : e}]`)))
@@ -669,7 +682,7 @@ async function closeChannel(opts: {
   if (closeRes.ok) {
     deleteChannelState(opts.channelId)
     if (opts.verbose >= 1) {
-      const closeReceiptHeader = closeRes.headers.get('Payment-Receipt')
+      const closeReceiptHeader = closeRes.headers.get(Constants.Headers.paymentReceipt)
       let closeTxHash: string | undefined
       if (closeReceiptHeader) {
         try {

package/src/cli/utils.test.ts

@@ -1,7 +1,7 @@
 import { tempo as tempoMainnet, tempoModerato } from 'viem/tempo/chains'
 import { afterEach, describe, expect, test } from 'vp/test'
 
-import { networkRpcUrls, resolveChain, resolveRpcUrl } from './utils.js'
+import { networkRpcUrls, resolveChain, resolveFundingNetwork, resolveRpcUrl } from './utils.js'
 
 describe('resolveRpcUrl', () => {
   afterEach(() => {
@@ -52,6 +52,30 @@ describe('resolveRpcUrl', () => {
   })
 })
 
+describe('resolveFundingNetwork', () => {
+  afterEach(() => {
+    delete process.env.MPPX_RPC_URL
+    delete process.env.RPC_URL
+  })
+
+  test('defaults faucet funding to testnet', () => {
+    expect(resolveFundingNetwork()).toBe('testnet')
+  })
+
+  test('keeps explicit network selection', () => {
+    expect(resolveFundingNetwork({ network: 'mainnet' })).toBe('mainnet')
+  })
+
+  test('does not override explicit rpc url', () => {
+    expect(resolveFundingNetwork({ rpcUrl: 'https://explicit.example.com' })).toBeUndefined()
+  })
+
+  test('does not override env rpc urls', () => {
+    process.env.MPPX_RPC_URL = 'https://env.example.com'
+    expect(resolveFundingNetwork()).toBeUndefined()
+  })
+})
+
 describe('resolveChain', () => {
   afterEach(() => {
     delete process.env.MPPX_RPC_URL

package/src/cli/utils.ts

@@ -242,6 +242,16 @@ export function resolveRpcUrl(
   )
 }
 
+/** Select the default network for faucet funding without overriding explicit RPC configuration. */
+export function resolveFundingNetwork(
+  options: { network?: Network | undefined; rpcUrl?: string | undefined } = {},
+): Network | undefined {
+  if (options.network) return options.network
+  if (options.rpcUrl) return undefined
+  if (process.env.MPPX_RPC_URL?.trim() || process.env.RPC_URL?.trim()) return undefined
+  return 'testnet'
+}
+
 export async function resolveChain(
   opts: { network?: Network | undefined; rpcUrl?: string | undefined } = {},
 ): Promise<Chain> {

package/src/client/Methods.ts

@@ -1,5 +1,8 @@
 export { evm } from '../evm/client/index.js'
 export { stripe } from '../stripe/client/index.js'
 export { subscription } from '../tempo/client/Subscription.js'
-export { tempo } from '../tempo/client/index.js'
-export { session } from '../tempo/client/Session.js'
+export { session, tempo } from '../tempo/client/index.js'
+export { session as sessionMethod } from '../tempo/session/client/Session.js'
+export { sessionManager } from '../tempo/session/client/SessionManager.js'
+export { session as sessionLegacy } from '../tempo/legacy/client/index.js'
+export { sessionManager as sessionLegacyManager } from '../tempo/legacy/client/index.js'

package/src/client/Mppx.test-d.ts

@@ -1,4 +1,4 @@
-import type { Account } from 'viem'
+import type { Account, Address } from 'viem'
 import { describe, expectTypeOf, test } from 'vp/test'
 
 import * as Challenge from '../Challenge.js'
@@ -9,11 +9,22 @@ import { tempo } from '../tempo/client/Methods.js'
 import type * as AutoSwap from '../tempo/internal/auto-swap.js'
 import * as Methods from '../tempo/Methods.js'
 import * as z from '../zod.js'
+import type { ResolveAccount } from './index.js'
 import * as Fetch from './internal/Fetch.js'
+import { session, sessionManager, sessionMethod } from './Methods.js'
 import * as Mppx from './Mppx.js'
 import * as Transport from './Transport.js'
 
 describe('Mppx', () => {
+  test('exports low-level session method and explicit managed session helper', () => {
+    expectTypeOf(session({ account: {} as Account })).toMatchTypeOf<Method.AnyClient>()
+    expectTypeOf(session.manager({ account: {} as Account })).toHaveProperty('fetch')
+    expectTypeOf(sessionManager({ account: {} as Account })).toHaveProperty('fetch')
+    expectTypeOf(sessionMethod({ account: {} as Account })).toMatchTypeOf<Method.AnyClient>()
+    expectTypeOf(tempo.session({ account: {} as Account })).toMatchTypeOf<Method.AnyClient>()
+    expectTypeOf(tempo.session.manager({ account: {} as Account })).toHaveProperty('fetch')
+  })
+
   test('has methods array', () => {
     const method = charge({
       account: {} as Account,
@@ -68,6 +79,25 @@ describe('create.Config', () => {
     expectTypeOf(mppx.fetch).toBeFunction()
   })
 
+  test('tempo common accepts one resolveAccount hook for charge and session', () => {
+    const resolveAccount: ResolveAccount = (info) => {
+      expectTypeOf(info).toHaveProperty('account')
+      expectTypeOf(info.chainId).toEqualTypeOf<number>()
+      if (info.operation.kind === 'executeCalls') {
+        expectTypeOf(info.operation.calls).toMatchTypeOf<
+          readonly { data: `0x${string}`; to: Address }[] | undefined
+        >()
+      }
+      if (info.operation.kind === 'authorizePaymentChannel') {
+        expectTypeOf(info.operation.authority).toEqualTypeOf<Address | undefined>()
+      }
+      return info.account
+    }
+
+    const methods = tempo({ account: {} as Account, resolveAccount })
+    expectTypeOf(methods).toMatchTypeOf<readonly Method.AnyClient[]>()
+  })
+
   test('orderChallenges receives supported challenge candidates', () => {
     const mppx = Mppx.create({
       methods: [tempo({ account: {} as Account })],

package/src/client/Mppx.test.ts

@@ -7,7 +7,7 @@ import * as Http from '~test/Http.js'
 import { accounts, asset, client } from '~test/tempo/viem.js'
 
 const realm = 'api.example.com'
-const secretKey = 'test-secret-key'
+const secretKey = 'test-secret-key-test-secret-key-32'
 
 afterEach(() => {
   Mppx.restore()
@@ -74,6 +74,81 @@ describe('Mppx.create', () => {
 })
 
 describe('createCredential', () => {
+  function sessionChallenge(id: string, sessionProtocol?: string) {
+    return {
+      expires: new Date(Date.now() + 60_000).toISOString(),
+      id,
+      intent: 'session',
+      method: 'tempo',
+      realm,
+      request: {
+        amount: '100',
+        currency: asset,
+        unitType: 'request',
+        methodDetails: {
+          chainId: 1,
+          escrowContract: '0x0000000000000000000000000000000000000001',
+          ...(sessionProtocol !== undefined ? { sessionProtocol } : {}),
+        },
+      },
+    } as const
+  }
+
+  function paymentRequiredResponse(...challenges: Challenge.Challenge[]) {
+    return new Response(null, {
+      status: 402,
+      headers: { 'WWW-Authenticate': challenges.map(Challenge.serialize).join(', ') },
+    })
+  }
+
+  function taggedSessionMethod(tag: string, canHandleChallenge: Method.CanHandleChallengeFn) {
+    return Method.toClient(Methods.session, {
+      canHandleChallenge,
+      async createCredential({ challenge }) {
+        return Credential.serialize({ challenge, payload: { tag } })
+      },
+    })
+  }
+
+  test('behavior: routes duplicate tempo/session client methods by sessionProtocol', async () => {
+    const tip1034 = taggedSessionMethod(
+      'v2',
+      ({ challenge }) =>
+        (challenge.request.methodDetails as { sessionProtocol?: string } | undefined)
+          ?.sessionProtocol === 'v2',
+    )
+    const legacy = taggedSessionMethod('v1', ({ challenge }) => {
+      const sessionProtocol = (
+        challenge.request.methodDetails as { sessionProtocol?: string } | undefined
+      )?.sessionProtocol
+      return sessionProtocol === undefined || sessionProtocol === 'v1'
+    })
+    const mppx = Mppx.create({ polyfill: false, methods: [tip1034, legacy] })
+
+    const [newCredential, legacyCredential, oldCredential] = await Promise.all([
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('new', 'v2'))),
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('v1', 'v1'))),
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('old'))),
+    ])
+    expect(Credential.deserialize(newCredential).payload).toEqual({ tag: 'v2' })
+    expect(Credential.deserialize(legacyCredential).payload).toEqual({ tag: 'v1' })
+    expect(Credential.deserialize(oldCredential).payload).toEqual({ tag: 'v1' })
+  })
+
+  test('behavior: rejects unknown tempo/session sessionProtocol', async () => {
+    const method = taggedSessionMethod(
+      'v2',
+      ({ challenge }) =>
+        (challenge.request.methodDetails as { sessionProtocol?: string } | undefined)
+          ?.sessionProtocol === 'v2',
+    )
+    const mppx = Mppx.create({ polyfill: false, methods: [method] })
+
+    await expect(
+      mppx.createCredential(paymentRequiredResponse(sessionChallenge('unknown', 'future'))),
+    ).rejects.toThrow('No method found for challenges: tempo.session')
+  })
+
   test('behavior: routes to correct method based on challenge', async () => {
     const mppx = Mppx.create({
       polyfill: false,

package/src/client/Mppx.ts

@@ -187,8 +187,8 @@ export function create<
       options?: createCredential.Options<FlattenMethods<methods>>,
     ) {
       const challenges = transport.getChallenges
-        ? transport.getChallenges(response as never)
-        : [transport.getChallenge(response as never)]
+        ? await transport.getChallenges(response as never)
+        : [await transport.getChallenge(response as never)]
       const preferences = resolveChallengePreferences(acceptPayment.entries, options?.acceptPayment)
 
       let challenge: Challenge.Challenge | undefined