[TASK-14095] feat: add fallback transport to viem clients

[jjramirezn]

Use viem fallback transport to handle RPC errors and fallback to other providers.

[notion-workspace]

Stop 429 from infura from afectting us

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Preview	Comments	Updated (UTC)
peanut-wallet	Canceled			Aug 25, 2025 8:53pm

[coderabbitai]

Walkthrough

Synchronous refactor of getPublicClient with a new fallback transport, updates to all call sites, migration away from ethers/SDK provider utilities, adjustments to ENS utilities’ RPC handling, constants cleanup, zerodev clients switched to fallback transport, and test mocks updated to include viem.fallback.

Changes

Cohort / File(s)	Summary
Client transport + sync public client src/app/actions/clients.ts	Added getTransportWithFallback using viem.fallback; refactored getPublicClient to be synchronous and use the fallback transport; updated imports and docs.
Zerodev public clients src/constants/zerodev.consts.ts	Replaced http(...) transports with getTransportWithFallback(...) for arbitrum and polygon; removed now-unneeded imports.
Call-site updates to sync client src/app/actions/claimLinks.ts, src/app/actions/tokens.ts	Replaced await getPublicClient(...) with getPublicClient(...); no other logic changes at these sites.
Service call-site with potential issue src/services/swap.ts	Changed to direct getPublicClient(...) assignment in checkTokenAllowance; introduces mismatch if client Promise was previously expected.
SDK provider removal and migration src/utils/sdk.utils.ts, src/utils/general.utils.ts	Deleted getSDKProvider and related logic; migrated fetchTokenSymbol to viem readContract via getPublicClient; removed Peanut SDK/ethers dependency for symbol lookup.
ENS utilities RPC handling src/utils/ens.utils.ts	Removed ethers fallback; now requires rpcUrls[mainnet.id]?.[0] (non-null) and eliminates hardcoded RPC fallback.
Constants cleanup src/constants/general.consts.ts	Removed two commented lines in rpcUrls; no runtime changes.
Tests src/components/Global/GeneralRecipientInput/__tests__/GeneralRecipientInput.test.tsx	Extended viem mock to include fallback: jest.fn() to support new transport code paths.

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~60 minutes

Possibly related PRs

• [TASK-14113] fix: handle rpc outage when creating sendlinks #1120 — Also modifies claimLinks.ts around getNextDepositIndex and public client/tx handling.
• [TASK-9940] perf: improve claim flow #768 — Similar migration from SDK-based providers to Viem public clients and related action refactors.
• feat: dont fetch tx receipt twice #812 — Touches claimLinks.ts, refactoring getLinkFromTx, overlapping with current call-site changes.

Suggested labels

enhancement

Suggested reviewers

• jjramirezn
• kushagrasarathe
• Zishan-7

✨ Finishing Touches

• 📝 Generate Docstrings

🧪 Generate unit tests

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch feat/clients-fallback

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

🪧 Tips

Chat

There are 3 ways to chat with CodeRabbit:

• Review comments: Directly reply to a review comment made by CodeRabbit. Example:
  • I pushed a fix in commit <commit_id>, please review it.
  • Open a follow-up GitHub issue for this discussion.
• Files and specific lines of code (under the "Files changed" tab): Tag @coderabbitai in a new review comment at the desired location with your query.
• PR comments: Tag @coderabbitai in a new PR comment to ask questions about the PR branch. For the best results, please provide a very specific query, as very limited context is provided in this mode. Examples:
  • @coderabbitai gather interesting stats about this repository and render them as a table. Additionally, render a pie chart showing the language distribution in the codebase.
  • @coderabbitai read the files in the src/scheduler package and generate a class diagram using mermaid and a README in the markdown format.

Support

Need help? Create a ticket on our support page for assistance with any issues or questions.

CodeRabbit Commands (Invoked using PR/Issue comments)

Type @coderabbitai help to get the list of available commands.

Other keywords and placeholders

• Add @coderabbitai ignore anywhere in the PR description to prevent this PR from being reviewed.
• Add @coderabbitai summary to generate the high-level summary at a specific location in the PR description.
• Add @coderabbitai anywhere in the PR title to generate the title automatically.

CodeRabbit Configuration File (.coderabbit.yaml)

• You can programmatically configure CodeRabbit by adding a .coderabbit.yaml file to the root of your repository.
• Please see the configuration documentation for more information.
• If your editor has YAML language server enabled, you can add the path at the top of this file to enable auto-completion and validation: # yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json

Status, Documentation and Community

• Visit our Status Page to check the current availability of CodeRabbit.
• Visit our Documentation for detailed information on how to use CodeRabbit.
• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[coderabbitai]

Actionable comments posted: 1

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (4)

src/app/actions/claimLinks.ts (1)

12-48: Sanity-check complete: remove direct http imports outside the transport builder

• No await getPublicClient(...) calls remain.
• Direct http imports found only in:
  • src/app/actions/clients.ts (line 2) — this file implements getTransportWithFallback, so importing http and fallback here is expected.
  • src/context/kernelClient.context.tsx (line 20) — must be refactored.
• Raw http(...) invocations found in kernelClient.context.tsx (lines 78, 103) and in clients.ts (lines 19, 22). The latter are part of the transport-builder logic and can remain; the former need to use getTransportWithFallback.
• No createPublicClient calls missing a transport fallback.

Action items in src/context/kernelClient.context.tsx:

• Update your imports around line 20:

  -import { Chain, http, PublicClient, Transport } from 'viem'
  +import { Chain, PublicClient, Transport } from 'viem'
  +import { getTransportWithFallback } from '@/app/actions/clients'

• Replace the two http(...) calls (around lines 78 and 103) with the fallback transport:

  -bundlerTransport: http(bundlerUrl),
  +bundlerTransport: getTransportWithFallback(chain.id),
  …
  -transport: http(paymasterUrl),
  +transport: getTransportWithFallback(chain.id),

src/app/actions/tokens.ts (3)

151-189: Cache key missing dynamic params will cause cross-token/chain collisions.

unstable_cache is configured with a static key ['fetchTokenDetails']. This will cache the first token details fetched and return it for subsequent calls, regardless of tokenAddress or chainId. Same pattern exists below for gas price/estimate. Include the parameters in the cache key (or switch to a small wrapper that derives keys per call).

Apply this refactor pattern:

-export const fetchTokenDetails = unstable_cache(
-    async (
-        tokenAddress: string,
-        chainId: string
-    ): Promise<{
-        symbol: string
-        name: string
-        decimals: number
-    }> => {
+export const fetchTokenDetails = async (
+  tokenAddress: string,
+  chainId: string
+): Promise<{ symbol: string; name: string; decimals: number }> =>
+  unstable_cache(
+    async () => {
       console.log('chain id', chainId)
       const tokenDetails = getTokenDetails({ tokenAddress: tokenAddress as Address, chainId: chainId! })
       if (tokenDetails) return tokenDetails
       const client = getPublicClient(Number(chainId) as ChainId)
       console.log('token address', tokenAddress)
       const [symbol, name, decimals] = await Promise.all([
         /* ... */
       ])
       if (!symbol || !name || !decimals) throw new Error('Failed to fetch token details')
       return { symbol, name, decimals }
-    },
-    ['fetchTokenDetails'],
-    {
-        tags: ['fetchTokenDetails'],
-    }
-)
+    },
+    ['fetchTokenDetails', chainId, tokenAddress],
+    { tags: ['fetchTokenDetails'] }
+  )()

Repeat the same approach for the gas helpers below to include their inputs in the cache key.

---

194-204: Gas price cache key is global; include chainId.

['getGasPrice'] will cache a single chain’s gas price for all chains. This yields incorrect estimates across networks.

Proposed change:

-const getCachedGasPrice = unstable_cache(
-    async (chainId: string) => {
-        const client = getPublicClient(Number(chainId) as ChainId)
-        const gasPrice = await client.getGasPrice()
-        return gasPrice.toString()
-    },
-    ['getGasPrice'],
-    {
-        revalidate: 2 * 60, // 2 minutes
-    }
-)
+const getCachedGasPrice = (chainId: string) =>
+  unstable_cache(
+    async () => {
+      const client = getPublicClient(Number(chainId) as ChainId)
+      const gasPrice = await client.getGasPrice()
+      return gasPrice.toString()
+    },
+    ['getGasPrice', chainId],
+    { revalidate: 2 * 60 }
+  )()

---

209-223: Gas estimate cache key ignores from/to/data/chain; collisions likely.

The current key ['getGasEstimate'] will reuse the first gas estimate for arbitrary transactions and networks. This can severely skew cost calculations.

Apply a safer per-call key. Consider hashing data to avoid a very long key:

-import type { Address, Hex } from 'viem'
+import type { Address, Hex } from 'viem'
+import { keccak256 } from 'viem'
+import { toHex } from 'viem'

-const getCachedGasEstimate = unstable_cache(
-    async (fromAddress: Address, contractAddress: Address, data: Hex, chainId: string) => {
-        const client = getPublicClient(Number(chainId) as ChainId)
-        const gasEstimate = await client.estimateGas({
-            account: fromAddress,
-            to: contractAddress,
-            data,
-        })
-        return gasEstimate.toString()
-    },
-    ['getGasEstimate'],
-    {
-        revalidate: 5 * 60, // 5 minutes - gas estimates are more stable
-    }
-)
+const getCachedGasEstimate = (
+  fromAddress: Address,
+  contractAddress: Address,
+  data: Hex,
+  chainId: string
+) =>
+  unstable_cache(
+    async () => {
+      const client = getPublicClient(Number(chainId) as ChainId)
+      const gasEstimate = await client.estimateGas({
+        account: fromAddress,
+        to: contractAddress,
+        data,
+      })
+      return gasEstimate.toString()
+    },
+    [
+      'getGasEstimate',
+      chainId,
+      fromAddress,
+      contractAddress,
+      // compact key for calldata
+      keccak256(data as Hex),
+    ],
+    { revalidate: 5 * 60 }
+  )()

🧹 Nitpick comments (9)

src/components/Global/GeneralRecipientInput/__tests__/GeneralRecipientInput.test.tsx (2)

42-47: Mock viem.fallback to return a minimal Transport function

Right now fallback: jest.fn() returns a bare mock. If any path actually calls viem.fallback(...), createPublicClient may expect a Transport function and could crash. Return a minimal transport to harden the test double.

 jest.mock('viem', () => ({
   isAddress: (address: string) => address.startsWith('0x') && address.length === 42,
   http: jest.fn(),
   createPublicClient: jest.fn(),
-  fallback: jest.fn(),
+  // Return a minimal viem Transport function shape
+  fallback: jest.fn(() => () => ({ request: jest.fn() })),
 }))

---

42-47: Prefer partial mocking to avoid unintentionally stripping needed viem exports

If other imports inside this test (or transitive deps) rely on additional viem exports, a full module mock can cause surprising failures. Consider spreading the real module and overriding only what you need.

-jest.mock('viem', () => ({
-  isAddress: (address: string) => address.startsWith('0x') && address.length === 42,
-  http: jest.fn(),
-  createPublicClient: jest.fn(),
-  fallback: jest.fn(() => () => ({ request: jest.fn() })),
-}))
+jest.mock('viem', () => {
+  const actual = jest.requireActual('viem')
+  return {
+    ...actual,
+    isAddress: (address: string) => address.startsWith('0x') && address.length === 42,
+    http: jest.fn(() => () => ({ request: jest.fn() })),
+    createPublicClient: jest.fn(),
+    fallback: jest.fn(() => () => ({ request: jest.fn() })),
+  }
+})

src/utils/ens.utils.ts (2)

21-39: Consider memoizing JustaName instance

JustaName.init(...) on every call can be wasteful. Cache per-process (single-threaded Next.js) keyed by siteUrl to reduce init overhead and improve latency.

// outside the function
let cachedJan: ReturnType<typeof JustaName.init> | null = null

// inside resolveAddressToUsername(...)
if (!cachedJan) {
  cachedJan = JustaName.init({ /* same config */ })
}
const justAName = cachedJan

---

32-33: Remove informal comment in production code

The “i dont even have an API key but it works haha” comment is unprofessional and can confuse future maintainers.

-                    apiKey: process.env.JUSTANAME_API_KEY || '', // i dont even have an API key but it works haha @facu
+                    apiKey: process.env.JUSTANAME_API_KEY || '',

src/app/actions/claimLinks.ts (1)

38-41: Unreachable/null-check is ineffective for deposit existence

deposit is an object you’ve just constructed; the if (!deposit) guard will never trigger. If you need a “not found” signal, check fields on rawDeposit (e.g., all-zero tuple) instead.

-        if (!deposit) {
-            throw new Error(`No deposit found for depositIdx ${depositIdx}`)
-        }
+        // Example: treat a zero sender address as "not found" (adjust to actual contract semantics)
+        if (!rawDeposit || rawDeposit[8] === '0x0000000000000000000000000000000000000000') {
+            throw new Error(`No deposit found for depositIdx ${depositIdx}`)
+        }

src/constants/zerodev.consts.ts (1)

49-57: Key type mismatch: use numeric keys for chain-indexed map

Record<string, …> works at runtime, but these keys are numeric chain IDs in practice. Switching to Record<number, …> improves type safety when indexing with arbitrum.id/polygon.id.

-export const PUBLIC_CLIENTS_BY_CHAIN: Record<
-    string,
+export const PUBLIC_CLIENTS_BY_CHAIN: Record<
+    number,
     {
         client: PublicClient
         chain: Chain
         bundlerUrl: string
         paymasterUrl: string
     }
 > = {

src/utils/general.utils.ts (1)

1059-1066: Add bytes32 fallback for non-standard ERC20 symbol.

Some ERC-20s (legacy or proxies) implement symbol() -> bytes32. Reading via erc20Abi (string) will revert. Add a fallback read to bytes32 and decode.

Suggested patch:

-            const client = getPublicClient(Number(chainId) as ChainId)
-            tokenSymbol = (await client.readContract({
-                address: tokenAddress as Address,
-                abi: erc20Abi,
-                functionName: 'symbol',
-                args: [],
-            })) as string
+            const client = getPublicClient(Number(chainId) as ChainId)
+            try {
+                tokenSymbol = (await client.readContract({
+                    address: tokenAddress as Address,
+                    abi: erc20Abi,
+                    functionName: 'symbol',
+                    args: [],
+                })) as string
+            } catch {
+                // Fallback: bytes32 symbol
+                const bytes32Symbol = (await client.readContract({
+                    address: tokenAddress as Address,
+                    abi: [{ type: 'function', name: 'symbol', stateMutability: 'view', inputs: [], outputs: [{ type: 'bytes32' }] }] as const,
+                    functionName: 'symbol',
+                })) as `0x${string}`
+                // Decode bytes32 -> string and trim null bytes
+                const { hexToString } = await import('viem')
+                tokenSymbol = hexToString(bytes32Symbol).replace(/\u0000+$/g, '')
+            }

If you prefer to avoid dynamic import, pull hexToString in the top-level Viem import.

src/app/actions/clients.ts (2)

10-28: Good centralization of fallback transport; consider a couple of small hardening tweaks.

• Edge case: if rpcUrls[chainId] exists but is an empty array, fallback([]) would throw. Guard by checking length.
• You may want to set retryCount/stallTimeout to reduce time to first success under provider stalls.

Proposed tweak:

-export function getTransportWithFallback(chainId: ChainId): Transport {
-    const providerUrls = rpcUrls[chainId]
-    if (!providerUrls) {
+export function getTransportWithFallback(chainId: ChainId): Transport {
+    const providerUrls = rpcUrls[chainId]
+    if (!providerUrls || providerUrls.length === 0) {
         // If no premium providers are configured, viem will use a default one
         return http()
     }
     return fallback(
         providerUrls.map((u) => http(u)),
-        // Viem checks the status of the provider every 60 seconds and notes latency
-        // and stability. The provider that viem will try first depend on this
-        // ranking
-        { rank: { interval: 60_000 } }
+        {
+          // Rank providers every 60s and fail over promptly if one stalls.
+          rank: { interval: 60_000 },
+          retryCount: 2,
+          stallTimeout: 2_500,
+        }
     )
 }

---

30-39: Avoid repeated PublicClient instantiation for non-preconfigured chains.

PUBLIC_CLIENTS_BY_CHAIN covers a subset of chains. For others, getPublicClient creates a new client each call. Adding a small in-module cache avoids extra instantiation and keeps connections/stats warm across requests.

Patch:

-const allChains = Object.values(chains)
+const allChains = Object.values(chains)
 export type ChainId = (typeof allChains)[number]['id']
 
+// Lightweight per-process cache for chains not listed in PUBLIC_CLIENTS_BY_CHAIN
+const EPHEMERAL_CLIENTS = new Map<ChainId, PublicClient>()
+
 export function getPublicClient(chainId: ChainId): PublicClient {
-    let client: PublicClient | undefined = PUBLIC_CLIENTS_BY_CHAIN[chainId]?.client
-    if (client) return client
+    let client: PublicClient | undefined = PUBLIC_CLIENTS_BY_CHAIN[chainId]?.client ?? EPHEMERAL_CLIENTS.get(chainId)
+    if (client) return client
     const chain: Chain = extractChain({ chains: allChains, id: chainId })
     if (!chain) throw new Error(`No chain found for chainId ${chainId}`)
-    return createPublicClient({
+    const created = createPublicClient({
         transport: getTransportWithFallback(chainId),
         chain,
     })
+    EPHEMERAL_CLIENTS.set(chainId, created)
+    return created
 }

📜 Review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

📥 Commits

Reviewing files that changed from the base of the PR and between 2bf2ac0 and f79affa.

📒 Files selected for processing (10)

• src/app/actions/claimLinks.ts (3 hunks)
• src/app/actions/clients.ts (1 hunks)
• src/app/actions/tokens.ts (3 hunks)
• src/components/Global/GeneralRecipientInput/__tests__/GeneralRecipientInput.test.tsx (1 hunks)
• src/constants/general.consts.ts (0 hunks)
• src/constants/zerodev.consts.ts (3 hunks)
• src/services/swap.ts (1 hunks)
• src/utils/ens.utils.ts (2 hunks)
• src/utils/general.utils.ts (2 hunks)
• src/utils/sdk.utils.ts (0 hunks)

💤 Files with no reviewable changes (2)

• src/constants/general.consts.ts
• src/utils/sdk.utils.ts

🧰 Additional context used

🧠 Learnings (1)

📚 Learning: 2025-05-23T19:26:58.220Z

Learnt from: jjramirezn
PR: peanutprotocol/peanut-ui#873
File: src/components/Withdraw/views/Initial.withdraw.view.tsx:95-95
Timestamp: 2025-05-23T19:26:58.220Z
Learning: The GeneralRecipientInput component supports username validation and resolution through the validateAndResolveRecipient function in src/lib/validation/recipient.ts. The function automatically detects usernames (inputs that don't contain '.' for ENS and don't start with '0x' for addresses), validates them via API HEAD request, fetches user data, and resolves them to Ethereum addresses from the user's PEANUT_WALLET account.

Applied to files:

• src/components/Global/GeneralRecipientInput/__tests__/GeneralRecipientInput.test.tsx

🧬 Code graph analysis (7)

src/utils/ens.utils.ts (2)

src/constants/general.consts.ts (1)

• rpcUrls (18-29)

src/utils/__mocks__/wagmi.ts (1)

• mainnet (2-14)

src/constants/zerodev.consts.ts (1)

src/app/actions/clients.ts (1)

• getTransportWithFallback (15-28)

src/services/swap.ts (1)

src/app/actions/clients.ts (2)

• getPublicClient (30-39)
• ChainId (8-8)

src/utils/general.utils.ts (1)

src/app/actions/clients.ts (2)

• getPublicClient (30-39)
• ChainId (8-8)

src/app/actions/tokens.ts (1)

src/app/actions/clients.ts (2)

• getPublicClient (30-39)
• ChainId (8-8)

src/app/actions/claimLinks.ts (2)

src/app/actions/clients.ts (2)

• getPublicClient (30-39)
• ChainId (8-8)

src/constants/zerodev.consts.ts (1)

• PEANUT_WALLET_CHAIN (18-18)

src/app/actions/clients.ts (2)

src/constants/general.consts.ts (1)

• rpcUrls (18-29)

src/constants/zerodev.consts.ts (1)

• PUBLIC_CLIENTS_BY_CHAIN (49-78)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)

• GitHub Check: Deploy-Preview

🔇 Additional comments (11)

src/utils/ens.utils.ts (1)

25-26: Propagate the guarded URL into JustaName provider config

Make sure the safe mainnetRpcUrl is used here; no change needed after applying the previous fix, just calling out the dependency.

src/app/actions/claimLinks.ts (3)

18-25: Good: switched to synchronous PublicClient

The transition to getPublicClient(...) without await matches the new synchronous API and simplifies control flow.

---

61-66: LGTM: synchronous client usage for receipt polling

Using the sync public client for waitForTransactionReceipt is correct and aligns with the refactor.

---

71-83: LGTM: synchronous client used for readContract

getNextDepositIndex now uses the direct PublicClient, consistent with the repo-wide change.

src/services/swap.ts (1)

194-201: LGTM: updated to sync PublicClient

getPublicClient(Number(chainId) as ChainId) aligns with the new API. Casting via Number(chainId) is appropriate given the input type is string.

src/constants/zerodev.consts.ts (3)

3-5: LGTM: centralizing on fallback transport

Importing createPublicClient and getTransportWithFallback matches the new transport strategy and keeps transport logic consistent.

---

60-63: LGTM: arbitrum client now uses fallback transport

Using getTransportWithFallback(arbitrum.id) is consistent with the PR objective and improves resiliency.

---

70-73: LGTM: polygon client now uses fallback transport

Same benefits as above; polling interval retained.

src/app/actions/tokens.ts (2)

163-163: Sync getPublicClient swap looks correct.

Replacing await getPublicClient(...) with the synchronous getPublicClient(...) at all call sites is aligned with the new API and avoids unnecessary awaits. No functional issues spotted here.

Also applies to: 196-196, 211-211

---

160-166: Validate and enforce numeric-only chainId inputs before casting

I reran a scan across .ts/.tsx files and didn’t find any literal "0x…" or "evm:…" prefixes passed directly as chainId. However, since the code does Number(chainId) as ChainId, any non-numeric string (e.g. "evm:42161", "0x1") would become NaN and break client creation. Please:

• Verify that all upstream sources of chainId are guaranteed to be plain numeric strings. In particular, confirm how these variables are derived:

  • selectedChainID in
    src/components/Request/link/views/Create.request.link.view.tsx (l.141)
  • sendLink.chainId in
    src/components/Claim/Claim.tsx (l.177)
  • deposit.chainId in
    src/app/actions/claimLinks.ts (l.41)
  • The chainId argument passed to
    estimateTransactionCostUsd in
    src/services/swap.ts (l.237) and
    src/hooks/usePaymentInitiator.ts (l.268)
  • The chainId prop used in
    src/app/actions/tokens.ts (l.237–240)

• If any of these can ever be non-numeric, either:

  • Add a simple runtime guard (e.g. if (isNaN(+chainId)) throw new Error("Invalid chainId")), or
  • Use a dedicated parser/util (e.g. parseChainId(chainId)) that fails fast on bad inputs.

This will ensure we never feed NaN into getPublicClient or other downstream calls.

src/utils/general.utils.ts (1)

18-21: Imports updated for Viem client + ERC20 ABI.

The move to getPublicClient and erc20Abi aligns with the PR direction and removes SDK-provider coupling. Looks good.

[Hugo0]

i creamed my pants with this PR

[Hugo0]

same as BE, amazinng