Short answer: Multicall3 is deployed on Core mainnet (chain ID 1116) at the usual address, 0xcA11bde05977b3631167028862bE2a173976CA11. Its code first appears at block 6,988,931 (9 September 2023). You can batch many read-only contract calls into one eth_call with aggregate3, from Foundry’s cast, viem’s built-in multicall, or an ethers v6 contract. All results come from the same block, and each call can fail without breaking the others.
This guide shows how to check that the contract is really there, then gives working examples for each tool. It also covers the mistakes that trip people up most. Every command below was run read-only against https://rpc.coredao.org on 19 November 2026. No transactions were sent.
What Multicall3 does (and why it matters on Core)
Multicall3 is a small stateless contract. It takes a list of calls, runs them one after another inside a single EVM call, and returns all the results together. According to the project README, batching reads like this:
- cuts the number of JSON-RPC requests you make, which helps with public-RPC rate limits;
- guarantees every value was read from the same block, so a balance and a total supply can’t come from two different blocks;
- lets you add the block number or timestamp to the batch so you can spot stale data.
On Core this helps dashboards, portfolio trackers and bots that read many ERC-20 balances, or that check USDT and USDC on Core alongside WCORE positions, without hammering the RPC.
Step 1: Verify Multicall3 exists on Core
The Multicall3 README warns that the original deployer key was compromised. On at least one chain (Ancient8), a different contract ended up at the Multicall3 address. So don’t just trust the address. Check the bytecode. With Foundry installed (see our cast commands for Core guide):
export ETH_RPC_URL=https://rpc.coredao.org
M=0xcA11bde05977b3631167028862bE2a173976CA11
cast chain-id # 1116
cast codesize $M # non-zero = a contract is deployed
cast call $M "getChainId()(uint256)" # 1116
To make sure it’s the genuine contract, compare the Core bytecode hash with the Ethereum mainnet one:
cast code $M --rpc-url https://rpc.coredao.org | cast keccak
cast code $M --rpc-url https://ethereum-rpc.publicnode.com | cast keccak
In our test both commands printed the same hash (0xd5c15df6…0891), so the runtime code on Core is identical to the canonical deployment. The Multicall3 repo’s deployments list also includes Core (chain 1116) with a Core Scan link.

Step 2: Batch reads with cast and aggregate3
aggregate3 takes an array of (address target, bool allowFailure, bytes callData) structs. It returns an array of (bool success, bytes returnData). Here we read USDT’s decimals and symbol, WCORE’s symbol, plus a junk call that is meant to fail:
USDT=0x900101d06A7426441Ae63e9AB3B9b0F63Be145F1
WCORE=0x40375C92d9FAf44d2f9db9Bd9ba41a3317a2404f
cast call $M "aggregate3((address,bool,bytes)[])((bool,bytes)[])" \
"[($USDT,true,$(cast calldata 'decimals()')),($USDT,true,$(cast calldata 'symbol()')),($WCORE,true,$(cast calldata 'symbol()')),($M,true,0xdeadbeef)]"
The output had four results. The first three were true and decoded to 6, "USDT" and "WCORE". The last was (false, 0x). Because allowFailure was true, the bad call simply reported failure. When we set allowFailure to false on the bad call, the whole batch reverted with execution reverted: Multicall3: call failed.
Multicall3 also has helper functions you can add to the batch, with the Multicall3 address itself as the target:
| Function | Returns | Result on Core (19 Nov 2026) |
|---|---|---|
getChainId() |
Chain ID | 1116 |
getBlockNumber() |
Current block | ~40.59 million |
getCurrentBlockTimestamp() |
Block time (Unix) | Works |
getCurrentBlockGasLimit() |
Block gas limit | 50,000,000 |
getEthBalance(address) |
Native CORE balance (wei) | Works |
getBasefee() |
Block base fee | 0 (Core blocks report baseFeePerGas 0) |
Note that getEthBalance returns the native coin balance. On Core that’s CORE, even though the function name says “Eth”.
Step 3: Use Multicall3 on Core with viem
viem’s coreDao chain definition already includes Multicall3. So publicClient.multicall works with no extra setup. Tested with viem 2.58.1:
import { createPublicClient, http, erc20Abi } from 'viem'
import { coreDao } from 'viem/chains'
const client = createPublicClient({ chain: coreDao, transport: http() })
const USDT = '0x900101d06A7426441Ae63e9AB3B9b0F63Be145F1'
const results = await client.multicall({
contracts: [
{ address: USDT, abi: erc20Abi, functionName: 'symbol' },
{ address: USDT, abi: erc20Abi, functionName: 'decimals' },
],
})
// [{ result: 'USDT', status: 'success' }, { result: 6, status: 'success' }]
By default viem uses allowFailure: true. A failed call comes back as { status: 'failure', error } and doesn’t throw. Always check status before you use result.
“Chain does not support contract multicall3”
viem stores the block where Multicall3 was created (blockCreated: 6_988_931 for Core in the current release). That matches the first block where we found code on Core’s archive RPC. If you pass a blockNumber older than that, viem throws ChainDoesNotSupportContract: Chain "Core Dao" does not support contract "multicall3". Before that block, the contract simply didn’t exist. Make those historical reads one by one instead. Use an archive endpoint such as rpcar.coredao.org for old blocks.
Step 4: Use Multicall3 with ethers v6
ethers v6 doesn’t have a built-in multicall helper. Call aggregate3 through a normal Contract and use staticCall. The function is marked payable, not view, so a plain call would try to send a transaction:
import { JsonRpcProvider, Contract, Interface } from 'ethers'
const provider = new JsonRpcProvider('https://rpc.coredao.org', 1116)
const mc = new Contract('0xcA11bde05977b3631167028862bE2a173976CA11', [
'function aggregate3((address target,bool allowFailure,bytes callData)[] calls) payable returns ((bool success,bytes returnData)[])'
], provider)
const erc20 = new Interface([
'function symbol() view returns (string)',
'function decimals() view returns (uint8)'
])
const USDT = '0x900101d06A7426441Ae63e9AB3B9b0F63Be145F1'
const res = await mc.aggregate3.staticCall([
{ target: USDT, allowFailure: true, callData: erc20.encodeFunctionData('symbol') },
{ target: USDT, allowFailure: true, callData: erc20.encodeFunctionData('decimals') },
])
// decode each res[i].returnData with erc20.decodeFunctionResult(...)
In our run this returned ['USDT', 6n] after decoding.
Common mistakes and how to avoid them
Never approve Multicall3 or send it funds
Multicall3 can batch writes too, but the README says it is unaudited. Its advice is that the contract should never hold your funds after a transaction and you should never approve Multicall3 to spend your tokens. Inside a batch, msg.sender is the Multicall3 contract, not your wallet. So batched token transfers wouldn’t come from your balance anyway. If you’ve approved it by mistake, see how to revoke token approvals.
Batches that are too big
The whole batch is a single eth_call, so it is limited by the RPC node’s gas cap for calls. Huge batches can fail even when each call is small. Split large lists into smaller chunks. viem does this for you: its batchSize option (measured in bytes of calldata) splits a long list into several Multicall3 calls.
Decoding failures as real values
A call to an address with no code can return success = true with empty data. A call to a missing function returns false. Check the target with cast codesize, and treat empty returnData as a failure in your own decoding.
Assuming the same address on Core Testnet
viem’s chain files list different Multicall3 addresses for Core’s testnets. For example, coreTestnet2 uses 0x3CB285ff3Cd5C7C7e570b1E7DE3De17A0f985e56. Check it on the testnet explorer before you rely on it. Better still, test against a local copy of mainnet. Our guide to forking Core mainnet with Anvil shows how, and Multicall3 is already present in the fork.
FAQ
What is the Multicall3 address on Core?
0xcA11bde05977b3631167028862bE2a173976CA11 on Core mainnet (chain ID 1116). It’s the same address used on Ethereum and most EVM chains, and the bytecode matched Ethereum’s in our check.
Does a Multicall3 read cost CORE?
No. Read-only batches go through eth_call, which runs on the node and isn’t broadcast, so no gas is paid. Only a real transaction to Multicall3 costs gas.
When was Multicall3 deployed on Core?
Our search of Core’s archive RPC found its code first at block 6,988,931, which has a timestamp of 9 September 2023 (UTC). That matches the blockCreated value in viem’s current Core chain definition.
Is aggregate3 better than aggregate?
Usually, yes. aggregate reverts if any call fails. aggregate3 lets you choose per call whether a failure should revert the batch, which is far more practical when reading many tokens.
Disclaimer: This article is for educational purposes only and is not financial or investment advice. Always verify contract addresses yourself and test on a fork or testnet before sending real transactions.
