mppx 0.4.3 → 0.4.5

package/src/client/internal/Fetch.test-d.ts

@@ -47,9 +47,9 @@ describe('Fetch.from', () => {
 
 describe('Fetch.from.RequestInit', () => {
   test('behavior: has context property typed to method context', () => {
-    const method = charge()
+    const _method = charge()
 
-    type Methods = [typeof method]
+    type Methods = [typeof _method]
     type Init = Fetch.from.RequestInit<Methods>
 
     expectTypeOf<Init>().toHaveProperty('context')

package/src/client/internal/Fetch.test.ts

@@ -1,9 +1,10 @@
 import { Receipt } from 'mppx'
 import { tempo } from 'mppx/client'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
-import { createClient } from 'viem'
+import { createClient, defineChain } from 'viem'
 import { describe, expect, test, vi } from 'vitest'
 import * as Http from '~test/Http.js'
+import { rpcUrl } from '~test/tempo/prool.js'
 import { accounts, asset, chain, client, http } from '~test/tempo/viem.js'
 import * as Fetch from './Fetch.js'
 
@@ -233,6 +234,61 @@ describe('Fetch.from', () => {
     httpServer.close()
   })
 
+  test('behavior: fee payer with plain chain client (no Tempo serializers)', async () => {
+    const plainChain = defineChain({
+      id: chain.id,
+      name: chain.name,
+      nativeCurrency: chain.nativeCurrency,
+      rpcUrls: chain.rpcUrls,
+    })
+    const plainClient = createClient({
+      account: accounts[1],
+      chain: plainChain,
+      transport: http(rpcUrl),
+    })
+
+    const serverWithFeePayer = Mppx_server.create({
+      methods: [
+        tempo_server.charge({
+          feePayer: accounts[0],
+          getClient: () => client,
+        }),
+      ],
+      realm,
+      secretKey,
+    })
+
+    const fetch = Fetch.from({
+      methods: [
+        tempo.charge({
+          account: accounts[1],
+          getClient: () => plainClient,
+        }),
+      ],
+    })
+
+    const httpServer = await Http.createServer(async (req, res) => {
+      const result = await Mppx_server.toNodeListener(
+        serverWithFeePayer.charge({
+          amount: '1',
+          currency: asset,
+          expires: new Date(Date.now() + 60_000).toISOString(),
+          recipient: accounts[0].address,
+        }),
+      )(req, res)
+      if (result.status === 402) return
+      res.end('OK')
+    })
+
+    const response = await fetch(httpServer.url)
+    expect(response.status).toBe(200)
+
+    const receipt = Receipt.fromResponse(response)
+    expect(receipt.status).toBe('success')
+
+    httpServer.close()
+  })
+
   test('behavior: onChallenge can create credential', async () => {
     const onChallenge = vi.fn(async (_challenge, { createCredential }) =>
       createCredential({ account: accounts[1] }),

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

@@ -122,8 +122,8 @@ describe('Mppx type tests', () => {
       recipient: '0x02',
     }
 
-    const handler = mppx.compose([alphaMethod, opts])
-    type HandlerReturn = ReturnType<typeof handler>
+    const _handler = mppx.compose([alphaMethod, opts])
+    type HandlerReturn = ReturnType<typeof _handler>
 
     assertType<Promise<{ status: 402; challenge: Response } | { status: 200; withReceipt: any }>>(
       {} as Awaited<HandlerReturn> as any,

package/src/server/Mppx.ts

@@ -82,16 +82,14 @@ type EffectiveTransportOf<mi, defaultTransport extends Transport.AnyTransport> =
   : TransportOverrideOf<mi>
 
 /** True when exactly one method has the given intent (no name collision). */
-type IsUniqueIntent<methods extends readonly Method.AnyServer[], intent extends string> = Extract<
-  methods[number],
-  { intent: intent }
-> extends infer M
-  ? M extends M
-    ? [Exclude<Extract<methods[number], { intent: intent }>, M>] extends [never]
-      ? true
-      : false
+type IsUniqueIntent<methods extends readonly Method.AnyServer[], intent extends string> =
+  Extract<methods[number], { intent: intent }> extends infer M
+    ? M extends M
+      ? [Exclude<Extract<methods[number], { intent: intent }>, M>] extends [never]
+        ? true
+        : false
+      : never
     : never
-  : never
 
 /** Only includes shorthand intent keys when the intent is unique across methods. */
 type UniqueIntentHandlers<

package/src/tempo/client/ChannelOps.test.ts

@@ -7,6 +7,10 @@ import { deployEscrow, openChannel } from '~test/tempo/session.js'
 import { accounts, asset, chain, client, fundAccount, http } from '~test/tempo/viem.js'
 import type { Challenge } from '../../Challenge.js'
 import * as Credential from '../../Credential.js'
+import {
+  chainId as chainIdDefaults,
+  escrowContract as escrowContractDefaults,
+} from '../internal/defaults.js'
 import { verifyVoucher } from '../session/Voucher.js'
 import {
   createClosePayload,
@@ -17,7 +21,7 @@ import {
   tryRecoverChannel,
 } from './ChannelOps.js'
 
-const escrow42431 = '0x542831e3E4Ace07559b7C8787395f4Fb99F70787' as Address
+const escrow42431 = escrowContractDefaults[chainIdDefaults.testnet] as Address
 
 const localAccount = privateKeyToAccount(
   '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',

package/src/tempo/client/Session.test.ts

@@ -6,6 +6,7 @@ import { deployEscrow, openChannel } from '~test/tempo/session.js'
 import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'
 import * as Challenge from '../../Challenge.js'
 import * as Credential from '../../Credential.js'
+import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import type { SessionCredentialPayload } from '../session/Types.js'
 import { session } from './Session.js'
 
@@ -22,7 +23,7 @@ const pureClient = createClient({
   transport: http('http://127.0.0.1'),
 })
 
-const escrowAddress = '0x542831e3E4Ace07559b7C8787395f4Fb99F70787' as Address
+const escrowAddress = escrowContractDefaults[chainId.testnet] as Address
 const recipient = '0x2222222222222222222222222222222222222222' as Address
 const currency = '0x3333333333333333333333333333333333333333' as Address
 

package/src/tempo/internal/defaults.test.ts

@@ -53,7 +53,7 @@ describe('escrowContract', () => {
   })
 
   test('testnet escrow contract', () => {
-    expect(escrowContract[chainId.testnet]).toBe('0x542831e3E4Ace07559b7C8787395f4Fb99F70787')
+    expect(escrowContract[chainId.testnet]).toBe('0xe1c4d3dce17bc111181ddf716f75bae49e61a336')
   })
 })
 

package/src/tempo/internal/defaults.ts

@@ -32,7 +32,7 @@ export const decimals = 6
 /** Default payment-channel escrow contract addresses per chain. */
 export const escrowContract = {
   [chainId.mainnet]: '0x33b901018174DDabE4841042ab76ba85D4e24f25',
-  [chainId.testnet]: '0x542831e3E4Ace07559b7C8787395f4Fb99F70787',
+  [chainId.testnet]: '0xe1c4d3dce17bc111181ddf716f75bae49e61a336',
 } as const satisfies Record<ChainId, string>
 
 /** Default RPC URLs for each Tempo chain. */

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

@@ -18,6 +18,10 @@ import {
   InvalidSignatureError,
 } from '../../Errors.js'
 import * as Store from '../../Store.js'
+import {
+  chainId as chainIdDefaults,
+  escrowContract as escrowContractDefaults,
+} from '../internal/defaults.js'
 import type * as Methods from '../Methods.js'
 import * as ChannelStore from '../session/ChannelStore.js'
 import type { SessionReceipt } from '../session/Types.js'
@@ -1309,7 +1313,7 @@ describe('monotonicity and TOCTOU (unit tests)', () => {
       token: '0x0000000000000000000000000000000000000003' as Address,
       authorizedSigner: '0x0000000000000000000000000000000000000004' as Address,
       chainId: 42431,
-      escrowContract: '0x542831e3E4Ace07559b7C8787395f4Fb99F70787' as Address,
+      escrowContract: escrowContractDefaults[chainIdDefaults.testnet] as Address,
       deposit: 10000000n,
       settledOnChain: 0n,
       highestVoucherAmount: 5000000n,

package/src/tempo/server/Session.ts

@@ -723,14 +723,14 @@ async function handleVoucher(
     lastOnChainVerified.set(payload.channelId, Date.now())
   } else {
     cachedOnChain = {
+      finalized: channel.finalized,
+      closeRequestedAt: 0n,
       payer: channel.payer,
       payee: channel.payee,
       token: channel.token,
+      authorizedSigner: channel.authorizedSigner,
       deposit: channel.deposit,
       settled: channel.settledOnChain,
-      finalized: channel.finalized,
-      authorizedSigner: channel.authorizedSigner,
-      closeRequestedAt: 0n,
     }
   }
 

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

@@ -1,5 +1,6 @@
 import type { Address, Hex } from 'viem'
 import { describe, expect, test } from 'vitest'
+import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import type * as ChannelStore from '../session/ChannelStore.js'
 import { serve, toResponse } from '../session/Sse.js'
 
@@ -33,7 +34,7 @@ function seedChannel(
     token: '0x0000000000000000000000000000000000000003' as Address,
     authorizedSigner: '0x0000000000000000000000000000000000000004' as Address,
     chainId: 42431,
-    escrowContract: '0x542831e3E4Ace07559b7C8787395f4Fb99F70787' as Address,
+    escrowContract: escrowContractDefaults[chainId.testnet] as Address,
     deposit: balance,
     settledOnChain: 0n,
     highestVoucherAmount: balance,

package/src/tempo/server/internal/transport.test.ts

@@ -2,6 +2,7 @@ import { Challenge, Credential } from 'mppx'
 import type { Address, Hex } from 'viem'
 import { describe, expect, test } from 'vitest'
 import * as Store from '../../../Store.js'
+import { chainId, escrowContract as escrowContractDefaults } from '../../internal/defaults.js'
 import * as ChannelStore from '../../session/ChannelStore.js'
 import { sse } from './transport.js'
 
@@ -23,7 +24,7 @@ function seedChannel(
     token: '0x0000000000000000000000000000000000000003' as Address,
     authorizedSigner: '0x0000000000000000000000000000000000000004' as Address,
     chainId: 42431,
-    escrowContract: '0x542831e3E4Ace07559b7C8787395f4Fb99F70787' as Address,
+    escrowContract: escrowContractDefaults[chainId.testnet] as Address,
     deposit: balance,
     settledOnChain: 0n,
     highestVoucherAmount: balance,

package/src/tempo/session/Chain.ts

@@ -305,14 +305,14 @@ export async function broadcastOpenTransaction(parameters: {
     return {
       txHash,
       onChain: {
+        finalized: false,
+        closeRequestedAt: 0n,
         payer: transaction.from,
         payee,
         token,
         authorizedSigner,
         deposit,
         settled: 0n,
-        closeRequestedAt: 0n,
-        finalized: false,
       } as OnChainChannel,
     }
   }

package/src/tempo/session/ChannelStore.test.ts

@@ -1,6 +1,7 @@
 import type { Address, Hex } from 'viem'
 import { describe, expect, test } from 'vitest'
 import * as Store from '../../Store.js'
+import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import * as ChannelStore from './ChannelStore.js'
 
 const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
@@ -14,7 +15,7 @@ function makeChannel(overrides?: Partial<ChannelStore.State>): ChannelStore.Stat
     token: '0x0000000000000000000000000000000000000003' as Address,
     authorizedSigner: '0x0000000000000000000000000000000000000004' as Address,
     chainId: 42431,
-    escrowContract: '0x542831e3E4Ace07559b7C8787395f4Fb99F70787' as Address,
+    escrowContract: escrowContractDefaults[chainId.testnet] as Address,
     deposit: 10_000_000n,
     settledOnChain: 0n,
     highestVoucherAmount: 10_000_000n,

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

@@ -1,5 +1,6 @@
 import type { Address, Hex } from 'viem'
 import { describe, expect, test } from 'vitest'
+import { chainId, escrowContract as escrowContractDefaults } from '../internal/defaults.js'
 import type * as ChannelStore from './ChannelStore.js'
 import { formatNeedVoucherEvent, formatReceiptEvent, parseEvent, serve } from './Sse.js'
 import type { NeedVoucherEvent, SessionReceipt } from './Types.js'
@@ -218,7 +219,7 @@ describe('serve', () => {
       token: '0x0000000000000000000000000000000000000003' as Address,
       authorizedSigner: '0x0000000000000000000000000000000000000004' as Address,
       chainId: 42431,
-      escrowContract: '0x542831e3E4Ace07559b7C8787395f4Fb99F70787' as Address,
+      escrowContract: escrowContractDefaults[chainId.testnet] as Address,
       deposit: balance,
       settledOnChain: 0n,
       highestVoucherAmount: balance,

package/src/tempo/session/escrow.abi.ts

@@ -36,6 +36,16 @@ export const escrowAbi = [
       },
     ],
     outputs: [
+      {
+        name: 'finalized',
+        type: 'bool',
+        internalType: 'bool',
+      },
+      {
+        name: 'closeRequestedAt',
+        type: 'uint64',
+        internalType: 'uint64',
+      },
       {
         name: 'payer',
         type: 'address',
@@ -66,16 +76,6 @@ export const escrowAbi = [
         type: 'uint128',
         internalType: 'uint128',
       },
-      {
-        name: 'closeRequestedAt',
-        type: 'uint64',
-        internalType: 'uint64',
-      },
-      {
-        name: 'finalized',
-        type: 'bool',
-        internalType: 'bool',
-      },
     ],
     stateMutability: 'view',
   },
@@ -213,6 +213,16 @@ export const escrowAbi = [
         type: 'tuple',
         internalType: 'struct TempoStreamChannel.Channel',
         components: [
+          {
+            name: 'finalized',
+            type: 'bool',
+            internalType: 'bool',
+          },
+          {
+            name: 'closeRequestedAt',
+            type: 'uint64',
+            internalType: 'uint64',
+          },
           {
             name: 'payer',
             type: 'address',
@@ -243,16 +253,6 @@ export const escrowAbi = [
             type: 'uint128',
             internalType: 'uint128',
           },
-          {
-            name: 'closeRequestedAt',
-            type: 'uint64',
-            internalType: 'uint64',
-          },
-          {
-            name: 'finalized',
-            type: 'bool',
-            internalType: 'bool',
-          },
         ],
       },
     ],
@@ -274,6 +274,16 @@ export const escrowAbi = [
         type: 'tuple[]',
         internalType: 'struct TempoStreamChannel.Channel[]',
         components: [
+          {
+            name: 'finalized',
+            type: 'bool',
+            internalType: 'bool',
+          },
+          {
+            name: 'closeRequestedAt',
+            type: 'uint64',
+            internalType: 'uint64',
+          },
           {
             name: 'payer',
             type: 'address',
@@ -304,16 +314,6 @@ export const escrowAbi = [
             type: 'uint128',
             internalType: 'uint128',
           },
-          {
-            name: 'closeRequestedAt',
-            type: 'uint64',
-            internalType: 'uint64',
-          },
-          {
-            name: 'finalized',
-            type: 'bool',
-            internalType: 'bool',
-          },
         ],
       },
     ],

package/src/viem/Client.test.ts

@@ -1,3 +1,8 @@
+import { createClient, custom, defineChain, type Hex } from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
+import { signTransaction } from 'viem/actions'
+import { tempoLocalnet } from 'viem/chains'
+import { Transaction } from 'viem/tempo'
 import { describe, expect, test } from 'vitest'
 import * as Client from './Client.js'
 
@@ -56,3 +61,194 @@ describe('getResolver', () => {
     )
   })
 })
+
+// ---------------------------------------------------------------------------
+// Serializer injection – ensures user-provided clients without Tempo chain
+// config get Tempo serializers merged in by getResolver.
+// ---------------------------------------------------------------------------
+
+const testAccount = privateKeyToAccount(
+  '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+)
+
+const chainIdHex = `0x${tempoLocalnet.id.toString(16)}`
+const mockTransport = custom({
+  async request({ method }: { method: string }) {
+    if (method === 'eth_chainId') return chainIdHex
+    throw new Error(`Unexpected RPC call: ${method}`)
+  },
+})
+
+const tempoClient = createClient({
+  account: testAccount,
+  chain: tempoLocalnet,
+  transport: mockTransport,
+})
+
+function createPlainClient() {
+  const plainChain = defineChain({
+    id: tempoLocalnet.id,
+    name: 'Tempo (no serializer)',
+    nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+    rpcUrls: { default: { http: ['http://127.0.0.1:1'] } },
+  })
+  return createClient({
+    account: testAccount,
+    chain: plainChain,
+    transport: mockTransport,
+  })
+}
+
+const feePayer_prepared = {
+  chainId: tempoLocalnet.id,
+  calls: [
+    {
+      to: '0x20c0000000000000000000000000000000000001' as const,
+      data: '0x1234' as Hex,
+    },
+  ],
+  feePayer: true as const,
+  feeToken: '0x20c0000000000000000000000000000000000001' as const,
+  gas: 100_000n,
+  maxFeePerGas: 1_000_000_000n,
+  maxPriorityFeePerGas: 1_000_000n,
+  nonce: 0,
+  nonceKey: 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+  validBefore: Math.floor(Date.now() / 1000) + 25,
+}
+
+describe('feePayer transaction serialization', () => {
+  test('behavior: signTransaction with Tempo chain and feePayer: true', async () => {
+    const serialized = await signTransaction(tempoClient, {
+      account: testAccount,
+      ...feePayer_prepared,
+    } as never)
+    expect(serialized).toMatch(/^0x7[68]/)
+  })
+
+  test('behavior: signTransaction with gasPrice + type legacy', async () => {
+    const serialized = await signTransaction(tempoClient, {
+      account: testAccount,
+      ...feePayer_prepared,
+      gasPrice: 1_000_000_000n,
+      type: 'legacy' as const,
+    } as never)
+    expect(serialized).toMatch(/^0x7[68]/)
+  })
+
+  test('behavior: fee-payer co-sign with Account object', async () => {
+    const feePayerAccount = privateKeyToAccount(
+      '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d',
+    )
+    const serialized = await signTransaction(tempoClient, {
+      account: feePayerAccount,
+      ...feePayer_prepared,
+      feePayer: feePayerAccount,
+    } as never)
+    expect(serialized).toMatch(/^0x7[68]/)
+  })
+
+  test('behavior: deserialized + re-signed tx (server charge flow)', async () => {
+    const feePayerAccount = privateKeyToAccount(
+      '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d',
+    )
+    const clientSigned = await signTransaction(tempoClient, {
+      account: testAccount,
+      ...feePayer_prepared,
+    } as never)
+    const deserialized = Transaction.deserialize(
+      clientSigned as Transaction.TransactionSerializedTempo,
+    )
+    const serverSigned = await signTransaction(tempoClient, {
+      ...deserialized,
+      account: feePayerAccount,
+      feePayer: feePayerAccount,
+      feeToken: '0x20c0000000000000000000000000000000000001' as const,
+    } as never)
+    expect(serverSigned).toMatch(/^0x7[68]/)
+  })
+})
+
+describe('getResolver serializer injection', () => {
+  test('behavior: injects Tempo serializer onto plain clients', async () => {
+    const plainClient = createPlainClient()
+    expect(plainClient.chain?.serializers?.transaction).toBeUndefined()
+
+    const resolver = Client.getResolver({
+      chain: tempoLocalnet,
+      getClient: () => plainClient,
+    })
+    const resolvedClient = await resolver({})
+
+    expect(resolvedClient.chain?.serializers?.transaction).toBeDefined()
+    const serialized = await signTransaction(resolvedClient, {
+      account: testAccount,
+      ...feePayer_prepared,
+    } as never)
+    expect(serialized).toMatch(/^0x7[68]/)
+  })
+
+  test('behavior: fixes legacy type + feePayer + maxFeePerGas', async () => {
+    const resolver = Client.getResolver({
+      chain: tempoLocalnet,
+      getClient: () => createPlainClient(),
+    })
+    const resolvedClient = await resolver({})
+
+    const serialized = await signTransaction(resolvedClient, {
+      account: testAccount,
+      ...feePayer_prepared,
+      type: 'legacy' as const,
+    } as never)
+    expect(serialized).toMatch(/^0x7[68]/)
+  })
+
+  test('behavior: preserves existing serializers', async () => {
+    const resolver = Client.getResolver({
+      chain: tempoLocalnet,
+      getClient: () => tempoClient,
+    })
+    const resolvedClient = await resolver({})
+
+    expect(resolvedClient.chain?.serializers?.transaction).toBe(
+      tempoClient.chain?.serializers?.transaction,
+    )
+  })
+
+  test('behavior: passes through getClient when chain has no serializers', async () => {
+    const getClient = () => createPlainClient()
+    const resolver = Client.getResolver({
+      chain: undefined,
+      getClient,
+    })
+
+    expect(resolver).toBe(getClient)
+  })
+
+  test('behavior: does not mutate the original client', async () => {
+    const plainClient = createPlainClient()
+    const originalChain = plainClient.chain
+
+    const resolver = Client.getResolver({
+      chain: tempoLocalnet,
+      getClient: () => plainClient,
+    })
+    const resolvedClient = await resolver({})
+
+    expect(plainClient.chain).toBe(originalChain)
+    expect(resolvedClient).not.toBe(plainClient)
+    expect(resolvedClient.chain?.serializers?.transaction).toBeDefined()
+  })
+
+  test('error: plain client without resolver throws on feePayer tx', async () => {
+    const plainClient = createPlainClient()
+
+    await expect(
+      signTransaction(plainClient, {
+        account: testAccount,
+        ...feePayer_prepared,
+        type: 'legacy' as const,
+      } as never),
+    ).rejects.toThrow()
+  })
+})

package/src/viem/Client.ts

@@ -11,7 +11,29 @@ export function getResolver(
 ): (parameters: { chainId?: number | undefined }) => MaybePromise<Client> {
   const { chain, getClient, rpcUrl } = parameters
 
-  if (getClient) return getClient
+  if (getClient) {
+    // When a default chain with serializers is provided (e.g. Tempo chain config),
+    // ensure user-provided clients inherit those serializers. Without this, clients
+    // created without the Tempo chain config will use the default viem serializer,
+    // causing errors like "maxFeePerGas is not a valid Legacy Transaction attribute".
+    if (!chain?.serializers) return getClient
+    return async (params) => {
+      const client = await getClient(params)
+      if (client.chain?.serializers?.transaction) return client
+      return Object.assign({}, client, {
+        chain: {
+          ...chain,
+          ...client.chain,
+          formatters: client.chain?.formatters ?? chain.formatters,
+          prepareTransactionRequest:
+            client.chain?.prepareTransactionRequest ?? chain.prepareTransactionRequest,
+          serializers: client.chain?.serializers?.transaction
+            ? client.chain.serializers
+            : chain.serializers,
+        } as typeof client.chain,
+      })
+    }
+  }
 
   return ({ chainId }: { chainId?: number | undefined }) => {
     if (!rpcUrl) throw new Error('No `rpcUrl` provided.')