VGOSnano

One window. One deterministic run. Exact same bytes → exact same digest.

▶ Play the full interactive Sandbox (VGOsMini)

Quick Flow — Where data comes from and what leaves

➜

Inputs

Earnings events (Marketplace / ERP ingestion)
Adjustments & refunds (Ops API or CSV uploads)
CT / Compliance flags (KYC/AML: CLEAR / HOLD)
Window policy (bonus ppm, late tolerance, close time)
Determinism: order=(ts↑, id↑); carry=(remainder↓, principal↑)
Schema: event_id, ts_occurred, principal_id, amount_minor, source_type

➜

Verit VGOSNano

exactly-once → stable order → integer math → sealed digest → acceptance

IntakeOrderAccumulateCTCarrySealAcceptance

Outputs

Payout allocations (per principal)
Seal payload (canonical JSON + SHA-256 digest)
Acceptance receipt (ACK + replay digest)
Window totals (net, bonus_floor, carry, payout)

Daily window closes 21:00ZBonus = 10% (100000 ppm)Late tolerance = 10 minInteger numerics (¢)Canonical JSON → SHA-256

This screen compresses the end-to-end settlement into a single storyline. We show how exactly-once intake removes duplicates, how a fixed order makes replay stable, how policy uses late quantization to keep integer math exact, how the carry-ledger assigns a single cent deterministically, and how a sealed digest gets replayed at acceptance before any money moves.

Live demo

Prefer to explore each step with toggles, transcripts, and artifacts?VGOsMini lets you drive the full 10-step flow.

Run the full interactive Sandbox (VGOsMini) →

Story — What’s happening

Plain-English narration of each phase.

Intake: we parse raw events, reject duplicates by event_id, and drop anything that occurred after the membership cutoff (close_ts - 600s).
Order: the fold comparator is exactly (ts_occurred asc, event_id asc), yielding a stableorder_key.
Accumulate: per principal net is summed in cents; the 10% bonus is computed in micro-cents (ppm) then floored to cents, exposing a deterministic remainder.
CT: compliance/tax statuses mark who is ALLOW or HOLD; this doesn’t affect math, only decisions.
Carry: we distribute the remainder pool (+1¢) to top ranks by remainder (desc) then principal_id (A→Z).
Seal: we canonicalize {window,final_allocations,totals} and hash with SHA-256 to form the output_digest.
Acceptance: we recompute the digest byte-for-byte (replay) and require a fresh ACK; money only moves ifreplay_digest == sealed_digest and ACK is fresh.
Done: same inputs → same digest, every single time.

Window

ID: 2025-09-23

Closes: 2025-09-23T21:00:00Z (membership cutoff = close − 600s)

Policy: v1.0; bonus 10%

Currency: USD (outputs in cents)

Inputs (VGONano receives)

Raw events (kept + rejected)

event_id	ts	principal	amount (¢)	type
e1	2025-09-23T11:00:00Z	CRE-0001	345	earning
e2	2025-09-23T11:05:00Z	CRE-0002	250	earning
e2	2025-09-23T11:05:00Z	CRE-0002	250	earning
e3	2025-09-23T11:10:00Z	CRE-0003	415	earning
e4	2025-09-24T00:05:00Z	CRE-0001	90	earning

CT status (per principal)

principal_id	ct_status	reason
CRE-0001	CLEAR	OK
CRE-0002	HOLD	CT_HOLD
CRE-0003	CLEAR	OK

Outputs (from this run)

Digest equals replay? —

Totals

—

Final allocations (payout)

principal	payout (¢)	decision

Sealed digest

—

Expected (from scenario)

—

Acceptance: —

1) Intake (dedupe + membership)

Duplicates (same event_id) are rejected; late events (after cutoff) are excluded with reason codes.

event_id	code	detail	kept

2) Order (stable comparator)

Deterministic fold order: (ts_occurred asc, event_id asc) → order_key = ts+id.

event_id	ts_occurred	principal_id	amount_minor (¢)	order_key

3) Accumulate (bonus in micro-cents, floor + remainder)

We keep everything integer. Bonus is net*ppm; floor gives whole cents; remainder feeds carry.

principal_id	net_minor (¢)	bonus_ppm	bonus_floor (¢)	remainder (µ¢)

4) CT (compliance / tax)

CT does not change numerics; it determines each principal's decision: ALLOW or HOLD.

principal_id	ct_status	reason
CRE-0001	CLEAR	OK
CRE-0002	HOLD	CT_HOLD
CRE-0003	CLEAR	OK

5) Carry (deterministic remainder distribution)

Pool = ⌊Σ remainder / 10,000⌋ cents. Rank by remainder desc, then principal A→Z. Top ranks get +1¢.

principal_id	rank	remainder (µ¢)	carry (¢)

6) Final allocations (sealed)

Only CLEAR principals are ALLOW; HOLD principals stay HOLD (e.g., CT_HOLD). These rows are hashed in the seal.

principal_id	net (¢)	bonus_floor (¢)	carry (¢)	payout (¢)	decision	reason

7) Seal → Acceptance (replay check before money moves)

We hash canonical {'{window,final_allocations,totals}'} to build the sealed digest, then recompute it (replay). Money only moves if the bytes match and ACK is fresh.

Sealed digest

—

Totals

—

Replay digest

—

ACK PRESENT (freshness 1800s)

Decision:—

Cross-check: expected digest for this scenario is —.

Phase

IDLE

Raw events

Kept (intake)

—

Ordered rows

—

Principals

—

Carry pool (¢)

—

Digest matches?

—

ACK freshness (s)

1800

Totals (¢)

—