Guarda Wallet Custom RPC Setup: Connecting to Private Blockchains and Layer 2 Networks

A developer building on an experimental Layer 2 network or testing a private blockchain deployment needs reliable connectivity without relying on default public endpoints. Using a wallet that enforces its own node infrastructure creates friction: limited chain support, potential rate limiting, and no control over where transactions route. A non-custodial wallet with customizable RPC endpoints solves that constraint by letting users and developers specify their own remote procedure call servers, whether pointing to a personal node, a testnet cluster, or an optimized provider for specific performance requirements.

Guarda Wallet’s architecture supports this configuration across its web, desktop, mobile, and browser extension platforms. The ability to add custom RPC endpoints transforms it from a user-facing asset manager into a developer tool, enabling connection to experimental chains, private deployments, and Layer 2 networks that are not part of the standard network list. Understanding how to configure these settings correctly, validate endpoints, and troubleshoot common failures is essential for anyone moving beyond simple token holding into active protocol interaction or infrastructure testing.

Why custom RPC endpoints matter for Guarda Wallet users

Default public endpoints often represent a compromise. They must serve thousands of requests per day from disparate users and applications, which means rate limits, variable latency, and occasional unavailability during network congestion. For a casual token holder checking balances, this is acceptable. For a developer deploying smart contracts, arbitraging across DEXs, or testing consensus changes, it becomes a bottleneck. A custom RPC endpoint gives direct control over request routing, allows higher throughput, and enables connection to networks that are not included in any wallet’s default list.

Guarda Wallet’s non-custodial architecture means your private keys remain encrypted locally on your device. Adding a custom RPC endpoint does not change that fundamental security property. The RPC server you specify only sees the addresses you query and the transactions you broadcast; it never handles your recovery phrase or signing key. However, the choice of endpoint does affect network privacy. A public endpoint operator can see your IP address, wallet addresses, and transaction patterns. Using your own node or a privacy-focused RPC provider reduces that exposure.

The practical scenarios for custom RPC setup fall into several categories. First, testnet and development: testing contracts on Sepolia, Goerli, or a local Hardhat fork before mainnet deployment. Second, Layer 2 networks: connecting to Arbitrum, Optimism, Polygon, or newer chains not yet in Guarda’s default configuration. Third, private or permissioned networks: internal testnets or consortium blockchains where a standard endpoint does not exist. Fourth, performance optimization: routing traffic through a provider with lower latency, higher rate limits, or specialized indexing for your use case. Each scenario requires slightly different validation and monitoring.

When you configure a custom RPC in Guarda Wallet, you are essentially telling the application: “For this blockchain, use this specific server to read state and broadcast transactions.” That server becomes a chokepoint for your wallet’s visibility and responsiveness. Misconfiguring it—using a dead endpoint, a server on a different network fork, or one with incompatible API versions—will make the wallet appear broken for that chain. The validation steps described below prevent most such mistakes.

Understanding RPC endpoints and their requirements

An RPC endpoint is an HTTP or HTTPS URL that exposes blockchain read and write methods. The standard interface is JSON-RPC 2.0, which means you send structured requests to methods like eth_getBalance, eth_sendRawTransaction, or eth_call. The server responds with the requested data or an error. For EVM-compatible chains (Ethereum, Polygon, Arbitrum, Optimism), the method set is largely standardized. For non-EVM chains, the method set differs; Solana uses its own JSON-RPC methods, as does Tezos or Cosmos.

Guarda Wallet handles multiple blockchain protocols. When you add a custom RPC, the wallet must know which protocol that chain implements. Adding an Ethereum RPC endpoint to a Solana network configuration will fail because the method calls will not match. Similarly, an RPC server that implements only a subset of methods may work for balance queries but fail when you try to send a transaction or call a contract. Before adding a custom endpoint to Guarda Wallet, verify three things: the endpoint’s protocol (EVM, Solana, Tezos, Cosmos, etc.), which methods it supports, and whether it requires authentication or API keys.

Rate limits and request quotas are another critical factor. Public RPC endpoints often limit requests per second or per day. If Guarda Wallet sends 100 requests to fetch balances for a portfolio with 20 tokens across 5 networks, and each network is rate-limited to 10 requests per second, some requests will be rejected. The wallet may show incomplete data or retry after a delay. For this reason, developers often use providers like Infura, Alchemy, QuickNode, or Chainstack, which offer higher rate limits in exchange for an API key. Some of these services are free up to a certain threshold; higher throughput requires a paid plan.

HTTPS versus HTTP is another consideration. HTTPS is encrypted in transit, protecting your requests from network eavesdropping. HTTP is faster but unencrypted. For public networks where you are querying data that is already public, the privacy difference is minimal. For private testnets or if you are concerned about metadata leakage, HTTPS is preferable. Most production RPC services use HTTPS by default. If you are setting up a custom RPC endpoint for a private network and only have HTTP available, evaluate whether the reduced latency justifies the reduced encryption.

Step-by-step configuration in Guarda Wallet

The process differs slightly across platforms—web, desktop, mobile—but the logic is identical. Open Guarda Wallet and navigate to the network settings or custom network configuration panel. In the browser extension or web version, this is typically under Settings > Networks or Add Network. On desktop and mobile, it may be under Advanced Settings or Blockchain Settings. The specific menu location has evolved across updates, so check Guarda Wallet’s latest documentation if you cannot locate it immediately.

When you reach the custom network form, you will need to fill in several fields. Network Name is the label you see in the wallet’s UI—something like “Arbitrum Sepolia” or “My Private Chain.” Chain ID is the numeric identifier for the network; Ethereum mainnet is 1, Sepolia is 11155111, Arbitrum One is 42161. This must match the chain ID the RPC server is configured for. RPC URL is the endpoint itself: the full HTTPS or HTTP address you are connecting to. Currency Symbol is the gas token (ETH, MATIC, ARB). Block Explorer URL

For EVM-compatible chains, you may also specify an optional API endpoint for contract verification and ABI lookup, though this is not required for basic wallet functions. Some configurations allow you to mark the network as testnet or mainnet, which affects how Guarda Wallet displays it. Do not guess these values. A mismatched chain ID or an RPC endpoint running a different network version will produce silent failures: balances may appear as zero, transactions may fail mid-flight, or you may accidentally broadcast to the wrong network.

After entering the configuration, Guarda Wallet should test the connection immediately or upon your request. This test verifies that the endpoint is reachable and responds to a basic RPC call. A successful test indicates that the endpoint is online and uses the correct protocol. It does not guarantee that the chain ID matches or that all wallet functions will work. Save the configuration only after a successful test, then add an account for that network if you have not already.

Validating and troubleshooting custom RPC connections

After adding a custom RPC endpoint to Guarda Wallet, perform a series of validation checks before using it with real funds. First, retrieve a balance. If you have an account on that network, fetch its balance through the wallet. The balance should match what you see on the block explorer for the same address. If it differs or shows as zero, the RPC endpoint may be out of sync, running a different fork, or experiencing an error.

Second, make a test transaction with a tiny amount, if the network supports gas fees. Broadcast a small transfer to another account and confirm it on the block explorer. This tests not only the RPC endpoint’s read capabilities but also its transaction broadcasting pipeline. Some endpoints allow queries but reject transactions due to rate limits, API key restrictions, or misconfiguration of their broadcast channel. If the transaction appears on the block explorer, the endpoint is working correctly. If it times out or fails with a cryptic error, investigate whether the endpoint requires additional authentication or has a bug.

Third, check for common RPC error messages. “Invalid chain ID” means the network configuration in Guarda Wallet does not match the server. “Method not found” typically means the endpoint does not support a particular JSON-RPC call; this is common for older or lightweight endpoints. “Exceeded rate limit” means too many requests in a short period; if this happens frequently, switch to a higher-tier provider or use an API key. “Gateway timeout” or “connection refused” means the server is unreachable; check whether the URL is correct, whether there is network connectivity, and whether the server is online.

If Guarda Wallet shows a network error or blank balance after configuration, do not immediately reconfigure the endpoint. First, manually verify the endpoint by making a curl or fetch request. For example, you can test an Ethereum-compatible endpoint with: `curl -X POST -H “Content-Type: application/json” –data ‘{“jsonrpc”:”2.0″,”method”:”eth_blockNumber”,”params”:[],”id”:1}’ `. If the server responds with a block number, it is working. If it returns an error or times out, the problem is at the server level, not Guarda Wallet.

Custom RPC for Layer 2 networks and testnets

Layer 2 networks like Arbitrum, Optimism, and Polygon Zkync require custom RPC configuration if Guarda Wallet does not include them by default. Many of these networks are mature and may be included in Guarda’s default list, but testnets or newer L2s often are not. Obtain the RPC endpoint from the official network documentation—do not use random endpoints from GitHub without verification.

Arbitrum One, for example, uses the chain ID 42161. Its official RPC endpoint is https://arb1.arbitrum.io/rpc. Arbitrum Sepolia (testnet) is chain ID 421614 and uses https://sepolia-rollup.arbitrum.io/rpc. Enter these exactly as shown; an extra slash, a typo, or a different variant will cause failures. After adding the network, import or create an account, and test with a small transaction if possible. Layer 2 transactions are faster and cheaper than mainnet, making them ideal for testing custom RPC setup without significant cost.

Testnets like Goerli, Sepolia, or Mumbai are free to use and do not require real funds. Obtain testnet ETH or MATIC from a faucet, send a small amount to your Guarda Wallet address, and verify it appears. This confirms end-to-end connectivity without risk. Many testnets are deprecated or scheduled for shutdown—Goerli and Mumbai are no longer the primary testnets—so check the latest Ethereum or Polygon documentation for current recommendations.

Private networks and local testnets require additional configuration. If you are running a local Hardhat or Ganache instance, your RPC endpoint is typically http://127.0.0.1:8545 (Hardhat) or http://127.0.0.1:7545 (Ganache). The chain ID depends on your configuration; Hardhat defaults to 31337, while Ganache may use 1024 or another number. On desktop, this works if Guarda Wallet is running on the same machine. On mobile or web, you will need to expose the local endpoint through a tunnel or network interface, which introduces additional complexity and security considerations. For development, desktop Guarda Wallet is simpler.

RPC endpoint providers and optimization strategies

Public endpoints are free but shared. Paid RPC providers offer higher reliability, better rate limits, and sometimes additional features like transaction history, event indexing, or webhook support. Popular choices include Infura, Alchemy, QuickNode, Chainstack, and node-as-a-service providers from blockchain projects themselves. Each offers a free tier with limited requests per day, making them suitable for development. Paid tiers start around $20-50 per month for production use.

When evaluating a provider for use with guarda wallet, consider latency, reliability, support for the specific chains you need, and cost structure. Some providers bill by request count; others charge monthly. Some offer geographic distribution, routing requests to the nearest node for lower latency. Others specialize in specific chains—Shyft for Solana, Pocket Network for decentralized RPC, Infura for Ethereum and Polygon.

An optimization strategy for Guarda Wallet might involve using different endpoints for different use cases. For balance queries and portfolio monitoring, a free public endpoint or a low-tier service is adequate. For active trading or DeFi interaction, where latency and reliability matter, a paid provider like Alchemy or QuickNode is worth the cost. For privacy, a self-hosted node or a privacy-focused provider like 1RPC (which uses privacy proxies) is preferable despite higher latency. Guarda Wallet’s support for custom RPC allows you to switch strategies without replacing the wallet.

If you operate a personal or organizational node, you can use its RPC endpoint directly. Running a full node for Ethereum or a major Layer 2 requires significant disk space (hundreds of gigabytes) and bandwidth. Archive nodes, which store the complete history, require terabytes. Light clients and validator clients with pruning options are more resource-efficient but less feature-complete. For a developer running a node for integration testing, a pruned Geth or Besu node on a desktop is sufficient. For production usage through Guarda Wallet across many users, a managed service is more reliable.

Security considerations and best practices

A custom RPC endpoint does not compromise Guarda Wallet’s non-custodial security—your private keys remain encrypted locally. However, the endpoint operator has visibility into your wallet’s behavior. If you query balances for 10 addresses from one IP address, the RPC operator can infer they belong to the same entity. If you broadcast unsigned transactions or use the endpoint to monitor specific smart contract events, the operator can learn your intentions. This is primarily a privacy concern, not a security one.

Mitigate this by using HTTPS endpoints (encrypted in transit), rotating between multiple endpoints for different transactions, using a VPN or Tor if privacy is critical, or running your own node. Do not use a public HTTP endpoint from an untrusted network, as the traffic is unencrypted and could be intercepted. Do not add an endpoint from a random GitHub repository or Discord message without verifying its legitimacy; a compromised RPC endpoint could serve incorrect blockchain state or steal transaction data.

API keys, if your chosen provider requires them, should be treated like passwords. Do not hardcode them in public repositories or share them. Some providers allow you to restrict API keys by domain or IP address, which limits damage if a key leaks. Guarda Wallet stores your configuration locally, so an API key entered in the wallet is not transmitted to Guarda’s servers. However, the key is visible to anyone with access to your device, so consider whether a service-specific API key with limited permissions is preferable to a master key.

Monitor your RPC provider’s status page or set up alerts if the endpoint becomes unavailable. A failed endpoint will leave Guarda Wallet unable to interact with that network until you switch endpoints or the server recovers. For production use, consider a failover: add two endpoints for the same network, and manually switch if the primary fails. Some advanced wallets support automatic failover; Guarda Wallet currently requires manual selection, so maintain a list of backup endpoints for critical networks.

Advanced configurations and automation

For developers working with multiple custom networks, maintaining RPC configurations manually becomes tedious. Some workflows involve exporting network configurations from Guarda Wallet (if the feature is available) or documenting them externally for easy re-import. Others involve using wallet connection libraries like Web3.js or Ethers.js to programmatically manage multiple endpoints, then connecting those applications to Guarda Wallet via WalletConnect or MetaMask-compatible browser injection.

Guarda Wallet’s browser extension enables Web3 connectivity, meaning decentralized applications can request permission to connect and send transactions through the wallet. If you are building a dapp that uses custom networks, you can guide users to add the network to Guarda through the extension’s UI, or provide a JSON-RPC network descriptor that users can import. This is more convenient than manual configuration and reduces configuration errors.

For testnet and development work, storing network configurations in a version-controlled dotenv or JSON file speeds up setup across multiple machines or team members. Document the purpose of each network, the provider rationale, and any known limitations or gotchas. This reduces onboarding friction and prevents misconfigurations that waste debugging time. Over time, the stable configuration can be exported or contributed back to Guarda Wallet’s network list if it becomes widely used.