Tenderly Fork Setup for Smart Contract Testing

Why You Need a Tenderly Fork in Production Testing?

Picture this: you're developing a DeFi protocol and need to reproduce a complex flash loan attack that occurred at a specific mainnet block. Local anvil --fork-url requires each developer to set up their environment, and the state doesn't persist between restarts. We use Tenderly Fork to create an isolated copy of the mainnet with full state control. It's a cloud fork accessible via an RPC URL that you can share with your team or auditors. Unlike local anvil --fork-url, a Tenderly Fork lives in the cloud and doesn't die when you close the terminal. Our experience with DeFi protocols shows this approach cuts bug reproduction time by 80% and halves testing infrastructure costs. Tenderly Fork supports Ethereum mainnet, Arbitrum, Polygon, and other networks, enabling cross-chain scenario testing without deploying your own nodes.

Why Tenderly Fork Outperforms anvil for Team Collaboration?

anvil --fork-url runs locally and dies with the process. Tenderly Fork is created via API, persists until deleted, and its RPC URL can be handed to a frontend or mobile app. Real case: a vault contract undergoes an audit. The audit team wants to reproduce a specific attack scenario—drain via flash loan at a particular protocol state. Instead of each auditor setting up a local environment, we create a Tenderly Fork pinned at the needed block, set the attacker's balance, and share one RPC URL. Order Tenderly Fork setup—your team will save up to 70% of test environment preparation time.

How to Create a Tenderly Fork via API?

const response = await fetch("https://api.tenderly.co/api/v1/account/MY_ACCOUNT/project/MY_PROJECT/fork", { method: "POST", headers: { "X-Access-Key": process.env.TENDERLY_API_KEY, "Content-Type": "application/json" }, body: JSON.stringify({ network_id: "1", // Ethereum mainnet block_number: 19500000, // specific block transaction_index: 0, initial_balance: 100, chain_config: { chain_id: 1 } }) }); const { simulation_fork } = await response.json(); const forkRpcUrl = `https://rpc.tenderly.co/fork/${simulation_fork.id}`; 

State Manipulation via JSON-RPC

Tenderly Fork supports non-standard methods:

// Set address balance await provider.send("tenderly_setBalance", [ ["0xUserAddress"], "0x56BC75E2D63100000" // 100 ETH in hex ]); // Impersonate account (sign on its behalf) await provider.send("tenderly_addBalance", [ ["0xWhaleAddress"], "0xDE0B6B3A7640000" ]); // Set storage value directly await provider.send("tenderly_setStorageAt", [ contractAddress, storageSlot, // keccak256 slot newValue ]); // Change timestamp await provider.send("evm_setNextBlockTimestamp", [futureTimestamp]); await provider.send("evm_mine", []); 

Writing directly to storage is a powerful testing tool: set paused = true in a contract without calling pause(), simulate a user having already deposited $1M, bypass cooldown periods.

Integration with Foundry

# Run tests against Tenderly Fork forge test --fork-url $TENDERLY_FORK_RPC --fork-block-number 19500000 -vvv 

In Foundry tests, you can use vm.prank(whale) and vm.deal(attacker, 1000 ether) — they work via Tenderly Fork just like with anvil. The difference: state persists between runs if the fork is not recreated.

How to Simulate a Complex Attack Scenario with Tenderly Fork?

The Tenderly Simulate API allows simulating a transaction and getting a detailed trace before sending to mainnet:

const simulation = await fetch(`https://api.tenderly.co/api/v1/account/${account}/project/${project}/simulate`, { method: "POST", headers: { "X-Access-Key": apiKey }, body: JSON.stringify({ network_id: "1", from: senderAddress, to: contractAddress, input: calldata, gas: 500000, value: "0", save: true // save for dashboard viewing }) }); 

The result is a full call trace with gas per call, storage changes, events. This is cheaper than real mainnet deployment for debugging complex scenarios. We guarantee simulations will be accurate and reproducible.

Typical Scenarios

Testing upgrades on mainnet state. Fork at the block before upgrade, execute the upgrade transaction, verify all user positions are read correctly by the new implementation.

Incident reproduction. Fork at the block before the exploit, reproduce the attack vector, find root cause, patch, verify the patched version is resilient.

Demo for investors. Create a fork with the desired initial state (users, positions, balances), share the RPC URL. The investor interacts with the protocol as if on mainnet, but without real funds.

Comparison of Fork Tools

Tenderly Fork Setup Stages

What's Included in Tenderly Fork Setup?

• Fork creation pinned to a block and required network
• JSON-RPC methods configuration for state manipulation (balances, storage, time)
• CI/CD integration for automatic fork creation and deletion
• Script writing for test scenario reproduction
• Documentation on fork usage and API
• One-month post-delivery support

Source: Tenderly Documentation

Get a consultation on Tenderly Fork setup — our engineers will help select the optimal configuration for your project.