mppx 0.8.6 → 0.8.8

package/src/cli/validate/payment.ts

@@ -1,34 +1,49 @@
-import { createClient, http } from 'viem'
+import * as childProcess from 'node:child_process'
+
+import { type Address, type Chain, createClient, erc20Abi, http } from 'viem'
 import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts'
-import { waitForTransactionReceipt } from 'viem/actions'
+import { readContract, waitForTransactionReceipt } from 'viem/actions'
+import * as viemChains from 'viem/chains'
 import { Actions } from 'viem/tempo'
 import { tempoModerato, tempo as tempoMainnetChain } from 'viem/tempo/chains'
 
 import * as Challenge from '../../Challenge.js'
 import * as Mppx from '../../client/Mppx.js'
 import * as Constants from '../../Constants.js'
+import type { AnyClient } from '../../Method.js'
 import * as Receipt from '../../Receipt.js'
 import { tempo as tempoMethods } from '../../tempo/client/index.js'
 import { chainId as tempoChainIds } from '../../tempo/internal/defaults.js'
 import { resolveAccount, resolveAccountName } from '../account.js'
-import { loadConfig, selectChallenge } from '../internal.js'
+import type { Config } from '../config.js'
+import { loadConfig, resolvePlugin } from '../internal.js'
 import { fetchTokenInfo, confirm, pc } from '../utils.js'
+import { buildUrl } from './discovery.js'
 import type { CheckResult, EndpointSpec } from './helpers.js'
-import { buildUrl, check, fail, fetchWithTimeout, formatBytes, skip, warn } from './helpers.js'
+import {
+  check,
+  fail,
+  fetchWithTimeout,
+  formatBytes,
+  isValidIntegerAmount,
+  skip,
+  warn,
+} from './helpers.js'
 
 async function provisionAndPayTestnet(
   challenge: Challenge.Challenge,
   verbose: boolean,
-): Promise<{ methods: import('../../Method.js').AnyClient[] } | undefined> {
+  silent?: boolean,
+): Promise<{ methods: AnyClient[] } | undefined> {
   try {
-    console.log(pc.dim('    Provisioning testnet wallet and funding via faucet...'))
+    if (!silent) console.log(pc.dim('    Provisioning testnet wallet and funding via faucet...'))
     const key = generatePrivateKey()
     const account = privateKeyToAccount(key)
 
     const client = createClient({ chain: tempoModerato, transport: http() })
     const hashes = await Actions.faucet.fund(client, { account })
     await Promise.all(hashes.map((hash) => waitForTransactionReceipt(client, { hash })))
-    console.log(pc.dim(`    Using wallet: ${account.address}`))
+    if (!silent) console.log(pc.dim(`    Using wallet: ${account.address}`))
 
     const methods = [...tempoMethods({ account })]
     return { methods }
@@ -54,17 +69,77 @@ async function resolveWalletAddress(): Promise<string | undefined> {
   }
 }
 
+// Auto-detect Stripe test key from the Stripe CLI if installed and logged in.
+function resolveStripeKey(verbose: boolean): string | undefined {
+  try {
+    const { execSync } = childProcess
+    const output = execSync('stripe config --list', { encoding: 'utf8', timeout: 5000 })
+    const match = output.match(/test_mode_api_key\s*=\s*'([^']+)'/)
+    if (match?.[1]) {
+      if (verbose) console.log(pc.dim('    Using Stripe test key from stripe CLI'))
+      return match[1]
+    }
+  } catch {}
+  return undefined
+}
+
+async function fetchEvmTokenInfo(
+  chain: Chain,
+  token: Address,
+  account: Address,
+): Promise<{ balance: bigint; symbol: string | undefined }> {
+  const client = createClient({ chain, transport: http() })
+  const [balance, symbol] = await Promise.all([
+    readContract(client, {
+      address: token,
+      abi: erc20Abi,
+      functionName: 'balanceOf',
+      args: [account],
+    }),
+    readContract(client, { address: token, abi: erc20Abi, functionName: 'symbol' }).catch(
+      () => undefined,
+    ),
+  ])
+  return { balance, symbol: symbol ?? undefined }
+}
+
+function resolveEvmChain(chainId: number): Chain | undefined {
+  const all = Object.values(viemChains) as Chain[]
+  return all.find((c) => c.id === chainId)
+}
+
+function formatAmount(amount: bigint, decimals: number): string {
+  return `$${(Number(amount) / 10 ** decimals).toFixed(2)}`
+}
+
+function methodSetupHint(challenge: Challenge.Challenge): string {
+  switch (challenge.method) {
+    case Constants.Methods.evm:
+      return 'no EVM payment plugin yet'
+    case 'solana':
+      return 'no Solana payment plugin yet'
+    default:
+      return `no plugin for ${challenge.method}/${challenge.intent}`
+  }
+}
 export async function validatePaymentFlow(
   baseUrl: string,
   endpoint: EndpointSpec,
   verbose: boolean,
-  options?: { body?: string | undefined; query?: string[] | undefined; yes?: boolean | undefined },
+  options: {
+    body?: string | undefined
+    query?: string[] | undefined
+    yes?: boolean | undefined
+    silent?: boolean | undefined
+    interactive?: boolean | undefined
+    onResults?: (results: CheckResult[]) => void
+  },
 ): Promise<CheckResult[]> {
   const results: CheckResult[] = []
-  const url = buildUrl(baseUrl, endpoint, options?.query)
+  const url = buildUrl(baseUrl, endpoint, options.query)
   const fetchHeaders: Record<string, string> = {}
   let fetchBody: string | undefined
-  if (options?.body) {
+  if (options.body) {
     fetchBody = options.body
     fetchHeaders['content-type'] = 'application/json'
   }
@@ -87,33 +162,40 @@ export async function validatePaymentFlow(
     return results
   }
 
-  // Parse challenge
-  let challenge: Challenge.Challenge
+  // Parse all challenges
+  let challenges: Challenge.Challenge[]
   try {
-    challenge = Challenge.fromResponse(challengeResponse)
+    challenges = Challenge.fromResponseList(challengeResponse)
   } catch (error) {
     results.push(fail('Payment: parse challenge', (error as Error).message))
     return results
   }
-
-  // Detect network
-  const request = challenge.request as Record<string, unknown>
-  const methodDetails = request.methodDetails as Record<string, unknown> | undefined
-  const isTestnet =
-    typeof methodDetails?.chainId === 'number' && methodDetails.chainId !== tempoChainIds.mainnet
+  if (challenges.length === 0) {
+    results.push(fail('Payment: parse challenge', 'No Payment challenges in response'))
+    return results
+  }
 
   // Testnet Tempo: always use ephemeral wallet (zero-setup, free money)
-  if (isTestnet && challenge.method === Constants.Methods.tempo) {
-    const provisioned = await provisionAndPayTestnet(challenge, verbose)
+  const tempoTestnetChallenge = challenges.find((ch) => {
+    if (ch.method !== Constants.Methods.tempo) return false
+    const req = ch.request as Record<string, unknown>
+    const md = req.methodDetails as Record<string, unknown> | undefined
+    return typeof md?.chainId === 'number' && md.chainId !== tempoChainIds.mainnet
+  })
+
+  if (tempoTestnetChallenge) {
+    const provisioned = await provisionAndPayTestnet(tempoTestnetChallenge, verbose, options.silent)
     if (provisioned) {
       const fakeResp = new Response(null, {
         status: 402,
-        headers: { [Constants.Headers.wwwAuthenticate]: Challenge.serialize(challenge) },
+        headers: {
+          [Constants.Headers.wwwAuthenticate]: Challenge.serialize(tempoTestnetChallenge),
+        },
       })
       try {
         const mppx = Mppx.create({ methods: provisioned.methods, polyfill: false })
         const cred = await mppx.createCredential(fakeResp)
-        results.push(check('Payment: credential created', 'ephemeral testnet wallet'))
+        results.push(check('Payment: submitted', 'ephemeral testnet wallet'))
         return await sendAndValidateResponse(
           results,
           url,
@@ -122,7 +204,7 @@ export async function validatePaymentFlow(
           fetchHeaders,
           fetchBody,
           verbose,
-          true,
+          tempoModerato,
         )
       } catch (error) {
         results.push(fail('Payment: create credential', (error as Error).message))
@@ -136,99 +218,191 @@ export async function validatePaymentFlow(
     }
   }
 
-  // Mainnet: use configured wallet
+  // Try each challenge method (skip testnet challenge already handled above)
   const loaded = await loadConfig().catch(() => undefined)
-  const selected = selectChallenge([challenge], loaded?.config)
+  const isInteractive = options.interactive
+  const stripeKey = process.env.MPPX_STRIPE_SECRET_KEY ?? resolveStripeKey(verbose)
+  const isStripeTestKey = stripeKey?.startsWith('sk_test_') || stripeKey?.startsWith('rk_test_')
+  const supportedPaymentMethods: Set<string> = new Set([
+    Constants.Methods.tempo,
+    Constants.Methods.evm,
+    Constants.Methods.stripe,
+  ])
+
+  for (const challenge of challenges) {
+    if (challenge === tempoTestnetChallenge) continue
+    if (!supportedPaymentMethods.has(challenge.method)) continue
+    if (!options.silent) console.log('')
+
+    const flushStart = results.length
+    const flush = () => {
+      if (options.onResults && results.length > flushStart)
+        options.onResults(results.slice(flushStart))
+    }
+    const tag = `Payment [${challenge.method}]`
 
-  if (!selected) {
-    results.push(
-      skip(
-        'Payment: no configured method',
-        `Need ${challenge.method}/${challenge.intent}`,
-        'Run "mppx account create" to create a local wallet for payment testing. The wallet is stored on your machine and only used by mppx.',
-      ),
-    )
-    return results
+    try {
+      switch (challenge.method) {
+        case Constants.Methods.tempo:
+        case Constants.Methods.evm:
+          await attemptCryptoPayment(challenge, tag, {
+            results,
+            url,
+            endpoint,
+            fetchHeaders,
+            fetchBody,
+            verbose,
+            loaded,
+            isInteractive,
+            options,
+          })
+          break
+        case Constants.Methods.stripe:
+          await attemptStripePayment(challenge, tag, {
+            results,
+            url,
+            endpoint,
+            fetchHeaders,
+            fetchBody,
+            verbose,
+            loaded,
+            isInteractive,
+            isStripeTestKey: isStripeTestKey ?? false,
+            stripeKey,
+            options,
+          })
+          break
+      }
+    } finally {
+      flush()
+    }
   }
 
-  const { plugin, method: directMethod } = selected
+  return results
+}
 
-  if (!plugin && !directMethod) {
-    results.push(skip('Payment: no plugin available', `${challenge.method}/${challenge.intent}`))
-    return results
+type PaymentContext = {
+  results: CheckResult[]
+  url: string
+  endpoint: EndpointSpec
+  fetchHeaders: Record<string, string>
+  fetchBody: string | undefined
+  verbose: boolean
+  loaded: { config: Config; path: string } | undefined
+  isInteractive: boolean | undefined
+  options: {
+    body?: string | undefined
+    query?: string[] | undefined
+    yes?: boolean | undefined
+    silent?: boolean | undefined
+    interactive?: boolean | undefined
+    onResults?: ((results: CheckResult[]) => void) | undefined
   }
+}
 
-  const requiredAmount = request.amount ? BigInt(request.amount as string) : undefined
-  // Display only -- defaults to 6 (standard for USDC/PathUSD tokens)
-  const decimals = (request.decimals as number | undefined) ?? 6
+async function attemptCryptoPayment(
+  challenge: Challenge.Challenge,
+  tag: string,
+  ctx: PaymentContext,
+): Promise<void> {
+  const { results, url, endpoint, fetchHeaders, fetchBody, verbose, loaded, options } = ctx
+  const request = challenge.request as Record<string, unknown>
+  const methodDetails = request.methodDetails as Record<string, unknown> | undefined
+  const requiredAmount = isValidIntegerAmount(request.amount)
+    ? BigInt(request.amount as string)
+    : undefined
+  const decimals =
+    (methodDetails?.decimals as number | undefined) ?? (request.decimals as number | undefined) ?? 6
   const currency = request.currency as string | undefined
 
-  // Pre-flight balance check
+  // Resolve wallet
   let walletAddress: string | undefined
-  if (challenge.method === Constants.Methods.tempo && requiredAmount && currency) {
+  try {
+    walletAddress = await resolveWalletAddress()
+  } catch {}
+  if (!walletAddress) {
+    results.push(skip(tag, 'no wallet configured. Run "mppx account create" to create one.'))
+    return
+  }
+
+  // Pre-flight balance check and chain resolution
+  let paymentChain: Chain | undefined
+  if (challenge.method === Constants.Methods.tempo) paymentChain = tempoMainnetChain
+  else if (challenge.method === Constants.Methods.evm) {
+    const chainId = methodDetails?.chainId as number | undefined
+    if (chainId) paymentChain = resolveEvmChain(chainId)
+  }
+
+  let tokenSymbol: string | undefined
+  if (requiredAmount && currency && paymentChain) {
     try {
-      walletAddress = await resolveWalletAddress()
-      if (walletAddress) {
+      let balance: bigint
+      if (challenge.method === Constants.Methods.tempo) {
         const client = createClient({ chain: tempoMainnetChain, transport: http() })
-        const tokenInfo = await fetchTokenInfo(
-          client,
-          currency as `0x${string}`,
-          walletAddress as `0x${string}`,
+        const info = await fetchTokenInfo(client, currency as Address, walletAddress as Address)
+        balance = info.balance
+        tokenSymbol = info.symbol
+      } else {
+        const info = await fetchEvmTokenInfo(
+          paymentChain,
+          currency as Address,
+          walletAddress as Address,
         )
-        const requiredDisplay = `$${(Number(requiredAmount) / 10 ** decimals).toFixed(2)}`
-        const balanceDisplay = `$${(Number(tokenInfo.balance) / 10 ** tokenInfo.decimals).toFixed(2)}`
-
-        if (tokenInfo.balance < requiredAmount) {
-          console.log(pc.dim(`    Wallet: ${walletAddress}`))
-          console.log(pc.dim(`    Balance: ${balanceDisplay} ${tokenInfo.symbol}`))
-          const hint = `Wallet ${walletAddress} has ${balanceDisplay} but endpoint requires ${requiredDisplay}. Fund this wallet to run payment tests, or use a testnet server.`
-          results.push(
-            skip(
-              'Payment: insufficient balance',
-              `Have ${balanceDisplay}, need ${requiredDisplay}`,
-              hint,
-            ),
-          )
-          return results
-        }
+        balance = info.balance
+        tokenSymbol = info.symbol
+      }
+      if (balance < requiredAmount) {
+        const requiredDisplay = formatAmount(requiredAmount, decimals)
+        const balanceDisplay = formatAmount(balance, decimals)
+        const symbol = tokenSymbol ?? 'tokens'
+        results.push(
+          skip(
+            tag,
+            `insufficient balance (have ${balanceDisplay}, need ${requiredDisplay} ${symbol} on ${paymentChain.name})`,
+            `Fund wallet ${walletAddress} with at least ${requiredDisplay} ${symbol} on ${paymentChain.name}.`,
+          ),
+        )
+        return
       }
     } catch (e) {
       if (verbose) console.log(pc.dim(`    Balance check skipped: ${(e as Error).message}`))
     }
   }
 
-  // Prompt before paying on mainnet (unless --yes or non-interactive)
-  const amountDisplay = requiredAmount
-    ? `$${(Number(requiredAmount) / 10 ** decimals).toFixed(2)}`
-    : 'unknown amount'
-  if (walletAddress) console.log(pc.dim(`    Using wallet: ${walletAddress}`))
-  const isInteractive = process.stdin.isTTY ?? false
-  if (!options?.yes && !isInteractive) {
-    results.push(
-      skip('Payment: skipped', 'Non-interactive mode. Use --yes to approve mainnet payments.'),
-    )
-    return results
-  }
-  if (!options?.yes) {
-    console.log('')
-    const ok = await confirm(
-      `  ${pc.yellow('Mainnet payment:')} Will transfer ${amountDisplay} to ${String(request.recipient).slice(0, 10)}... Continue?`,
-      false,
-    )
+  // Prompt
+  const amountDisplay = requiredAmount ? formatAmount(requiredAmount, decimals) : 'unknown amount'
+  const tokenDisplay = tokenSymbol ?? (currency?.length === 3 ? currency.toUpperCase() : '')
+  const chainName = paymentChain?.name
+  const paymentDesc = `${amountDisplay}${tokenDisplay ? ` ${tokenDisplay}` : ''}${chainName ? ` on ${chainName}` : ''}`
+
+  if (!options.silent) console.log(pc.dim(`    Attempting payment with wallet ${walletAddress}`))
+
+  if (paymentChain?.testnet) {
+    if (!options.silent) console.log(pc.dim(`    Auto-approved: ${paymentDesc} (testnet)`))
+  } else if (!options.yes && !ctx.isInteractive) {
+    results.push(skip(tag, 'non-interactive mode, use --yes to approve'))
+    return
+  } else if (!options.yes) {
+    const ok = await confirm(`  ${pc.yellow('Pay')} ${paymentDesc}. Continue?`, false)
     if (!ok) {
-      results.push(skip('Payment: skipped by user', 'mainnet payment declined'))
-      return results
+      results.push(skip(tag, 'declined'))
+      return
     }
   } else {
-    console.log(
-      pc.dim(`    Auto-approved: ${amountDisplay} to ${String(request.recipient).slice(0, 10)}...`),
-    )
+    if (!options.silent) console.log(pc.dim(`    Auto-approved: ${paymentDesc}`))
   }
 
-  // Setup plugin or use direct method
-  let methods: import('../../Method.js').AnyClient[]
-  let createCredentialFn: ((response: Response) => Promise<string>) | undefined
+  // Resolve plugin and pay
+  const resolved = resolvePlugin(challenge, loaded?.config)
+  const plugin = resolved.plugin
+  const directMethod = resolved.method
+  if (!plugin && !directMethod) {
+    results.push(skip(tag, methodSetupHint(challenge)))
+    return
+  }
 
+  let methods: AnyClient[]
+  let createCredentialFn: ((response: Response) => Promise<string>) | undefined
   if (plugin) {
     try {
       const pluginResult = await plugin.setup({
@@ -239,74 +413,169 @@ export async function validatePaymentFlow(
       methods = pluginResult.methods
       createCredentialFn = pluginResult.createCredential
     } catch (error) {
-      const msg = (error as Error).message
-      if (msg.includes('No account found') || msg.includes('not found')) {
-        results.push(skip('Payment: no wallet configured', msg))
-      } else {
-        results.push(fail('Payment: wallet setup', msg))
-      }
-      return results
+      results.push(skip(tag, (error as Error).message))
+      return
     }
   } else {
     methods = [directMethod!]
   }
 
-  // Create credential
-  let credential: string
+  const credential = await createAndSend(challenge, methods, createCredentialFn, tag, results)
+  if (!credential) return
+
+  plugin?.prepareCredentialRequest?.({ challenge, credential, headers: fetchHeaders })
+  await sendAndValidateResponse(
+    results,
+    url,
+    endpoint,
+    credential,
+    fetchHeaders,
+    fetchBody,
+    verbose,
+    paymentChain,
+  )
+}
+
+async function attemptStripePayment(
+  challenge: Challenge.Challenge,
+  tag: string,
+  ctx: PaymentContext & { isStripeTestKey: boolean; stripeKey?: string | undefined },
+): Promise<void> {
+  const {
+    results,
+    url,
+    endpoint,
+    fetchHeaders,
+    fetchBody,
+    verbose,
+    loaded,
+    options,
+    isStripeTestKey,
+    stripeKey,
+  } = ctx
+  const request = challenge.request as Record<string, unknown>
+  const requiredAmount = isValidIntegerAmount(request.amount)
+    ? BigInt(request.amount as string)
+    : undefined
+  const decimals = (request.decimals as number | undefined) ?? 2
+  const currency = request.currency as string | undefined
+
+  const amountDisplay = requiredAmount ? formatAmount(requiredAmount, decimals) : 'unknown amount'
+  const tokenDisplay = currency?.length === 3 ? currency.toUpperCase() : ''
+  const paymentDesc = `${amountDisplay}${tokenDisplay ? ` ${tokenDisplay}` : ''} via Stripe${isStripeTestKey ? ' (testmode)' : ''}`
+
+  if (isStripeTestKey) {
+    if (!options.silent) console.log(pc.dim(`    Attempting: ${paymentDesc}`))
+  } else if (!options.yes && !ctx.isInteractive) {
+    results.push(skip(tag, 'non-interactive mode, use --yes to approve'))
+    return
+  } else if (!options.yes) {
+    const ok = await confirm(`  ${pc.yellow('Pay')} ${paymentDesc}. Continue?`, false)
+    if (!ok) {
+      results.push(skip(tag, 'declined'))
+      return
+    }
+  } else {
+    if (!options.silent) console.log(pc.dim(`    Auto-approved: ${paymentDesc}`))
+  }
+
+  // Resolve plugin
+  const resolved = resolvePlugin(challenge, loaded?.config)
+  const plugin = resolved.plugin
+  if (!plugin) {
+    results.push(skip(tag, 'no Stripe plugin available'))
+    return
+  }
+
+  let methods: AnyClient[]
+  let createCredentialFn: ((response: Response) => Promise<string>) | undefined
+  try {
+    const methodOpts: Record<string, string> = { paymentMethod: 'pm_card_visa' }
+    if (stripeKey) methodOpts.secretKey = stripeKey
+    const pluginResult = await plugin.setup({
+      challenge,
+      options: {},
+      methodOpts,
+    })
+    methods = pluginResult.methods
+    createCredentialFn = pluginResult.createCredential
+  } catch (error) {
+    results.push(skip(tag, (error as Error).message))
+    return
+  }
+
+  const credential = await createAndSend(challenge, methods, createCredentialFn, tag, results)
+  if (!credential) return
+
+  plugin.prepareCredentialRequest?.({ challenge, credential, headers: fetchHeaders })
+
+  // Stripe testmode: detect livemode rejection gracefully
+  if (isStripeTestKey) {
+    const resp = await fetchWithTimeout(
+      url,
+      {
+        method: endpoint.method,
+        headers: { ...fetchHeaders, [Constants.Headers.authorization]: credential },
+        body: fetchBody ?? null,
+      },
+      30_000,
+    )
+    if (resp.status >= 200 && resp.status < 300) {
+      results.push(check(`${tag}: successful`, `HTTP ${resp.status}`))
+    } else {
+      results.push(
+        skip(
+          `${tag}: server is in livemode`,
+          undefined,
+          'Run your server with a Stripe test key to automatically validate Stripe payments in testmode.',
+        ),
+      )
+    }
+    return
+  }
+
+  await sendAndValidateResponse(
+    results,
+    url,
+    endpoint,
+    credential,
+    fetchHeaders,
+    fetchBody,
+    verbose,
+    undefined,
+  )
+}
+
+async function createAndSend(
+  challenge: Challenge.Challenge,
+  methods: AnyClient[],
+  createCredentialFn: ((response: Response) => Promise<string>) | undefined,
+  tag: string,
+  results: CheckResult[],
+): Promise<string | undefined> {
   const fakeResponse = new Response(null, {
     status: 402,
     headers: { [Constants.Headers.wwwAuthenticate]: Challenge.serialize(challenge) },
   })
   try {
+    let credential: string
     if (createCredentialFn) {
       credential = await createCredentialFn(fakeResponse)
     } else {
       const mppx = Mppx.create({ methods, polyfill: false })
       credential = await mppx.createCredential(fakeResponse)
     }
+    results.push(check(`${tag}: submitted`))
+    return credential
   } catch (error) {
     const msg = (error as Error).message
-    const isInsufficientBalance =
-      msg.toLowerCase().includes('insufficientbalance') ||
-      msg.toLowerCase().includes('insufficient')
-    if (isInsufficientBalance) {
-      const match = msg.match(/available:\s*(\d+),\s*required:\s*(\d+)/)
-      const available = match ? BigInt(match[1]!) : undefined
-      const required = match ? BigInt(match[2]!) : requiredAmount
-      const fromMatch = msg.match(/from:\s*(0x[0-9a-fA-F]{40})/)
-      const fromAddr = fromMatch?.[1]
-      const requiredDisplay = required
-        ? `$${(Number(required) / 10 ** decimals).toFixed(2)}`
-        : 'unknown'
-      const availableDisplay =
-        available !== undefined ? `$${(Number(available) / 10 ** decimals).toFixed(2)}` : undefined
-      const detail = availableDisplay
-        ? `Have ${availableDisplay}, need ${requiredDisplay}`
-        : `Endpoint requires ${requiredDisplay}`
-      const hint = fromAddr
-        ? `Wallet ${fromAddr} needs at least ${requiredDisplay}. This is a local wallet created by "mppx account create". Fund it to run payment tests, or point at a testnet server for free validation.`
-        : `Fund your mppx wallet with at least ${requiredDisplay} to run payment tests, or use a testnet server.`
-      results.push(skip('Payment: insufficient balance', detail, hint))
-      return results
+    if (msg.toLowerCase().includes('insufficient')) {
+      results.push(skip(tag, `insufficient balance: ${msg}`))
+    } else {
+      results.push(fail(tag, msg))
     }
-    results.push(fail('Payment: create credential', msg))
-    return results
+    return undefined
   }
-
-  results.push(check('Payment: credential created'))
-
-  // Prepare and send
-  plugin?.prepareCredentialRequest?.({ challenge, credential, headers: fetchHeaders })
-  return await sendAndValidateResponse(
-    results,
-    url,
-    endpoint,
-    credential,
-    fetchHeaders,
-    fetchBody,
-    verbose,
-    isTestnet,
-  )
 }
 
 async function sendAndValidateResponse(
@@ -317,7 +586,7 @@ async function sendAndValidateResponse(
   baseHeaders: Record<string, string>,
   fetchBody: string | undefined,
   verbose: boolean,
-  isTestnet?: boolean,
+  explorerChain?: Chain | undefined,
 ): Promise<CheckResult[]> {
   let paymentResponse: Response
   try {
@@ -475,10 +744,10 @@ async function sendAndValidateResponse(
     try {
       const receipt = Receipt.deserialize(receiptHeader)
       if (receipt.reference && /^0x[0-9a-fA-F]{64}$/.test(receipt.reference)) {
-        const chain = isTestnet ? tempoModerato : tempoMainnetChain
-        const explorerUrl = chain.blockExplorers?.default?.url
+        const explorerUrl = explorerChain?.blockExplorers?.default?.url
         if (explorerUrl) {
-          results.push(check('On-chain transaction', `${explorerUrl}/receipt/${receipt.reference}`))
+          const path = explorerUrl.includes('tempo') ? 'receipt' : 'tx'
+          results.push(check('On-chain transaction', `${explorerUrl}/${path}/${receipt.reference}`))
         }
       }
     } catch {}