[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_26":27,"_28":29,"_30":12,"_31":12,"_32":12,"_33":12,"_34":12,"_35":12,"_36":37},"routes/canvas.shared.$sharedTextdocId",{"_9":10,"_11":12},"sharedTextdoc",{"_13":14,"_15":-7,"_16":17,"_18":19,"_20":21,"_22":23,"_24":12,"_25":12},"isAuthenticated",false,"sharedTextdocId","693bc241917c819192f5bae040e4a0db","versionInt","title","Da Schemes — Dynamic Network Graphs","type","code/react","content","import React, { useMemo, useState } from \"react\";\nimport {\n ResponsiveContainer,\n LineChart,\n Line,\n XAxis,\n YAxis,\n CartesianGrid,\n Tooltip,\n Legend,\n} from \"recharts\";\n\n// -----------------------------\n// Helpers\n// -----------------------------\nconst BYTES_PER_MIB = 1024 * 1024;\n\nfunction ceilDiv(a: number, b: number) {\n return Math.ceil(a / b);\n}\n\nfunction depth(m: number) {\n return m > 1 ? Math.ceil(Math.log2(m)) : 0;\n}\n\nfunction fmtBitsPerSec(bits: number) {\n if (!Number.isFinite(bits) || bits <= 0) return \"0 b/s\";\n const units = [\"b/s\", \"Kib/s\", \"Mib/s\", \"Gib/s\", \"Tib/s\"]; // binary (×1024)\n let i = 0;\n let v = bits;\n while (v >= 1024 && i < units.length - 1) {\n v /= 1024;\n i++;\n }\n return `${v.toFixed(2)} ${units[i]}`;\n}\n\nfunction fmtBytes(b: number) {\n if (!Number.isFinite(b) || b <= 0) return \"0 B\";\n const units = [\"B\", \"KiB\", \"MiB\", \"GiB\", \"TiB\"]; // binary\n let i = 0;\n let v = b;\n while (v >= 1024 && i < units.length - 1) {\n v /= 1024;\n i++;\n }\n return `${v.toFixed(2)} ${units[i]}`;\n}\n\n// -----------------------------\n// Scheme sizing formulas (bytes)\n// -----------------------------\n// Each function returns sizes for ONE BLOB for ONE SUBNETWORK when applicable.\n// d = blob size (bytes); m = number of subnetworks; r = hadamard rows; sHad = chosen hadamard chunk bytes\n\nfunction sizesKZGv1(d: number, m: number) {\n const t = ceilDiv(2 * d, 31 * m); // scaling factor used by DA v1\n const shard = 31 * t; // per subnetwork\n const commit = 48 * t; // commitment built per column count\n const shardProof = 48; // proof for shard\n const chunk = shard; // for sampling we use the shard-sized linear-combination sample\n const chunkProof = 48;\n return { commit, shard, shardProof, chunk, chunkProof };\n}\n\nfunction sizesKZGChunk(d: number, m: number) {\n const t = ceilDiv(2 * d, 31 * m);\n const shard = 31 * t;\n const commit = 48; // single commitment reused for chunks\n const shardProof = 48;\n const chunk = 31; // one field element\n const chunkProof = 96; // opening + eval proof\n return { commit, shard, shardProof, chunk, chunkProof };\n}\n\nfunction sizesSemiAVID(d: number, m: number) {\n const t = ceilDiv(2 * d, 31 * m);\n const shard = 31 * t;\n const commit = 48 * (m / 2); // root-of-roots style\n const shardProof = 0;\n const chunk = 31;\n const chunkProof = 48;\n return { commit, shard, shardProof, chunk, chunkProof };\n}\n\n// --- New: Greyhound & Blaze (no chunk sampling; proofs are large) ---\nfunction sizesGreyhound(d: number, m: number) {\n const shard = 248 * ceilDiv(2 * d, 248 * m); // per subnetwork\n const commit = 4464; // bytes\n const shardProof = 52 * 1024; // ≈ 52 KiB (depends on max_d in spec)\n const chunk = shard; // no chunk sampling → fetch shard\n const chunkProof = 52 * 1024; // same as shard proof\n return { commit, shard, shardProof, chunk, chunkProof };\n}\n\nfunction sizesBlaze(d: number, m: number) {\n const shard = 32 * ceilDiv(2 * d, 32 * m); // per subnetwork\n const commit = 32; // Merkle root\n const shardProof = 30 * 1024; // ≈ 30 KiB\n const chunk = shard; // no chunk sampling → fetch shard\n const chunkProof = 30 * 1024;\n return { commit, shard, shardProof, chunk, chunkProof };\n}\n\nfunction sizesZodaHadamard(d: number, m: number, sHad: number) {\n // Column-only storage per subnetwork\n const shard = ceilDiv(2 * d, m); // ≈ per-column size (r*s)\n const commit = 32; // single Merkle root (columns)\n const merkle = 32 * depth(m); // proof for column leaf\n const shardProof = merkle;\n const chunk = sHad; // chosen entry size\n const chunkProof = merkle; // column proof for sampled chunk\n return { commit, shard, shardProof, chunk, chunkProof };\n}\n\nfunction sizesZodaTensor(d: number, m: number) {\n const s_t = ceilDiv(4 * d, m * m); // one cell/entry (bytes), from 4d over m^2\n const shard = 2 * m * s_t; // one column + one row stored by each subnetwork\n const commit = 64; // two Merkle roots (rows, columns)\n const merkle = 64 * depth(m); // need both row and column proofs\n const shardProof = merkle;\n const chunk = s_t; // one entry sampled\n const chunkProof = merkle; // row+column membership\n return { commit, shard, shardProof, chunk, chunkProof };\n}\n\n// full replication (separate chart use)\nfunction sizesFullReplication(d: number) {\n return { commit: 0, shard: d, shardProof: 0, chunk: d, chunkProof: 0 };\n}\n\n// -----------------------------\n// Component\n// -----------------------------\nexport default function DASchemesDynamicGraphs() {\n // Inputs\n const [m, setM] = useState(2048); // number of subnetworks\n const [capacityMiB, setCapacityMiB] = useState(1024); // DA capacity per block (MiB)\n const [blobMiB, setBlobMiB] = useState(1); // size per blob (MiB)\n const [consensusN, setConsensusN] = useState(100); // number of consensus nodes (not used in per-node metrics here)\n const [localThreshPow, setLocalThreshPow] = useState(20); // 2^-t → t samples\n const [blockTimeSec, setBlockTimeSec] = useState(30);\n const [hadChunk, setHadChunk] = useState(1024); // bytes\n const [chartHeight, setChartHeight] = useState(480); // px, controls all charts\n\n const dBytes = blobMiB * BYTES_PER_MIB; // per-blob size\n const capacityBytes = capacityMiB * BYTES_PER_MIB; // target capacity per block\n const blobsPerBlock = Math.max(1, Math.floor(capacityBytes / dBytes)); // i\n const samplesPerBlob = localThreshPow; // per consensus node\n\n // Choose visible schemes\n const [show, setShow] = useState({\n kzgv1: true,\n kzgchunk: true,\n semiavid: true,\n greyhound: true,\n blaze: true,\n zhad: true,\n zten: true,\n fullrep: false, // rendered in its own chart\n });\n\n // Utility to compute dispersal bps and sampling bps from sizes\n function dispersalBps(s: { commit: number; shard: number; shardProof: number }) {\n const perBlobBytes = s.commit + s.shard + s.shardProof;\n return (blobsPerBlock * perBlobBytes * 8) / blockTimeSec;\n }\n function consensusSamplingBps(s: { commit: number; chunk: number; chunkProof: number }) {\n const perBlobBytes = s.commit + samplesPerBlob * (s.chunk + s.chunkProof);\n return (blobsPerBlock * perBlobBytes * 8) / blockTimeSec;\n }\n\n // Curves: X varies DA capacity (MiB) with fixed m\n const xCapacity = useMemo(() => {\n const capsMiB = [] as number[];\n for (let v = 8; v <= 131072; v *= 2) capsMiB.push(v); // 8 MiB .. 128 GiB\n const rows: any[] = [];\n for (const cap of capsMiB) {\n const i = Math.max(1, Math.floor((cap * BYTES_PER_MIB) / dBytes));\n const sK1 = sizesKZGv1(dBytes, m);\n const sKC = sizesKZGChunk(dBytes, m);\n const sSA = sizesSemiAVID(dBytes, m);\n const sGH = sizesGreyhound(dBytes, m);\n const sBL = sizesBlaze(dBytes, m);\n const sZH = sizesZodaHadamard(dBytes, m, hadChunk);\n const sZT = sizesZodaTensor(dBytes, m);\n rows.push({\n capMiB: cap,\n kzgv1: (i * (sK1.commit + sK1.shard + sK1.shardProof) * 8) / blockTimeSec,\n kzgchunk: (i * (sKC.commit + sKC.shard + sKC.shardProof) * 8) / blockTimeSec,\n semiavid: (i * (sSA.commit + sSA.shard + sSA.shardProof) * 8) / blockTimeSec,\n greyhound: (i * (sGH.commit + sGH.shard + sGH.shardProof) * 8) / blockTimeSec,\n blaze: (i * (sBL.commit + sBL.shard + sBL.shardProof) * 8) / blockTimeSec,\n zhad: (i * (sZH.commit + sZH.shard + sZH.shardProof) * 8) / blockTimeSec,\n zten: (i * (sZT.commit + sZT.shard + sZT.shardProof) * 8) / blockTimeSec,\n });\n }\n return rows;\n }, [dBytes, m, hadChunk, blockTimeSec]);\n\n // Curves: X varies m with fixed DA capacity\n const xSubnets = useMemo(() => {\n const ms: number[] = [];\n for (let v = 1; v <= 8192; v *= 2) ms.push(v);\n const i = blobsPerBlock;\n const rows: any[] = [];\n for (const mm of ms) {\n const sK1 = sizesKZGv1(dBytes, mm);\n const sKC = sizesKZGChunk(dBytes, mm);\n const sSA = sizesSemiAVID(dBytes, mm);\n const sGH = sizesGreyhound(dBytes, mm);\n const sBL = sizesBlaze(dBytes, mm);\n const sZH = sizesZodaHadamard(dBytes, mm, hadChunk);\n const sZT = sizesZodaTensor(dBytes, mm);\n rows.push({\n m: mm,\n kzgv1: (i * (sK1.commit + sK1.shard + sK1.shardProof) * 8) / blockTimeSec,\n kzgchunk: (i * (sKC.commit + sKC.shard + sKC.shardProof) * 8) / blockTimeSec,\n semiavid: (i * (sSA.commit + sSA.shard + sSA.shardProof) * 8) / blockTimeSec,\n greyhound: (i * (sGH.commit + sGH.shard + sGH.shardProof) * 8) / blockTimeSec,\n blaze: (i * (sBL.commit + sBL.shard + sBL.shardProof) * 8) / blockTimeSec,\n zhad: (i * (sZH.commit + sZH.shard + sZH.shardProof) * 8) / blockTimeSec,\n zten: (i * (sZT.commit + sZT.shard + sZT.shardProof) * 8) / blockTimeSec,\n });\n }\n return rows;\n }, [blobsPerBlock, dBytes, hadChunk, blockTimeSec]);\n\n // Consensus sampling charts\n const xCapacitySampling = useMemo(() => {\n const capsMiB = [] as number[];\n for (let v = 8; v <= 131072; v *= 2) capsMiB.push(v);\n const rows: any[] = [];\n for (const cap of capsMiB) {\n const i = Math.max(1, Math.floor((cap * BYTES_PER_MIB) / dBytes));\n const sK1 = sizesKZGv1(dBytes, m);\n const sKC = sizesKZGChunk(dBytes, m);\n const sSA = sizesSemiAVID(dBytes, m);\n const sGH = sizesGreyhound(dBytes, m);\n const sBL = sizesBlaze(dBytes, m);\n const sZH = sizesZodaHadamard(dBytes, m, hadChunk);\n const sZT = sizesZodaTensor(dBytes, m);\n rows.push({\n capMiB: cap,\n kzgv1: (i * (sK1.commit + localThreshPow * (sK1.chunk + sK1.chunkProof)) * 8) / blockTimeSec,\n kzgchunk: (i * (sKC.commit + localThreshPow * (sKC.chunk + sKC.chunkProof)) * 8) / blockTimeSec,\n semiavid: (i * (sSA.commit + localThreshPow * (sSA.chunk + sSA.chunkProof)) * 8) / blockTimeSec,\n greyhound: (i * (sGH.commit + localThreshPow * (sGH.chunk + sGH.chunkProof)) * 8) / blockTimeSec,\n blaze: (i * (sBL.commit + localThreshPow * (sBL.chunk + sBL.chunkProof)) * 8) / blockTimeSec,\n zhad: (i * (sZH.commit + localThreshPow * (sZH.chunk + sZH.chunkProof)) * 8) / blockTimeSec,\n zten: (i * (sZT.commit + localThreshPow * (sZT.chunk + sZT.chunkProof)) * 8) / blockTimeSec,\n });\n }\n return rows;\n }, [dBytes, m, hadChunk, localThreshPow, blockTimeSec]);\n\n const xSubnetsSampling = useMemo(() => {\n const ms: number[] = [];\n for (let v = 1; v <= 8192; v *= 2) ms.push(v);\n const i = blobsPerBlock;\n const rows: any[] = [];\n for (const mm of ms) {\n const sK1 = sizesKZGv1(dBytes, mm);\n const sKC = sizesKZGChunk(dBytes, mm);\n const sSA = sizesSemiAVID(dBytes, mm);\n const sGH = sizesGreyhound(dBytes, mm);\n const sBL = sizesBlaze(dBytes, mm);\n const sZH = sizesZodaHadamard(dBytes, mm, hadChunk);\n const sZT = sizesZodaTensor(dBytes, mm);\n rows.push({\n m: mm,\n kzgv1: (i * (sK1.commit + localThreshPow * (sK1.chunk + sK1.chunkProof)) * 8) / blockTimeSec,\n kzgchunk: (i * (sKC.commit + localThreshPow * (sKC.chunk + sKC.chunkProof)) * 8) / blockTimeSec,\n semiavid: (i * (sSA.commit + localThreshPow * (sSA.chunk + sSA.chunkProof)) * 8) / blockTimeSec,\n greyhound: (i * (sGH.commit + localThreshPow * (sGH.chunk + sGH.chunkProof)) * 8) / blockTimeSec,\n blaze: (i * (sBL.commit + localThreshPow * (sBL.chunk + sBL.chunkProof)) * 8) / blockTimeSec,\n zhad: (i * (sZH.commit + localThreshPow * (sZH.chunk + sZH.chunkProof)) * 8) / blockTimeSec,\n zten: (i * (sZT.commit + localThreshPow * (sZT.chunk + sZT.chunkProof)) * 8) / blockTimeSec,\n });\n }\n return rows;\n }, [blobsPerBlock, dBytes, hadChunk, localThreshPow, blockTimeSec]);\n\n // Full replication (separate chart)\n const fullRepData = useMemo(() => {\n const capsMiB = [] as number[];\n for (let v = 8; v <= 131072; v *= 2) capsMiB.push(v);\n const rows: any[] = [];\n for (const cap of capsMiB) {\n const i = Math.max(1, Math.floor((cap * BYTES_PER_MIB) / dBytes));\n const sFR = sizesFullReplication(dBytes);\n rows.push({ capMiB: cap, fullrep: (i * (sFR.commit + sFR.shard + sFR.shardProof) * 8) / blockTimeSec });\n }\n return rows;\n }, [dBytes, blockTimeSec]);\n\n const colors: Record = {\n kzgv1: \"#0072B2\", // blue\n kzgchunk: \"#E69F00\", // orange\n semiavid: \"#CC79A7\", // reddish purple\n greyhound: \"#009E73\", // bluish green\n blaze: \"#D55E00\", // vermillion\n zhad: \"#56B4E9\", // sky blue\n zten: \"#9467bd\", // purple\n fullrep: \"#000000\", // black\n };\n\n return (\n

DA Schemes — Dynamic Network Graphs

\n\n {/* Controls */}\n

\n Number of subnetworks (m)\n setM(Math.max(1, parseInt(e.target.value) || 1))}\n className=\"mt-2 w-full border rounded px-3 py-2\"\n />\n

Merkle depth = {depth(m)}; log₂(m)

\n\n

\n DA capacity per block (MiB)\n setCapacityMiB(Math.max(1, parseInt(e.target.value) || 1))}\n className=\"mt-2 w-full border rounded px-3 py-2\"\n />\n

Blobs per block i = {blobsPerBlock}

\n\n

\n Size per blob (MiB)\n setBlobMiB(Math.max(1, parseInt(e.target.value) || 1))}\n className=\"mt-2 w-full border rounded px-3 py-2\"\n />\n

Blob size = {fmtBytes(dBytes)}

\n\n

\n Sampling local threshold 2^-t → t samples\n setLocalThreshPow(Math.max(1, parseInt(e.target.value) || 1))}\n className=\"mt-2 w-full border rounded px-3 py-2\"\n />\n

\n\n

\n Block time (s)\n setBlockTimeSec(Math.max(1, parseInt(e.target.value) || 1))}\n className=\"mt-2 w-full border rounded px-3 py-2\"\n />\n

\n Chart height (px)\n setChartHeight(Math.max(240, Math.min(1200, parseInt(e.target.value) || 480)))}\n className=\"mt-2 w-full border rounded px-3 py-2\"\n />\n

Affects all charts.

\n\n {/* Hadamard chunk size control */}\n

\n Hadamard chunk size s (bytes)\n setHadChunk(Math.max(1, parseInt(e.target.value) || 1))}\n className=\"mt-2 w-full border rounded px-3 py-2\"\n />\n

\n Implied rows r = {Math.ceil((2 * dBytes) / (hadChunk * m))}\n

\n\n {/* Scheme toggles */}\n

Show schemes

\n {Object.entries(show).map(([key, val]) => (\n \n setShow((s) => ({ ...s, [key]: e.target.checked }))}\n />\n \n \n {key}\n \n \n ))}\n

Full replication is rendered in its own chart to avoid compressing other curves.

\n\n {/* Row 1 */}\n

DA node bandwidth during dispersal (fixed m = {m})

\n \n \n \n `${v} MiB`} />\n fmtBitsPerSec(v)} />\n fmtBitsPerSec(v)} labelFormatter={(l) => `${l} MiB`} />\n \n {show.kzgv1 && }\n {show.kzgchunk && }\n {show.semiavid && }\n {show.greyhound && }\n {show.blaze && }\n {show.zhad && }\n {show.zten && }\n \n \n

X: DA capacity, Y: per-subnetwork bandwidth (bits/s) to receive shard+commit+proof for all blobs in the block.

\n\n

DA node bandwidth during dispersal (fixed DA capacity = {capacityMiB} MiB)

\n \n \n \n \n fmtBitsPerSec(v)} />\n fmtBitsPerSec(v)} />\n \n {show.kzgv1 && }\n {show.kzgchunk && }\n {show.semiavid && }\n {show.greyhound && }\n {show.blaze && }\n {show.zhad && }\n {show.zten && }\n \n \n

X: number of subnetworks, Y: per-subnetwork dispersal bandwidth.

\n\n {/* Row 2 */}\n

Consensus node sampling bandwidth (fixed m = {m}, {samplesPerBlob} samples)

X: DA capacity, Y: bandwidth to fetch one commit and {samplesPerBlob} chunk+proof per blob.

\n\n

Consensus node sampling bandwidth (fixed DA capacity = {capacityMiB} MiB, {samplesPerBlob} samples)

X: number of subnetworks, Y: sampling bandwidth per consensus node.

\n\n {/* Full replication separate */}\n

Full replication — DA node dispersal bandwidth (separate)

\n \n \n \n `${v} MiB`} />\n fmtBitsPerSec(v)} />\n fmtBitsPerSec(v)} labelFormatter={(l) => `${l} MiB`} />\n \n {show.fullrep && }\n \n \n

Toggle the scheme above to overlay if desired.

\n\n {/* Snapshot table for current parameters */}\n

Snapshot (per subnetwork / per consensus node)

\n {(() => {\n const s = {\n kzgv1: sizesKZGv1(dBytes, m),\n kzgchunk: sizesKZGChunk(dBytes, m),\n semiavid: sizesSemiAVID(dBytes, m),\n greyhound: sizesGreyhound(dBytes, m),\n blaze: sizesBlaze(dBytes, m),\n zhad: sizesZodaHadamard(dBytes, m, hadChunk),\n zten: sizesZodaTensor(dBytes, m),\n } as const;\n const rows = Object.entries(s).map(([key, v]) => ({\n scheme: key,\n shard: fmtBytes(v.shard),\n commit: fmtBytes(v.commit),\n proofShard: fmtBytes(v.shardProof),\n chunk: fmtBytes(v.chunk),\n proofChunk: fmtBytes(v.chunkProof),\n dispersal: fmtBitsPerSec(dispersalBps(v)),\n sampling: fmtBitsPerSec(consensusSamplingBps(v)),\n }));\n return (\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n {rows.map((r) => (\n \n \n \n \n \n \n \n \n \n \n ))}\n \n

Scheme	Shard size	Commit	Shard proof	Chunk	Chunk proof	Dispersal BW	Consensus BW
{r.scheme}	{r.shard}	{r.commit}	{r.proofShard}	{r.chunk}	{r.proofChunk}	{r.dispersal}	{r.sampling}

\n );\n })()}\n

\n Formulas: Dispersal = i·(commit+shard+shardProof)·8 / blockTime. Sampling = i·(commit + t·(chunk+chunkProof))·8 / blockTime, where i = ⌊capacity/blobSize⌋ and t = local threshold (default 20). For Greyhound/Blaze we assume no chunk sampling, so chunk = shard and proofs are large (≈52/30 KiB).\n

\n );\n}\n","access","public","isModerationBlocked","isAnonifyApiKeyDetected","dd",{"_38":39,"_40":41},"disablePrefetch",true,"shouldPrefetchAccount","shouldPrefetchUser","shouldPrefetchSystemHints","promoteCss","disableSSR","stripModulepreloadImports","statsigGateEvaluationsPromise",["P",37],"traceId","15299185293426110048","traceTime",1777766297289]