> ## Documentation Index
> Fetch the complete documentation index at: https://docs.goldsky.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Fanout
> A premium Edge RPC tier that cross-checks every read against multiple independent upstreams and verifies each response with deep data-integrity checks before returning it
export const FanoutFlow = () => {
const GREEN = '#16A34A';
const GOLD = '#D97706';
const BLUE = '#2563EB';
const PURPLE = '#7C3AED';
const TEAL = '#0D9488';
const ORANGE = '#EA580C';
const BORDER = 'rgba(113,113,122,0.4)';
const LANES = [{
key: 'reads',
color: BLUE,
methods: 'eth_call · eth_getBalance · +7',
policy: 'quorum agrees',
nodes: 5,
accent: GREEN
}, {
key: 'logs',
color: PURPLE,
methods: 'eth_getLogs · eth_getBlockReceipts',
policy: 'largest wins',
nodes: 3,
accent: GREEN
}, {
key: 'fees',
color: TEAL,
methods: 'eth_gasPrice · +2',
policy: 'highest wins',
nodes: 4,
accent: GOLD
}, {
key: 'cast',
color: ORANGE,
methods: 'eth_sendRawTransaction',
policy: 'broadcast',
nodes: 6,
accent: GOLD
}];
const CHECKS = ['Structure & encoding', 'Commitments match', 'Per-item authenticity', 'Cross-block continuity'];
const [step, setStep] = useState(0);
const TOTAL = 7;
useEffect(() => {
const id = setInterval(() => setStep(p => (p + 1) % TOTAL), 900);
return () => clearInterval(id);
}, []);
const laneOk = step >= 1;
const checkOk = i => step >= i + 2;
const verified = step >= 6;
const laneY = [31, 71, 111, 151];
const nodeX0 = 72;
const gap = 9;
const policyX = 140;
const checkX = 224;
const checkW = 100;
return
;
};
export const FanoutCoverage = () => {
const GOLD = '#D97706';
const BORDER = 'rgba(17, 24, 39, 0.12)';
const MUTED = '#6B7280';
const CARD_BG = '#FCFCFB';
const [status, setStatus] = useState('loading');
const [error, setError] = useState('');
const [payload, setPayload] = useState(null);
const [expanded, setExpanded] = useState(() => new Set());
const [didInit, setDidInit] = useState(false);
const load = () => {
setStatus('loading');
setError('');
fetch(`${window.location.origin}/data/fanout-coverage.json?t=${Date.now()}`, {
cache: 'no-store'
}).then(r => {
if (!r.ok) throw new Error(`Could not load coverage (${r.status})`);
return r.json();
}).then(data => {
if (!data?.rows?.length) throw new Error('Coverage data is empty');
setPayload(data);
setStatus('ready');
}).catch(err => {
setStatus('error');
setError(err?.message || 'Failed to load');
});
};
useEffect(() => {
load();
}, []);
const COLOR = {
strict: '#2563EB',
larger: '#2563EB',
highest: '#0D9488',
broadcast: '#EA580C'
};
const RULE = {
strict: 'consensus',
larger: 'consensus',
highest: 'highest value',
broadcast: 'broadcast'
};
const LEGEND = [{
kind: 'consensus',
label: 'consensus',
color: COLOR.strict,
desc: 'The request goes to several independent upstreams; the answer is returned only when enough come back identical, so a lone wrong or stale node is outvoted.'
}, {
kind: 'highest',
label: 'highest value',
color: COLOR.highest,
desc: 'We query several upstreams and keep the highest, freshest value, so a stale, too-low one never sticks you.'
}, {
kind: 'broadcast',
label: 'broadcast',
color: COLOR.broadcast,
desc: 'We push it to every upstream in parallel for the widest, fastest propagation.'
}];
const ruleDiagram = (kind, color) => {
const fill = `${color}22`;
if (kind === 'consensus') {
const bad = '#DC2626';
const rows = [{
y: 16,
ok: true
}, {
y: 43,
ok: true
}, {
y: 70,
ok: false
}, {
y: 96,
ok: true
}];
return ;
}
if (kind === 'highest') {
const rows = [{
y: 16,
v: '11'
}, {
y: 43,
v: '9'
}, {
y: 70,
v: '14',
hi: true
}, {
y: 96,
v: '8'
}];
return ;
}
const gold = GOLD;
return ;
};
const CHECK = {
eth_call: 'Run on several independent upstreams; only returned when a supermajority come back with the exact same result.',
eth_getBalance: 'Cross-checked across upstreams; a supermajority must return the exact same balance.',
eth_getCode: 'A supermajority must return the exact same contract bytecode.',
eth_getStorageAt: 'A supermajority must return the exact same storage slot value.',
eth_getProof: 'A supermajority must agree on the account and storage proof.',
eth_getBlockByNumber: 'A supermajority must agree on the canonical block at that height.',
eth_getBlockByHash: 'A supermajority must agree on the block for that hash.',
eth_getTransactionByHash: 'A supermajority must agree on the transaction details.',
eth_getTransactionReceipt: 'A supermajority must agree on the receipt — status, gas used, and logs.',
eth_getLogs: 'Cross-checked across upstreams; a quorum must agree and the most complete log set wins, so silently dropped logs are caught.',
eth_getBlockReceipts: 'A quorum must agree, and the most complete set of receipts wins.',
eth_gasPrice: 'Fanned out to several upstreams, but gas price is a per-node estimate with no single correct value — so the highest, freshest price wins instead of a vote, and a stale, too-low quote never sticks you.',
eth_maxPriorityFeePerGas: 'A per-node estimate too: fanned out, and the highest priority fee returned wins — there is no canonical value to agree on.',
eth_getTransactionCount: 'Fanned out to several upstreams; the highest nonce wins, so a lagging node can’t hand back a stale, too-low value. Highest is the safe pick here, not a vote.',
eth_sendRawTransaction: 'A write, not a read: broadcast to every upstream in parallel for the widest, fastest propagation. Nothing to cross-check — the tx hash is fixed by the signed bytes.'
};
const ORDER = Object.keys(CHECK);
const methods = useMemo(() => {
if (!payload?.rows) return [];
const map = new Map();
for (const row of payload.rows) {
for (const name of row.matchMethod.split('|')) {
if (!map.has(name)) map.set(name, {
method: name,
policyType: row.policyType,
nets: new Map()
});
map.get(name).nets.set(row.chainId, {
alias: row.alias,
chainId: row.chainId,
agree: row.agreementThreshold,
fanout: row.maxParticipants
});
}
}
return [...map.values()].map(g => ({
method: g.method,
policyType: g.policyType,
color: COLOR[g.policyType] || MUTED,
check: CHECK[g.method] || '',
networks: [...g.nets.values()].sort((a, b) => b.fanout - a.fanout || b.agree - a.agree || a.alias.localeCompare(b.alias))
})).sort((a, b) => {
const ia = ORDER.indexOf(a.method);
const ib = ORDER.indexOf(b.method);
return (ia < 0 ? 99 : ia) - (ib < 0 ? 99 : ib);
});
}, [payload]);
const methodsByRule = useMemo(() => {
const m = {
consensus: [],
highest: [],
broadcast: []
};
for (const g of methods) {
const k = g.policyType === 'highest' ? 'highest' : g.policyType === 'broadcast' ? 'broadcast' : 'consensus';
m[k].push(g.method);
}
return m;
}, [methods]);
useEffect(() => {
if (!didInit && methods.length) {
setExpanded(new Set([methods[0].method]));
setDidInit(true);
}
}, [methods, didInit]);
const toggle = name => setExpanded(prev => {
const next = new Set(prev);
next.has(name) ? next.delete(name) : next.add(name);
return next;
});
const HIGHEST_TERM = {
eth_gasPrice: 'gas price',
eth_maxPriorityFeePerGas: 'priority fee',
eth_getTransactionCount: 'nonce'
};
const ruleSentence = (policyType, method, n) => {
const X = v => {v};
if (policyType === 'highest') return <>Highest {HIGHEST_TERM[method] || 'value'} among {X(n.fanout)} nodes;
if (policyType === 'broadcast') return <>Fastest propagation among {X(n.fanout)} nodes;
return <>{X(n.agree)} nodes fully agree;
};
const AVATAR_COLORS = ['#2563EB', '#0D9488', '#EA580C', '#7C3AED', '#DB2777', '#0E7490', '#D97706', '#DC2626'];
const avatar = alias => {
const s = alias || '?';
let h = 0;
for (let i = 0; i < s.length; i++) h = h * 31 + s.charCodeAt(i) >>> 0;
const c = AVATAR_COLORS[h % AVATAR_COLORS.length];
return {s[0]};
};
if (status === 'loading') {
return
;
};
Built for workloads that can't tolerate a wrong answer: DeFi, AI agents, accounting. A stale, buggy, or manipulated upstream is outvoted rather than served, and a genuine disagreement is returned as an error instead of a guess.
The Fanout tier is available on request. [Contact us](https://cal.com/team/goldsky/website-intro) or email [sales@goldsky.com](mailto:sales@goldsky.com) and we'll get you set up.
## Checks & coverage
The methods below are fanned out to multiple independent upstreams (the standard tier tries one at a time). How the answer is settled depends on the method; expand any one to see it per network.
## Under the hood
The tier layers two independent protections: **cross-source consensus** and per-response **data-integrity checks**.
For reads with one canonical answer (state, blocks, logs, receipts), consensus sends the request to several independent upstreams in parallel via eRPC's [consensus failsafe](https://docs.erpc.cloud/config/failsafe/consensus) and only returns a value once a quorum agrees. Fields that legitimately differ between client implementations (block timestamps, L1 metadata) are ignored, so only meaningful disagreements count. When sources genuinely disagree it returns an error rather than guessing, routing around any upstream that returned wrong data. The quorum isn't hand-tuned: it's sized per network from how many independent upstreams it actually has.
Not everything has a single right answer to vote on. Gas price and priority-fee estimates are computed locally by each node, and `eth_sendRawTransaction` is a write, not a read. So the tier still **fans these out to multiple upstreams**, but applies the rule that fits: it keeps the **highest** value for `eth_gasPrice` / `eth_maxPriorityFeePerGas` / `eth_getTransactionCount` (so a stale, too-low estimate can't stick you), and **broadcasts** `eth_sendRawTransaction` to every upstream in parallel for the widest, fastest propagation.
Independently of agreement, every response runs through eRPC's data-integrity checks:
| Check | What it verifies |
| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Structure, shape & encoding** | The response is well-formed and complete: correct structure, field shapes, and hex/RLP encoding. |
| **Block tags & ranges** | `latest` resolves to the highest block the network has (not a lagging node's view), tagged blocks are never null, and `eth_getLogs` stays within its requested range. |
| **Receipt integrity** | Receipts carry the correct logs bloom, item counts, and index contiguity. |
| **Commitment recompute** | State and receipt roots and block hashes are recomputed from the response and must match. |
| **Per-item authenticity** | Every transaction, receipt, and log is verified individually against its commitment. |
| **Cross-block continuity** | Blocks chain correctly: parent hashes and numbers line up across the requested range. |
| **Authoritative fetch** | Anything that can't be confirmed from data already on hand is force-fetched from an authoritative upstream and compared. |
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
## Related topics
- [S2](/turbo-pipelines/sinks/s2.md)