> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sei.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Multicall

> Batch multiple contract reads into a single RPC call using Multicall3 on Sei

export const RunSnippet = props => {
  const {method = 'eth_blockNumber', params = [], network = 'testnet', endpoint, label, title, description, decode = 'auto'} = props || ({});
  const ENDPOINTS = {
    testnet: 'https://evm-rpc-testnet.sei-apis.com',
    mainnet: 'https://evm-rpc.sei-apis.com'
  };
  const rpcUrl = endpoint || ENDPOINTS[network] || ENDPOINTS.testnet;
  const networkLabel = network === 'mainnet' ? 'pacific-1 · mainnet' : network === 'testnet' ? 'atlantic-2 · testnet' : network;
  const requestBody = {
    jsonrpc: '2.0',
    id: 1,
    method,
    params
  };
  const requestJson = JSON.stringify(requestBody, null, 2);
  const [phase, setPhase] = useState('idle');
  const [result, setResult] = useState(null);
  const [errorMsg, setErrorMsg] = useState(null);
  const [elapsed, setElapsed] = useState(null);
  const [copied, setCopied] = useState(false);
  const [btnHover, setBtnHover] = useState(false);
  const groupThousands = s => s.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  const hexToDecimal = value => {
    if (typeof value !== 'string' || !(/^0x[0-9a-fA-F]+$/).test(value)) return null;
    if (value.length > 66) return null;
    try {
      return groupThousands(BigInt(value).toString(10));
    } catch (e) {
      return null;
    }
  };
  const run = async () => {
    setPhase('loading');
    setErrorMsg(null);
    setResult(null);
    setElapsed(null);
    const startedAt = typeof performance !== 'undefined' ? performance.now() : null;
    try {
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestBody)
      });
      const data = await response.json();
      if (startedAt != null && typeof performance !== 'undefined') {
        setElapsed(Math.round(performance.now() - startedAt));
      }
      if (data && data.error) {
        setErrorMsg(data.error.message || 'RPC returned an error');
        setPhase('error');
        return;
      }
      setResult(data ? data.result : undefined);
      setPhase('success');
    } catch (err) {
      setErrorMsg(err && err.message ? err.message : 'Request failed');
      setPhase('error');
    }
  };
  const resultString = result === undefined ? 'undefined' : JSON.stringify(result, null, 2);
  const decoded = decode !== 'off' && typeof result === 'string' ? hexToDecimal(result) : null;
  const copyResult = () => {
    const flashCopied = () => {
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    };
    if (typeof navigator !== 'undefined' && navigator.clipboard && navigator.clipboard.writeText) {
      navigator.clipboard.writeText(resultString).then(flashCopied, () => {});
      return;
    }
    if (typeof document !== 'undefined') {
      try {
        const ta = document.createElement('textarea');
        ta.value = resultString;
        ta.style.position = 'fixed';
        ta.style.opacity = '0';
        document.body.appendChild(ta);
        ta.select();
        document.execCommand('copy');
        document.body.removeChild(ta);
        flashCopied();
      } catch (e) {}
    }
  };
  const HAIRLINE = 'rgba(128, 128, 128, 0.25)';
  const surfaceStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.08)'
  };
  const monoStyle = {
    fontFamily: 'var(--sei-font-mono)'
  };
  const codeStyle = {
    backgroundColor: 'rgba(128, 128, 128, 0.05)',
    fontFamily: 'var(--sei-font-mono)'
  };
  const cardClass = 'not-prose w-full rounded-lg border overflow-hidden my-4';
  const headerClass = 'flex items-center justify-between gap-3 px-4 py-2.5 border-b';
  const labelClass = 'text-xs uppercase tracking-wide text-neutral-500 dark:text-neutral-500';
  const preClass = 'm-0 px-4 py-3 text-sm overflow-x-auto text-neutral-700 dark:text-neutral-300';
  const buttonStyle = {
    backgroundColor: btnHover ? 'var(--sei-maroon-200)' : 'var(--sei-maroon-100)',
    color: '#ffffff',
    fontFamily: 'var(--sei-font-mono)',
    textTransform: 'uppercase',
    letterSpacing: '0.04em',
    fontSize: '10px',
    opacity: phase === 'loading' ? 0.7 : 1,
    cursor: phase === 'loading' ? 'default' : 'pointer'
  };
  return <div className={cardClass} style={{
    borderColor: HAIRLINE
  }}>
			<div className={headerClass} style={{
    ...surfaceStyle,
    borderBottomColor: HAIRLINE
  }}>
				<div className="flex flex-col min-w-0">
					<span className="text-sm font-medium text-neutral-900 dark:text-white truncate" style={monoStyle}>
						{title || method}
					</span>
					<span className="text-xs text-neutral-500 dark:text-neutral-500">{networkLabel}</span>
				</div>
				<button type="button" onClick={run} disabled={phase === 'loading'} onMouseEnter={() => setBtnHover(true)} onMouseLeave={() => setBtnHover(false)} className="inline-flex items-center gap-1.5 px-3 py-1.5 shrink-0 transition-colors" style={buttonStyle}>
					{phase === 'loading' ? <svg className="animate-spin h-4 w-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
								<circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
								<path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 0 1 8-8v4a4 4 0 0 0-4 4H4z" />
							</svg> : <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
								<path d="M8 5v14l11-7z" />
							</svg>}
					{phase === 'loading' ? 'Running…' : label || 'Run'}
				</button>
			</div>

			{description ? <div className="px-4 pt-3 text-sm text-neutral-600 dark:text-neutral-400">{description}</div> : null}

			<div className="px-4 pt-3 pb-1">
				<span className={labelClass}>Request</span>
			</div>
			<pre className={preClass} style={codeStyle}>
				{requestJson}
			</pre>

			{phase === 'success' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="flex items-center justify-between px-4 pt-3 pb-1">
						<span className={labelClass}>Response{elapsed != null ? ` · ${elapsed} ms` : ''}</span>
						<button type="button" onClick={copyResult} className="text-xs text-neutral-500 hover:text-neutral-800 dark:text-neutral-400 dark:hover:text-neutral-200 transition-colors">
							{copied ? 'Copied' : 'Copy'}
						</button>
					</div>
					<pre className={preClass} style={codeStyle}>
						{resultString}
					</pre>
					{decoded ? <div className="px-4 pb-3 text-xs text-neutral-500 dark:text-neutral-500" style={monoStyle}>
							= {decoded} (decimal)
						</div> : null}
				</div> : null}

			{phase === 'error' ? <div className="border-t" style={{
    borderTopColor: HAIRLINE
  }}>
					<div className="px-4 pt-3 pb-1">
						<span className={labelClass}>Error</span>
					</div>
					<pre className={`${preClass} text-red-600 dark:text-red-400`} style={codeStyle}>
						{errorMsg}
					</pre>
				</div> : null}
		</div>;
};

# Multicall

Multicall3 lets you batch multiple read calls into a single RPC round-trip, dramatically reducing latency for dashboards, portfolio pages, and any view that needs data from multiple contracts at once.

Multicall3 is deployed at `0xcA11bde05977b3631167028862bE2a173976CA11` on Sei mainnet and testnet — the same address as Ethereum.

## Try it live

Multicall3 is a normal contract — you can hit it with a single `eth_call` and no SDK. These run its two zero-argument helpers on Sei mainnet; the hex results decode to decimal below each response.

<RunSnippet method="eth_call" params={[{ to: '0xcA11bde05977b3631167028862bE2a173976CA11', data: '0x42cbb15c' }, 'latest']} network="mainnet" title="Multicall3.getBlockNumber()" description="Selector 0x42cbb15c on Multicall3 at 0xcA11…CA11 — returns the current block number." />

<RunSnippet method="eth_call" params={[{ to: '0xcA11bde05977b3631167028862bE2a173976CA11', data: '0x0f28c97d' }, 'latest']} network="mainnet" title="Multicall3.getCurrentBlockTimestamp()" description="Selector 0x0f28c97d — returns the latest block's Unix timestamp in seconds." />

## Batching ERC-20 Reads with viem

viem's `multicall` action wraps Multicall3 automatically:

```ts theme={"dark"}
import { createPublicClient, http, parseAbi } from 'viem';
import { sei } from 'viem/chains';

const client = createPublicClient({ chain: sei, transport: http() });

const ERC20_ABI = parseAbi([
  'function balanceOf(address owner) view returns (uint256)',
  'function symbol() view returns (string)',
  'function decimals() view returns (uint8)',
]);

const tokens = [
  '0xTokenA',
  '0xTokenB',
  '0xTokenC',
] as const;

const owner = '0xYourAddress';

// Fetch symbol, decimals, and balance for every token in one call
const results = await client.multicall({
  contracts: tokens.flatMap((address) => [
    { address, abi: ERC20_ABI, functionName: 'symbol' },
    { address, abi: ERC20_ABI, functionName: 'decimals' },
    { address, abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] },
  ]),
});

// Results are returned in the same order as the input contracts array
// Each result has { status: 'success' | 'failure', result, error }
tokens.forEach((address, i) => {
  const symbol  = results[i * 3];
  const decimals = results[i * 3 + 1];
  const balance  = results[i * 3 + 2];

  if (symbol.status === 'success' && balance.status === 'success') {
    console.log(`${address}: ${balance.result} (${symbol.result})`);
  }
});
```

## Allowing Individual Call Failures

By default, a single failed call causes the entire batch to revert. Use `allowFailure: true` (the default in viem) to get partial results instead:

```ts theme={"dark"}
const results = await client.multicall({
  contracts: [
    { address: '0xTokenA', abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] },
    { address: '0xMaybeInvalid', abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] },
  ],
  allowFailure: true, // default — individual failures don't abort the batch
});

results.forEach((result) => {
  if (result.status === 'success') {
    console.log('Balance:', result.result);
  } else {
    console.warn('Call failed:', result.error);
  }
});
```

## Batching with ethers

ethers doesn't have a built-in multicall action, but you can call the Multicall3 contract directly:

```ts theme={"dark"}
import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://evm-rpc.sei-apis.com');

const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
const MULTICALL3_ABI = [
  'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) view returns (tuple(bool success, bytes returnData)[] returnData)',
];

const multicall = new ethers.Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);

const ERC20_INTERFACE = new ethers.Interface([
  'function balanceOf(address owner) view returns (uint256)',
]);

const owner = '0xYourAddress';
const tokens = ['0xTokenA', '0xTokenB', '0xTokenC'];

const calls = tokens.map((target) => ({
  target,
  allowFailure: true,
  callData: ERC20_INTERFACE.encodeFunctionData('balanceOf', [owner]),
}));

const results = await multicall.aggregate3(calls);

results.forEach(({ success, returnData }: { success: boolean; returnData: string }, i: number) => {
  if (success) {
    const [balance] = ERC20_INTERFACE.decodeFunctionResult('balanceOf', returnData);
    console.log(`${tokens[i]}: ${balance}`);
  }
});
```

## Wagmi

In React apps, `useReadContracts` handles batching automatically:

```tsx theme={"dark"}
import { useReadContracts } from 'wagmi';
import { parseAbi } from 'viem';

const ERC20_ABI = parseAbi([
  'function balanceOf(address owner) view returns (uint256)',
  'function symbol() view returns (string)',
]);

const TOKEN_A = '0xTokenA' as const;
const TOKEN_B = '0xTokenB' as const;
const owner   = '0xYourAddress' as const;

export function MultiTokenBalances() {
  const { data } = useReadContracts({
    contracts: [
      { address: TOKEN_A, abi: ERC20_ABI, functionName: 'symbol' },
      { address: TOKEN_A, abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] },
      { address: TOKEN_B, abi: ERC20_ABI, functionName: 'symbol' },
      { address: TOKEN_B, abi: ERC20_ABI, functionName: 'balanceOf', args: [owner] },
    ],
  });

  if (!data) return null;

  return (
    <ul>
      <li>{data[0].result}: {data[1].result?.toString()}</li>
      <li>{data[2].result}: {data[3].result?.toString()}</li>
    </ul>
  );
}
```