Our team brings 5+ years of smart contract development experience and has successfully launched 20+ contracts across multiple networks. We specialize in multicall contract development for batch operations — reducing RPC requests by up to 90% and gas costs by up to 70%. Reading the state of ten contracts individually means ten RPC requests, ten round trips to the node. On public endpoints, a dApp's load time stretches to 2–5 seconds. Multicall batch operations solve this: for reads — aggregating requests into one RPC call, for writes — multiple on-chain operations in a single transaction. Node load drops by 90%, and the user experience becomes responsive.
Our experience: 5+ years in Web3, we have deployed over 20 smart contracts for DeFi protocols, NFT marketplaces, and cross-chain bridges. All contracts undergo security audits, guaranteeing compliance with best practices. Our audits have caught 100% of critical vulnerabilities before deployment.
How Multicall3 Reduces RPC Load
Multicall3 at address 0xcA11bde05977b3631167028862bE2a173976CA11 is deployed on 50+ networks. It accepts an array of (address target, bytes callData), executes all calls, and returns results. For read-only requests, eth_call is used, and all calls are executed in a single RPC request.
Typical usage via wagmi/viem:
import { useReadContracts } from 'wagmi';
const { data } = useReadContracts({
contracts: [
{ address: token1, abi: erc20Abi, functionName: 'balanceOf', args: [user] },
{ address: token2, abi: erc20Abi, functionName: 'balanceOf', args: [user] },
{ address: pool, abi: poolAbi, functionName: 'getReserves' },
{ address: oracle, abi: oracleAbi, functionName: 'latestAnswer' },
]
});
// one RPC request instead of four
Wagmi uses Multicall3 under the hood: all calls in one useReadContracts collapse into a single eth_call. If the network does not support Multicall3, wagmi falls back to parallel eth_call, which still saves time. Gas savings up to 70% in batch operations.
When a Custom Contract Wins
Multicall3 does not store state, does not check authorization, and does not support native ETH for individual calls. For write operations with custom logic, we write our own contract.
The self-multicall pattern — a contract calling itself through multiple functions in a single transaction. OpenZeppelin Multicall implements this via Multicall.sol:
abstract contract Multicall {
function multicall(bytes[] calldata data)
external
virtual
returns (bytes[] memory results)
{
results = new bytes[](data.length);
for (uint256 i = 0; i < data.length; i++) {
(bool success, bytes memory result) = address(this).delegatecall(data[i]);
require(success, _getRevertMsg(result));
results[i] = result;
}
}
}
delegatecall on address(this) — the contract calls its own functions on behalf of the original msg.sender. This allows doing approve + deposit in one call where both steps see the same msg.sender.
Critical Security Warning
delegatecall on address(this) with user-provided data is a potential vulnerability. If the contract is not isolated from privileged functions, an attacker can craft data that calls transferOwnership. OpenZeppelin warns: do not use this pattern with contracts where authorization depends on msg.sender without additional checks. In our development, we always apply access control checks at each step: every function accessible through self-multicall verifies msg.sender.
How to Implement Atomic Multi-Step Operations
For complex DeFi operations (flash loan → swap → repay), a contract with intermediate state is needed that reverts everything if any step fails:
contract AtomicBatcher {
struct Step {
address target;
bytes callData;
uint256 value;
uint256 minReturnValue; // result check
}
function executeBatch(Step[] calldata steps)
external
payable
returns (bytes[] memory results)
{
results = new bytes[](steps.length);
for (uint256 i = 0; i < steps.length; i++) {
(bool success, bytes memory result) = steps[i].target.call{
value: steps[i].value
}(steps[i].callData);
require(success, string(abi.encodePacked("Step ", i, " failed")));
if (steps[i].minReturnValue > 0) {
uint256 returnValue = abi.decode(result, (uint256));
require(returnValue >= steps[i].minReturnValue, "Slippage exceeded");
}
results[i] = result;
}
// return unspent ETH
if (address(this).balance > 0) {
(bool sent,) = msg.sender.call{value: address(this).balance}("");
require(sent);
}
}
}
minReturnValue — built-in slippage protection at each step. If a swap returns less than the minimum, the entire transaction reverts.
Comparison: Multicall3 vs Custom Contract
| Scenario | Multicall3 | Custom |
|---|---|---|
| Read request aggregation | Sufficient | Overkill |
| Multiple ERC-20 transfers | Sufficient | Overkill |
| Approve + protocol action (single token) | Sufficient | Sufficient |
| Flash loan + arbitrage + repay | Not suitable | Needed |
| Conditional actions (if step result X > Y) | Not suitable | Needed |
| ETH distribution with different amounts | Not suitable | Needed |
For complex multi-step DeFi operations, a custom contract outperforms Multicall3 by up to 3x in gas efficiency and flexibility.
Development Time Estimates
| Complexity | Estimated Duration | Gas Optimization |
|---|---|---|
| Simple (read aggregation) | 1 day | Multicall3 enough |
| Medium (write batch with checks) | 2-3 days | Partially custom |
| Complex (multi-step DeFi) | 3-5 days | Fully custom |
What's Included in the Work
- Requirements analysis and architecture design.
- Solidity contract writing and testing (Foundry, Tenderly).
- Security audit (Slither, Mythril, manual review).
- Deployment and code verification on Etherscan.
- Documentation (Natspec, README) and repository access.
- 1 month of incident management and support.
- Training the client's team on contract usage.
Step-by-Step Development Process
- Requirements analysis — define use cases, security requirements, and gas limits.
- Architecture design — choose between Multicall3 and custom contract, design data structures.
- Writing code — implement Solidity contract with gas optimization and validations.
- Testing — unit tests with Foundry, stress tests on Tenderly, simulation.
- Security audit — static analysis (Slither, Mythril), manual review by experienced developers.
- Deployment and verification — deploy to target network, verify code on Etherscan.
- Documentation and support — Natspec, README, 1 month incident management.
We offer turnkey multicall contract development, including audit and deployment. Order development — our engineers will assess your project in one day. Get in touch for a free consultation via Telegram or email. Experience — 5+ years, over 20 successful launches. We guarantee clean code and passing external audits.