Checkpoint Blooms: the chain, drawn.

RECOMPUTE IT YOURSELF · 20 LINES · SAME HASH, SAME BYTES

Recompute it yourself

This is the whole recipe: the same 20 lines bloomSvg() in /chain/apps/bloom.js runs, plus the one import it needs. Run it as a module (a <script type="module"> on any page works, because the SDK is served with CORS open), or in Node 20 or newer: save the SDK next to your file and change the import path to ./pointcast-chain.js. Call it with the block hash above. With no witness keys on the checkpoint, the SVG it returns is the file you can download, byte for byte.

1. Seeds. The chain’s own hash, blake2b-512, runs over the 32 bytes of the block hash plus a counter byte, for counters 0, 1 and 2. That is 192 seed bytes. Two bytes at a time become a number between 0 and 1.
2. Palette. Colours are chosen in OKLCH: one hue anywhere on the wheel, a near-white ink, a deep ground tinted like the site’s ink, and three petal colours with the chroma the channel ramps use. They are written as sRGB hex so every viewer agrees.
3. Petals. Five to thirteen petals in three layers: long and outer, shorter and offset, short and doubled. Length, width and how sharp the tip is come from the next numbers.
4. Rings and arcs. Three to six thin rings at hash-chosen radii, some dashed, and three to five signal arcs with round ends that start and sweep where the hash says.
5. Grain. A calm stipple: 120 tiny dots along a spiral, nudged by the seed bytes.
6. Witness rings. Not part of the recipe. If keys signed the checkpoint, one thin gold ring per distinct key is added outside the bloom, at radius 390 + 7 × k. Up to 14 are drawn; the text says the real count.

import { blake2b, hexToBytes } from 'https://pointcast.xyz/chain/sdk/pointcast-chain.js';
export function bloom(hash) {
  const B = [0, 1, 2].flatMap((c) => [...blake2b([hexToBytes(hash), [c]], 64)]); let i = 0; // 192 seed bytes: the chain's own hash, three counters
  const u = (a, b) => a + (b - a) * ((B[i++] << 8) | B[i++]) / 65536, R = (x) => Math.round(x * 10) / 10, P = (r, t) => `${R(500 + r * Math.sin(t))} ${R(500 - r * Math.cos(t))}`; // u: next two bytes as a number in [a, b)
  const T = (n, a, k = '') => `<${n} ${Object.entries(a).map(([x, v]) => `${x}="${v}"`).join(' ')}${k ? `>${k}</${n}>` : '/>'}`; // one SVG tag; every value is a number or a hex colour
  const hex = (L, C, H) => { const [a, b] = [Math.cos, Math.sin].map((f) => C * f(H * Math.PI / 180)), g = (v) => (v <= .0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - .055);
    const [l, m, s] = [[.3963, .2158], [-.1056, -.0639], [-.0895, -1.2915]].map(([p, q]) => (L + p * a + q * b) ** 3); // OKLCH -> OKLab -> linear sRGB -> hex
    return '#' + [[4.0767, -3.3077, .231], [-1.2684, 2.6098, -.3413], [-.0042, -.7034, 1.7076]].map(([p, q, r]) => Math.round(255 * Math.min(1, Math.max(0, g(p * l + q * m + r * s)))).toString(16).padStart(2, '0')).join(''); };
  const h0 = u(0, 360), ink = hex(.94, .02, h0), bg = hex(u(.17, .25), u(.02, .06), h0 + 190); // palette: a hue, a near-white ink, a deep ground
  const c = [hex(u(.7, .88), u(.08, .14), h0), hex(u(.62, .78), u(.1, .16), h0 + u(25, 70)), hex(u(.82, .93), u(.05, .1), h0 - u(20, 60)), hex(u(.74, .86), u(.1, .15), h0 + u(150, 210))];
  const n = Math.floor(u(5, 14)), len = u(280, 340), wide = u(.35, .8), tip = u(.35, 1), ratio = u(.55, .8); // petals: count, length, width, tip, inner ratio
  const petals = [0, 1, 2].map((j) => { const m = n * (1 + (j > 1)), L = len * [1, ratio, ratio * .6][j], x = L * wide / 2; // three layers of petals, drawn as paths
    const d = `M500 500C${R(500 - x)} ${R(500 - L * .35)} ${R(500 - x * tip)} ${R(500 - L * .9)} 500 ${R(500 - L)}C${R(500 + x * tip)} ${R(500 - L * .9)} ${R(500 + x)} ${R(500 - L * .35)} 500 500Z`;
    return Array.from({ length: m }, (_, k) => T('path', { d, transform: `rotate(${R((k + [0, .5, .25][j]) * 360 / m)} 500 500)`, fill: c[j], 'fill-opacity': [.8, .7, .9][j] })).join(''); }).join('');
  const rings = Array.from({ length: Math.floor(u(3, 7)) }, () => T('circle', { cx: 500, cy: 500, r: R(u(60, 372)), fill: 'none', stroke: ink, 'stroke-opacity': .6, 'stroke-width': R(u(1, 3)), ...(u(0, 1) > .5 && { 'stroke-dasharray': `${R(u(2, 10))} ${R(u(4, 16))}` }) })).join('');
  const arcs = Array.from({ length: Math.floor(u(3, 6)) }, (_, k) => { const r = u(90, 372), t = u(0, 6.2832), s = u(.5, 3.4); // signal arcs: radius, start angle, sweep
    return T('path', { d: `M${P(r, t)}A${R(r)} ${R(r)} 0 ${+(s > Math.PI)} 1 ${P(r, t + s)}`, fill: 'none', stroke: c[k % 2 ? 3 : 1], 'stroke-width': R(u(4, 10)), 'stroke-linecap': 'round', 'stroke-opacity': .95 }); }).join('');
  const grain = T('path', { d: Array.from({ length: 120 }, (_, k) => `M${P(Math.sqrt((k + .5) / 120) * 480, k * 2.39996 + B[k] / 40)}h0`).join(''), stroke: ink, 'stroke-width': 2.2, 'stroke-linecap': 'round', 'stroke-opacity': .2 }); // calm grain
  return T('svg', { xmlns: 'http://www.w3.org/2000/svg', viewBox: '0 0 1000 1000', width: 1000, height: 1000 }, T('rect', { x: -1e3, y: -1e3, width: 3e3, height: 3e3, fill: bg })
    + T('circle', { cx: 500, cy: 500, r: R(u(150, 330)), fill: c[1], 'fill-opacity': .12 }) + T('g', { class: 'p' }, petals) + rings + arcs + T('circle', { cx: 500, cy: 500, r: R(u(8, 22)), fill: ink }) + grain);
}
// bloom('<64 hex: a block hash>') returns the SVG as a string.

Copy the recipe Copy the call for this block

• Call …
• Colours chosen …
• Read the block yourself …

…