mppx 0.3.8 → 0.3.11

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

@@ -1,4 +1,5 @@
 import { type Address, encodeFunctionData, erc20Abi, type Hex } from 'viem'
+import { waitForTransactionReceipt } from 'viem/actions'
 import { Addresses, Transaction } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vitest'
 import {
@@ -346,6 +347,38 @@ describe('on-chain', () => {
       expect(result.txHash).toBeUndefined()
       expect(result.onChain.deposit).toBe(deposit)
     })
+
+    test('waitForConfirmation: false returns derived on-chain state', async () => {
+      const salt = nextSalt()
+      const deposit = 10_000_000n
+
+      const { channelId, serializedTransaction } = await signOpenChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const result = await broadcastOpenTransaction({
+        client,
+        serializedTransaction,
+        escrowContract,
+        channelId,
+        recipient,
+        currency,
+        waitForConfirmation: false,
+      })
+
+      expect(result.txHash).toBeDefined()
+      expect(result.onChain.payer.toLowerCase()).toBe(payer.address.toLowerCase())
+      expect(result.onChain.payee.toLowerCase()).toBe(recipient.toLowerCase())
+      expect(result.onChain.token.toLowerCase()).toBe(currency.toLowerCase())
+      expect(result.onChain.deposit).toBe(deposit)
+      expect(result.onChain.settled).toBe(0n)
+      expect(result.onChain.finalized).toBe(false)
+    })
   })
 
   describe('broadcastTopUpTransaction', () => {
@@ -380,6 +413,7 @@ describe('on-chain', () => {
           serializedTransaction,
           escrowContract,
           channelId: wrongChannelId,
+          currency: asset,
           declaredDeposit: topUpAmount,
           previousDeposit: deposit,
         }),
@@ -414,6 +448,7 @@ describe('on-chain', () => {
           serializedTransaction,
           escrowContract,
           channelId,
+          currency: asset,
           declaredDeposit: 9_999_999n,
           previousDeposit: deposit,
         }),
@@ -447,6 +482,7 @@ describe('on-chain', () => {
         serializedTransaction,
         escrowContract,
         channelId,
+        currency: asset,
         declaredDeposit: topUpAmount,
         previousDeposit: deposit,
       })
@@ -501,6 +537,7 @@ describe('on-chain', () => {
           serializedTransaction: tampered,
           escrowContract,
           channelId,
+          currency: asset,
           declaredDeposit: topUpAmount,
           previousDeposit: deposit,
           feePayer: accounts[0],
@@ -508,4 +545,157 @@ describe('on-chain', () => {
       ).rejects.toThrow('fee-sponsored topUp transaction contains an unauthorized call')
     })
   })
+
+  describe('settleOnChain', () => {
+    test('settles a channel', async () => {
+      const salt = nextSalt()
+      const deposit = 10_000_000n
+      const settleAmount = 5_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const signature = await signVoucher(
+        client,
+        payer,
+        { channelId, cumulativeAmount: settleAmount },
+        escrowContract,
+        chain.id,
+      )
+
+      const txHash = await settleOnChain(client, escrowContract, {
+        channelId,
+        cumulativeAmount: settleAmount,
+        signature,
+      })
+
+      expect(txHash).toBeDefined()
+      await waitForTransactionReceipt(client, { hash: txHash })
+      const channel = await getOnChainChannel(client, escrowContract, channelId)
+      expect(channel.settled).toBe(settleAmount)
+      expect(channel.finalized).toBe(false)
+    })
+
+    test('settles a channel with fee payer', async () => {
+      const salt = nextSalt()
+      const deposit = 10_000_000n
+      const settleAmount = 5_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const signature = await signVoucher(
+        client,
+        payer,
+        { channelId, cumulativeAmount: settleAmount },
+        escrowContract,
+        chain.id,
+      )
+
+      const txHash = await settleOnChain(
+        client,
+        escrowContract,
+        {
+          channelId,
+          cumulativeAmount: settleAmount,
+          signature,
+        },
+        accounts[0],
+      )
+
+      expect(txHash).toBeDefined()
+      await waitForTransactionReceipt(client, { hash: txHash })
+      const channel = await getOnChainChannel(client, escrowContract, channelId)
+      expect(channel.settled).toBe(settleAmount)
+      expect(channel.finalized).toBe(false)
+    })
+  })
+
+  describe('closeOnChain', () => {
+    test('closes a channel', async () => {
+      const salt = nextSalt()
+      const deposit = 10_000_000n
+      const closeAmount = 5_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const signature = await signVoucher(
+        client,
+        payer,
+        { channelId, cumulativeAmount: closeAmount },
+        escrowContract,
+        chain.id,
+      )
+
+      const txHash = await closeOnChain(client, escrowContract, {
+        channelId,
+        cumulativeAmount: closeAmount,
+        signature,
+      })
+
+      expect(txHash).toBeDefined()
+      await waitForTransactionReceipt(client, { hash: txHash })
+      const channel = await getOnChainChannel(client, escrowContract, channelId)
+      expect(channel.finalized).toBe(true)
+    })
+
+    test('closes a channel with fee payer', async () => {
+      const salt = nextSalt()
+      const deposit = 10_000_000n
+      const closeAmount = 5_000_000n
+
+      const { channelId } = await openChannel({
+        escrow: escrowContract,
+        payer,
+        payee: recipient,
+        token: currency,
+        deposit,
+        salt,
+      })
+
+      const signature = await signVoucher(
+        client,
+        payer,
+        { channelId, cumulativeAmount: closeAmount },
+        escrowContract,
+        chain.id,
+      )
+
+      const txHash = await closeOnChain(
+        client,
+        escrowContract,
+        {
+          channelId,
+          cumulativeAmount: closeAmount,
+          signature,
+        },
+        undefined,
+        accounts[0],
+      )
+
+      expect(txHash).toBeDefined()
+      await waitForTransactionReceipt(client, { hash: txHash })
+      const channel = await getOnChainChannel(client, escrowContract, channelId)
+      expect(channel.finalized).toBe(true)
+    })
+  })
 }) // end describe('on-chain')

package/src/tempo/session/Chain.ts

@@ -3,15 +3,26 @@ import {
   type Address,
   type Client,
   decodeFunctionData,
+  encodeFunctionData,
   getAbiItem,
+  getAddress,
   type Hex,
   isAddressEqual,
   type ReadContractReturnType,
   toFunctionSelector,
 } from 'viem'
-import { readContract, sendRawTransactionSync, signTransaction, writeContract } from 'viem/actions'
+import {
+  prepareTransactionRequest,
+  readContract,
+  sendRawTransaction,
+  sendRawTransactionSync,
+  signTransaction,
+  writeContract,
+} from 'viem/actions'
 import { Transaction } from 'viem/tempo'
 import { BadRequestError, ChannelClosedError, VerificationFailedError } from '../../Errors.js'
+import * as defaults from '../internal/defaults.js'
+import { simulateTransaction } from '../internal/simulate.js'
 import { escrowAbi } from './escrow.abi.js'
 import type { SignedVoucher } from './Types.js'
 
@@ -75,15 +86,21 @@ export async function settleOnChain(
   client: Client,
   escrowContract: Address,
   voucher: SignedVoucher,
+  feePayer?: Account | undefined,
 ): Promise<Hex> {
   assertUint128(voucher.cumulativeAmount)
+  const args = [voucher.channelId, voucher.cumulativeAmount, voucher.signature] as const
+  if (feePayer) {
+    const data = encodeFunctionData({ abi: escrowAbi, functionName: 'settle', args })
+    return sendFeePayerTx(client, feePayer, escrowContract, data, 'settle')
+  }
   return writeContract(client, {
     account: client.account!,
     chain: client.chain,
     address: escrowContract,
     abi: escrowAbi,
     functionName: 'settle',
-    args: [voucher.channelId, voucher.cumulativeAmount, voucher.signature],
+    args,
   })
 }
 
@@ -95,6 +112,7 @@ export async function closeOnChain(
   escrowContract: Address,
   voucher: SignedVoucher,
   account?: Account,
+  feePayer?: Account | undefined,
 ): Promise<Hex> {
   assertUint128(voucher.cumulativeAmount)
   const resolved = account ?? client.account
@@ -102,14 +120,67 @@ export async function closeOnChain(
     throw new Error(
       'Cannot close channel: no account available. Provide an `account` in the session config or a `getClient` that returns an account-bearing client.',
     )
+  const args = [voucher.channelId, voucher.cumulativeAmount, voucher.signature] as const
+  if (feePayer) {
+    const data = encodeFunctionData({ abi: escrowAbi, functionName: 'close', args })
+    return sendFeePayerTx(client, feePayer, escrowContract, data, 'close')
+  }
   return writeContract(client, {
     account: resolved,
     chain: client.chain,
     address: escrowContract,
     abi: escrowAbi,
     functionName: 'close',
-    args: [voucher.channelId, voucher.cumulativeAmount, voucher.signature],
+    args,
+  })
+}
+
+/**
+ * Build, sign, and broadcast a fee-sponsored type-0x76 transaction.
+ *
+ * Follows the same signTransaction + sendRawTransactionSync pattern used
+ * by broadcastOpenTransaction / broadcastTopUpTransaction, but originates
+ * the transaction server-side (estimating gas and fees first).
+ */
+async function sendFeePayerTx(
+  client: Client,
+  feePayer: Account,
+  to: Address,
+  data: Hex,
+  label: string,
+): Promise<Hex> {
+  // Resolve the fee token for this chain so the tx pays gas in the correct
+  // token.  `feePayer: true` tells the prepare hook to use expiring nonces but
+  // does NOT set feeToken automatically, so we must provide it explicitly.
+  const chainId = client.chain?.id
+  const feeToken = chainId
+    ? defaults.currency[chainId as keyof typeof defaults.currency]
+    : undefined
+
+  const prepared = await prepareTransactionRequest(client, {
+    account: feePayer,
+    calls: [{ to, data }],
+    feePayer: true,
+    ...(feeToken ? { feeToken } : {}),
+  } as never)
+
+  const serialized = (await signTransaction(client, {
+    ...prepared,
+    account: feePayer,
+    feePayer,
+  } as never)) as Hex
+
+  const receipt = await sendRawTransactionSync(client, {
+    serializedTransaction: serialized as Transaction.TransactionSerializedTempo,
   })
+
+  if (receipt.status !== 'success') {
+    throw new VerificationFailedError({
+      reason: `${label} transaction reverted: ${receipt.transactionHash}`,
+    })
+  }
+
+  return receipt.transactionHash
 }
 
 const escrowOpenSelector = /*#__PURE__*/ toFunctionSelector(
@@ -137,6 +208,8 @@ export async function broadcastOpenTransaction(parameters: {
   recipient: Address
   currency: Address
   feePayer?: Account | undefined
+  /** When false, simulates instead of waiting for confirmation and returns derived on-chain state. @default true */
+  waitForConfirmation?: boolean | undefined
 }): Promise<BroadcastResult> {
   const {
     client,
@@ -146,6 +219,7 @@ export async function broadcastOpenTransaction(parameters: {
     recipient,
     currency,
     feePayer,
+    waitForConfirmation = true,
   } = parameters
 
   const transaction = Transaction.deserialize(
@@ -184,7 +258,13 @@ export async function broadcastOpenTransaction(parameters: {
   }
 
   const { args: openArgs } = decodeFunctionData({ abi: escrowAbi, data: openCall.data! })
-  const [payee, token] = openArgs as readonly [Address, Address, ...unknown[]]
+  const [payee, token, deposit, , authorizedSigner] = openArgs as readonly [
+    Address,
+    Address,
+    bigint,
+    Hex,
+    Address,
+  ]
 
   if (!isAddressEqual(payee, recipient)) {
     throw new VerificationFailedError({
@@ -208,6 +288,28 @@ export async function broadcastOpenTransaction(parameters: {
     return serializedTransaction
   })()
 
+  if (!waitForConfirmation) {
+    const from = getAddress(transaction.from as Address)
+    await simulateTransaction(client, { ...transaction, from, calls })
+    const txHash = await sendRawTransaction(client, {
+      serializedTransaction: serializedTransaction_final as Transaction.TransactionSerializedTempo,
+    })
+
+    return {
+      txHash,
+      onChain: {
+        payer: from,
+        payee,
+        token,
+        authorizedSigner,
+        deposit,
+        settled: 0n,
+        closeRequestedAt: 0n,
+        finalized: false,
+      } as OnChainChannel,
+    }
+  }
+
   let txHash: Hex | undefined
   try {
     const receipt = await sendRawTransactionSync(client, {
@@ -239,6 +341,7 @@ export async function broadcastTopUpTransaction(parameters: {
   serializedTransaction: Hex
   escrowContract: Address
   channelId: Hex
+  currency: Address
   declaredDeposit: bigint
   previousDeposit: bigint
   feePayer?: Account | undefined
@@ -248,6 +351,7 @@ export async function broadcastTopUpTransaction(parameters: {
     serializedTransaction,
     escrowContract,
     channelId,
+    currency,
     declaredDeposit,
     previousDeposit,
     feePayer,
@@ -279,7 +383,7 @@ export async function broadcastTopUpTransaction(parameters: {
       const selector = call.data.slice(0, 10)
       const isEscrowTopUp =
         isAddressEqual(call.to, escrowContract) && selector === escrowTopUpSelector
-      const isTokenApprove = selector === erc20ApproveSelector
+      const isTokenApprove = isAddressEqual(call.to, currency) && selector === erc20ApproveSelector
       if (!isEscrowTopUp && !isTokenApprove) {
         throw new BadRequestError({
           reason: 'fee-sponsored topUp transaction contains an unauthorized call',