> ## 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 [dark, setDark] = useState(true);
  useEffect(() => {
    const root = document.documentElement;
    const update = () => setDark(root.classList.contains('dark'));
    update();
    const obs = new MutationObserver(update);
    obs.observe(root, {
      attributes: true,
      attributeFilter: ['class']
    });
    return () => obs.disconnect();
  }, []);
  const P = dark ? {
    accent: '#FFAD33',
    onAccent: '#1B1205',
    ok: '#22C55E',
    onOk: '#052E16',
    dim: '#3F3F46',
    label: '#A1A1AA',
    text: '#E4E4E7'
  } : {
    accent: '#FFAD33',
    onAccent: '#1B1205',
    ok: '#22C55E',
    onOk: '#052E16',
    dim: '#D4D4D8',
    label: '#71717A',
    text: '#3F3F46'
  };
  const LANES = [{
    key: 'reads',
    methods: 'eth_call · eth_getBalance · +7',
    policy: 'quorum agrees',
    nodes: 5
  }, {
    key: 'logs',
    methods: 'eth_getLogs · eth_getBlockReceipts',
    policy: 'largest wins',
    nodes: 3
  }, {
    key: 'fees',
    methods: 'eth_gasPrice · +2',
    policy: 'highest wins',
    nodes: 4
  }, {
    key: 'cast',
    methods: 'eth_sendRawTransaction',
    policy: 'broadcast',
    nodes: 6
  }];
  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 HUB_X = 84;
  const MID_Y = 100;
  const laneY = [31, 77, 123, 169];
  const laneX = 144;
  const dotR = 5.5;
  const dotGap = 15;
  const policyRight = 324;
  const funnelX = 336;
  const boxX = 414;
  const boxW = 162;
  const boxY = 44;
  const boxH = 112;
  const PAD = 16;
  const rowY = i => 82 + i * 20;
  const pillCX = boxX + boxW / 2;
  const pillY = 168;
  const pillH = 28;
  const lane = y => `M ${HUB_X} ${MID_Y} C 112 ${MID_Y}, 116 ${y}, ${laneX} ${y}`;
  const funnel = y => `M ${funnelX} ${y} C 368 ${y}, 382 ${MID_Y}, ${boxX} ${MID_Y}`;
  const tick = (cx, cy, s) => `M ${cx - 2.4 * s} ${cy} l ${1.8 * s} ${1.8 * s} l ${3.2 * s} ${-3.6 * s}`;
  return <div className="not-prose my-8">
      <svg viewBox="0 0 620 204" width="100%" xmlns="http://www.w3.org/2000/svg">
        {}
        <rect x="8" y="82" width="76" height="36" rx="8" fill="none" stroke={P.dim} strokeWidth="1" />
        <text x="46" y="104" textAnchor="middle" fill={P.text} style={{
    fontSize: '10.5px'
  }}>request</text>

        {}
        {LANES.map((l, li) => {
    const y = laneY[li];
    const ok = laneOk;
    return <g key={l.key}>
              <path d={lane(y)} fill="none" stroke={ok ? P.accent : P.dim} strokeWidth={ok ? '1.4' : '1'} style={{
      transition: 'stroke .3s, stroke-width .3s'
    }} />
              <text x={laneX} y={y - 14} fill={P.label} fontFamily="monospace" style={{
      fontSize: '9.5px'
    }}>{l.methods}</text>
              {Array.from({
      length: l.nodes
    }).map((_, ni) => <circle key={ni} cx={laneX + dotR + ni * dotGap} cy={y} r={dotR} fill={ok ? P.accent : P.dim} style={{
      transition: 'fill .3s'
    }} />)}
              {}
              <text x={policyRight} y={y + 3.8} textAnchor="end" fill={ok ? P.text : P.label} style={{
      fontSize: '10.5px',
      transition: 'fill .3s'
    }}>{l.policy}</text>
              <path d={funnel(y)} fill="none" stroke={ok ? P.accent : P.dim} strokeWidth="1" style={{
      transition: 'stroke .3s'
    }} />
            </g>;
  })}

        {}
        <rect x={boxX} y={boxY} width={boxW} height={boxH} rx="8" fill="none" stroke={P.dim} strokeWidth="1" />
        <text x={boxX + PAD} y="62" fill={P.label} style={{
    fontSize: '9.5px'
  }}>data-integrity checks</text>
        {CHECKS.map((c, i) => {
    const cy = rowY(i);
    const ok = checkOk(i);
    return <g key={c}>
              <circle cx={boxX + PAD + 5} cy={cy} r="5" fill={ok ? P.ok : 'none'} stroke={ok ? P.ok : P.dim} strokeWidth="1" style={{
      transition: 'fill .3s, stroke .3s'
    }} />
              {ok && <path d={tick(boxX + PAD + 5, cy, 1)} fill="none" stroke={P.onOk} strokeWidth="1.4" strokeLinecap="round" strokeLinejoin="round" />}
              <text x={boxX + PAD + 19} y={cy + 3.6} fill={ok ? P.text : P.label} style={{
      fontSize: '10.5px',
      transition: 'fill .3s'
    }}>{c}</text>
            </g>;
  })}

        {}
        <line x1={pillCX} y1={boxY + boxH} x2={pillCX} y2={pillY} stroke={verified ? P.ok : P.dim} strokeWidth="1.4" style={{
    transition: 'stroke .3s'
  }} />
        <rect x={pillCX - 44} y={pillY} width="88" height={pillH} rx="8" fill={verified ? P.ok : 'none'} stroke={verified ? 'none' : P.dim} strokeWidth="1" style={{
    transition: 'fill .3s, stroke .3s'
  }} />
        {verified && <path d={tick(467, pillY + pillH / 2, 1.5)} fill="none" stroke={P.onOk} strokeWidth="1.9" strokeLinecap="round" strokeLinejoin="round" />}
        <text x={verified ? 479 : pillCX} y={pillY + pillH / 2 + 3.9} textAnchor={verified ? 'start' : 'middle'} fill={verified ? P.onOk : P.label} style={{
    fontSize: '11px',
    fontWeight: 600
  }}>verified</text>
      </svg>
    </div>;
};

export const FanoutDiagram = ({kind}) => {
  const [dark, setDark] = useState(true);
  useEffect(() => {
    const root = document.documentElement;
    const update = () => setDark(root.classList.contains("dark"));
    update();
    const obs = new MutationObserver(update);
    obs.observe(root, {
      attributes: true,
      attributeFilter: ["class"]
    });
    return () => obs.disconnect();
  }, []);
  const P = dark ? {
    accent: "#FFAD33",
    onAccent: "#1B1205",
    muted: "#A1A1AA",
    faint: "#71717A",
    border: "rgba(255,255,255,0.10)",
    line: "rgba(255,255,255,0.22)",
    chip: "rgba(255,255,255,0.06)",
    danger: "#F87171"
  } : {
    accent: "#FFAD33",
    onAccent: "#1B1205",
    muted: "#52525B",
    faint: "#A1A1AA",
    border: "rgba(9,9,11,0.10)",
    line: "rgba(9,9,11,0.20)",
    chip: "rgba(9,9,11,0.05)",
    danger: "#DC2626"
  };
  const MONO = "ui-monospace, SFMono-Regular, Menlo, monospace";
  const CHIP = {
    fontSize: "11px",
    fontWeight: 500,
    color: P.muted,
    background: P.chip,
    borderRadius: "6px",
    padding: "3px 8px",
    whiteSpace: "nowrap",
    fontFamily: MONO
  };
  const [tags, setTags] = useState([]);
  useEffect(() => {
    const origin = window.location.hostname === "localhost" ? "https://docs.goldsky.com" : window.location.origin;
    fetch(`${origin}/data/fanout-coverage.json?t=${Date.now()}`, {
      cache: "no-store"
    }).then(r => r.ok ? r.json() : null).then(data => {
      if (!data?.rows) return;
      const names = new Set();
      for (const row of data.rows) {
        const rule = row.policyType === "highest" ? "highest" : row.policyType === "broadcast" ? "broadcast" : "consensus";
        if (rule === kind) for (const n of row.matchMethod.split("|")) names.add(n);
      }
      setTags([...names]);
    }).catch(() => {});
  }, [kind]);
  const diagram = () => {
    const box = {
      rx: 6,
      strokeWidth: 1.25
    };
    const hex = {
      fontSize: 12,
      fontFamily: MONO
    };
    const num = {
      fontSize: 12,
      style: {
        fontVariantNumeric: "tabular-nums"
      }
    };
    const source = label => <g>
        <rect x="8" y="42" width="52" height="28" rx="6" fill={P.chip} />
        <text x="34" y="60" textAnchor="middle" fill={P.muted} fontSize="12">
          {label}
        </text>
      </g>;
    if (kind === "consensus") {
      const rows = [{
        y: 15,
        ok: true
      }, {
        y: 43,
        ok: true
      }, {
        y: 71,
        ok: false
      }, {
        y: 99,
        ok: true
      }];
      return <svg viewBox="0 0 640 112" width="100%" style={{
        display: "block"
      }} aria-hidden="true">
          {source("call")}
          {rows.map((r, i) => <g key={i}>
              <line x1="60" y1="56" x2="232" y2={r.y} stroke={r.ok ? P.line : P.danger} strokeWidth={box.strokeWidth} strokeDasharray={r.ok ? undefined : "3 3"} />
              <rect x="232" y={r.y - 12} width="104" height="24" rx={box.rx} fill="none" stroke={r.ok ? P.border : P.danger} strokeWidth={box.strokeWidth} />
              <text x="284" y={r.y + 4} textAnchor="middle" fill={r.ok ? P.muted : P.danger} {...hex}>
                {r.ok ? "0x1a3f" : "0x9c2b"}
              </text>
              {r.ok ? <line x1="336" y1={r.y} x2="528" y2="56" stroke={P.line} strokeWidth={box.strokeWidth} /> : <path d={`M348 ${r.y - 4} l8 8 M356 ${r.y - 4} l-8 8`} stroke={P.danger} strokeWidth="1.5" strokeLinecap="round" fill="none" />}
            </g>)}
          <rect x="528" y="42" width="104" height="28" rx={box.rx} fill={P.accent} />
          <text x="580" y="60" textAnchor="middle" fill={P.onAccent} fontWeight="600" {...hex}>
            0x1a3f
          </text>
        </svg>;
    }
    if (kind === "highest") {
      const rows = [{
        y: 15,
        v: "11"
      }, {
        y: 43,
        v: "9"
      }, {
        y: 71,
        v: "14",
        hi: true
      }, {
        y: 99,
        v: "8"
      }];
      return <svg viewBox="0 0 640 112" width="100%" style={{
        display: "block"
      }} aria-hidden="true">
          {source("fee")}
          {rows.map((r, i) => <g key={i}>
              <line x1="60" y1="56" x2="232" y2={r.y} stroke={P.line} strokeWidth={box.strokeWidth} />
              <rect x="232" y={r.y - 12} width="72" height="24" rx={box.rx} fill={r.hi ? P.accent : "none"} stroke={r.hi ? "none" : P.border} strokeWidth={box.strokeWidth} />
              <text x="268" y={r.y + 4} textAnchor="middle" fill={r.hi ? P.onAccent : P.faint} fontWeight={r.hi ? 600 : 400} {...num}>
                {r.v}
              </text>
              {r.hi && <line x1="304" y1={r.y} x2="528" y2="56" stroke={P.accent} strokeWidth="1.75" />}
            </g>)}
          <rect x="528" y="42" width="72" height="28" rx={box.rx} fill={P.accent} />
          <text x="564" y="60" textAnchor="middle" fill={P.onAccent} fontWeight="600" {...num}>
            14
          </text>
        </svg>;
    }
    if (kind !== "broadcast") return null;
    const nodes = [12, 30, 48, 66, 84, 102];
    const first = 2;
    return <svg viewBox="0 0 640 112" width="100%" style={{
      display: "block"
    }} aria-hidden="true">
        {source("tx")}
        {nodes.map((y, i) => <g key={i}>
            <line x1="60" y1="56" x2="328" y2={y} stroke={i === first ? P.accent : P.line} strokeWidth={i === first ? 1.5 : box.strokeWidth} />
            <circle cx="336" cy={y} r="7" fill={i === first ? P.accent : P.line} />
          </g>)}
        <line x1="344" y1={nodes[first]} x2="528" y2="56" stroke={P.accent} strokeWidth="1.75" />
        <rect x="528" y="42" width="104" height="28" rx={box.rx} fill={P.accent} />
        <text x="580" y="60" textAnchor="middle" fill={P.onAccent} fontWeight="600" {...hex}>
          0x7d2e
        </text>
        <text x="580" y="84" textAnchor="middle" fill={P.muted} fontSize="11">
          Fastest response
        </text>
      </svg>;
  };
  return <div className="not-prose my-6">
      {diagram()}
      {tags.length > 0 && <div style={{
    display: "flex",
    flexWrap: "wrap",
    gap: "6px",
    marginTop: "14px"
  }}>
          {tags.map(m => <code key={m} style={CHIP}>
              {m}
            </code>)}
        </div>}
    </div>;
};

export const FanoutCoverage = ({kind, synced}) => {
  const [dark, setDark] = useState(true);
  useEffect(() => {
    const root = document.documentElement;
    const update = () => setDark(root.classList.contains("dark"));
    update();
    const obs = new MutationObserver(update);
    obs.observe(root, {
      attributes: true,
      attributeFilter: ["class"]
    });
    return () => obs.disconnect();
  }, []);
  const P = dark ? {
    ok: "#22C55E",
    text: "#F4F4F5",
    muted: "#A1A1AA",
    faint: "#71717A",
    border: "rgba(255,255,255,0.10)",
    card: "rgba(255,255,255,0.03)",
    chip: "rgba(255,255,255,0.06)",
    hover: "rgba(255,255,255,0.04)",
    track: "rgba(255,255,255,0.14)",
    danger: "#F87171",
    lift: "inset 0 1px 0 rgba(255,255,255,0.05)"
  } : {
    ok: "#22C55E",
    text: "#18181B",
    muted: "#52525B",
    faint: "#A1A1AA",
    border: "rgba(9,9,11,0.10)",
    card: "#FFFFFF",
    chip: "rgba(9,9,11,0.05)",
    hover: "rgba(9,9,11,0.025)",
    track: "rgba(9,9,11,0.12)",
    danger: "#DC2626",
    lift: "0 1px 2px rgba(16,24,40,0.04), 0 1px 3px rgba(16,24,40,0.05)"
  };
  const MONO = "ui-monospace, SFMono-Regular, Menlo, monospace";
  const CARD = {
    border: `1px solid ${P.border}`,
    borderRadius: "12px",
    background: P.card,
    boxShadow: P.lift
  };
  const CHIP = {
    fontSize: "11px",
    fontWeight: 500,
    color: P.muted,
    background: P.chip,
    borderRadius: "6px",
    padding: "3px 8px",
    whiteSpace: "nowrap"
  };
  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 [hovered, setHovered] = useState(null);
  const load = () => {
    setStatus("loading");
    setError("");
    fetch(`${window.location.hostname === "localhost" ? "https://docs.goldsky.com" : 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 ruleOf = policyType => policyType === "highest" ? "highest" : policyType === "broadcast" ? "broadcast" : "consensus";
  const RULE = {
    strict: "Consensus",
    larger: "Consensus",
    highest: "Highest value",
    broadcast: "Broadcast"
  };
  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. A node that has fallen behind quotes a price too low to get your transaction mined.",
    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, and the highest nonce wins. A node that has not yet seen your latest transaction reports a nonce too low to use, and the next transaction would be rejected as a duplicate. 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, and the first upstream to answer is the response you get. There is nothing to cross-check, since 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()].filter(g => !kind || ruleOf(g.policyType) === kind).map(g => ({
      method: g.method,
      policyType: g.policyType,
      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, kind]);
  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 quorum = (policyType, n) => policyType === "highest" || policyType === "broadcast" ? {
    filled: n.fanout,
    label: policyType === "highest" ? `highest of ${n.fanout}` : `all ${n.fanout}`
  } : {
    filled: n.agree,
    label: `${n.agree} of ${n.fanout} agree`
  };
  const pips = (filled, total) => <span style={{
    display: "inline-flex",
    gap: "3px",
    flex: "none"
  }} aria-hidden="true">
      {Array.from({
    length: total
  }).map((_, i) => <span key={i} style={{
    width: "4px",
    height: "12px",
    borderRadius: "2px",
    background: i < filled ? P.ok : P.track
  }} />)}
    </span>;
  const chevron = open => <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.75" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true" style={{
    flex: "none",
    color: P.faint,
    transform: open ? "rotate(90deg)" : "none",
    transition: "transform 150ms cubic-bezier(0.2, 0, 0, 1)"
  }}>
      <path d="M9 6l6 6-6 6" />
    </svg>;
  if (status === "loading") {
    return <div className="not-prose my-8" style={{
      ...CARD,
      padding: "20px"
    }}>
        <div style={{
      fontSize: "13px",
      color: P.muted
    }}>
          Loading coverage…
        </div>
      </div>;
  }
  if (status === "error") {
    return <div className="not-prose my-8" style={{
      ...CARD,
      padding: "20px",
      display: "flex",
      flexDirection: "column",
      alignItems: "flex-start",
      gap: "12px"
    }}>
        <p style={{
      color: P.danger,
      fontSize: "13px",
      margin: 0
    }}>{error}</p>
        <button type="button" onClick={load} style={{
      ...CHIP,
      color: P.text,
      cursor: "pointer",
      border: "none",
      padding: "5px 10px"
    }}>
          Retry
        </button>
      </div>;
  }
  return <div className="not-prose my-8">
      <div style={{
    display: "flex",
    flexDirection: "column",
    gap: "10px"
  }}>
        {methods.map(g => {
    const isOpen = expanded.has(g.method);
    return <div key={g.method} style={{
      ...CARD,
      overflow: "hidden"
    }}>
              <button type="button" onClick={() => toggle(g.method)} onMouseEnter={() => setHovered(g.method)} onMouseLeave={() => setHovered(h => h === g.method ? null : h)} aria-expanded={isOpen} style={{
      width: "100%",
      textAlign: "left",
      background: hovered === g.method ? P.hover : "transparent",
      border: "none",
      cursor: "pointer",
      color: "inherit",
      padding: "14px 16px",
      display: "flex",
      flexDirection: "column",
      gap: "8px",
      transitionProperty: "background-color",
      transitionDuration: "150ms",
      transitionTimingFunction: "cubic-bezier(0.2, 0, 0, 1)"
    }}>
                <div style={{
      display: "flex",
      alignItems: "center",
      gap: "10px"
    }}>
                  <code style={{
      fontFamily: MONO,
      fontSize: "14px",
      fontWeight: 600,
      color: P.text
    }}>
                    {g.method}
                  </code>
                  <span style={CHIP}>{RULE[g.policyType] || "consensus"}</span>
                  <span style={{
      marginLeft: "auto",
      display: "flex",
      alignItems: "center",
      gap: "8px"
    }}>
                    <span style={{
      fontSize: "12px",
      color: P.faint,
      fontVariantNumeric: "tabular-nums"
    }}>
                      {g.networks.length} networks
                    </span>
                    {chevron(isOpen)}
                  </span>
                </div>
                <div style={{
      fontSize: "13px",
      color: P.muted,
      lineHeight: 1.5,
      textWrap: "pretty"
    }}>
                  {g.check}
                </div>
              </button>

              {isOpen && <div>
                  {g.networks.map(n => {
      const q = quorum(g.policyType, n);
      return <div key={n.chainId} title={`chain ${n.chainId}`} style={{
        display: "flex",
        alignItems: "center",
        gap: "12px",
        padding: "9px 16px",
        borderTop: `1px solid ${P.border}`
      }}>
                        <span style={{
        flex: 1,
        minWidth: 0,
        fontSize: "13px",
        color: P.text,
        whiteSpace: "nowrap",
        overflow: "hidden",
        textOverflow: "ellipsis"
      }}>
                          {n.alias}
                        </span>
                        <span style={{
        flex: "none",
        width: "104px",
        textAlign: "right",
        fontSize: "12px",
        color: P.muted,
        fontVariantNumeric: "tabular-nums"
      }}>
                          {q.label}
                        </span>
                        {pips(q.filled, n.fanout)}
                      </div>;
    })}
                </div>}
            </div>;
  })}
      </div>

      {synced && payload?.meta && <p style={{
    marginTop: "14px",
    fontSize: "12px",
    color: P.faint,
    fontVariantNumeric: "tabular-nums"
  }}>
          {payload.meta.networkCount} networks · synced from the live Edge
          config on{" "}
          {new Date(payload.meta.syncedAt).toLocaleDateString("en-US", {
    day: "numeric",
    month: "short",
    year: "numeric"
  })}
        </p>}
    </div>;
};

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.

### Consensus

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.

<FanoutDiagram kind="consensus" />

<FanoutCoverage kind="consensus" />

### Highest value

We query several upstreams and keep the highest, freshest value. A node that has fallen behind reports a number that is too low, which is enough to leave your transaction unmined or rejected.

<FanoutDiagram kind="highest" />

<FanoutCoverage kind="highest" />

### Broadcast

We push it to every upstream in parallel for the widest, fastest propagation, and return the fastest response.

<FanoutDiagram kind="broadcast" />

<FanoutCoverage kind="broadcast" synced />

## Under the hood

The tier layers two independent protections: **cross-source consensus** and per-response **data-integrity checks**.

<FanoutFlow />

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

- [Pipeline cookbook](/turbo-pipelines/reference/pipeline-cookbook.md)
- [Google Cloud Pub/Sub](/turbo-pipelines/sinks/pubsub.md)
- [Pipeline architecture patterns](/turbo-pipelines/guides/architecture-patterns.md)
- [Build a binary prediction market](/compose/guides/build-a-prediction-market.md)
- [S2](/turbo-pipelines/sinks/s2.md)