SPAWN — Technical Whitepaper (full capture)

Two versions exist on the live site and are captured here together:

Arc version — https://spawn.farm/whitepaper — header "spawn.farm · Arc · v1.0", SHA-256 04a602802e32424f46faf04f14a2c8321c51a7c016b53e0f8d157b0804dbd4d0
Robinhood (classic) version — https://spawn.farm/whitepaper-classic — header "spawn.farm · Robinhood Chain · v1.0", SHA-256 f144b0ce41dc607aa2be898925203b2940abad82c35aeb8641a9120f53d0f96a

Sections §1–§15 and §19–§21 are identical between the two. They diverge at §16, §17, §18 and the header/closing. Divergences are flagged inline with [ARC] / [ROBINHOOD] blocks. For v2 you are consolidating to one — see the v2 launch spec.

Abstract

Spawn is a launchpad [ARC: on Arc | ROBINHOOD: on Robinhood Chain] where anyone can deploy a small, formally specified dynamical system: a neural circuit built on published connectome data, a reaction-diffusion field, an oscillator network, a cellular automaton, or an agent-based model. It launches with its own token in a single transaction, and that token's trading activity funds the compute required to keep the model running. Two guarantees are designed to be enforced at the contract level, not promised in prose (Section 17 states which contracts are live). A third mechanism lets any third party recompute a model's published state from its seed and step function and check it against a hash recorded on-chain, turning "this is really running" into something falsifiable rather than something to be believed.

1 What Spawn Is

A launchpad where anyone can be the scientist: write a small model that actually runs, launch it with its own token in one transaction, and let the pool that people trade and farm pay for it to keep stepping.

DeSci. The specification defines the state and step function; provenance separates sourced material from engineering choices; checkpoints let anyone replay the execution and challenge a mismatch. DeFi. The token, trading pool, farming positions, and runtime escrow form the funding loop. Swaps produce both LP fees and the escrow share that pays for ticks.

A creator writes a small model plus a concrete description of how it executes.
They complete a provenance document: what the model is not, every dataset with origin and license, a real citation, and an explicit split between sourced data and engineering decisions.
They submit one transaction: deploys token (fixed supply), records provenance hashes on-chain, creates the pool, locks liquidity. If any step reverts, the whole launch reverts.
Trading fees split by the locker: majority to runtime escrow, bounded share to creator, fixed share to protocol.
The escrow pays for ticks. While it has balance, the organism runs; when it empties, it pauses visibly.

What "running" means. No single runtime — client-rendered browser process, on-chain state machine, or off-chain worker posting checkpoints. The creator must state which, and what advances a step. "An AI runs it" fails validation. Fixed supply, no mint. No mint function; supply entered at step 1 is all that will ever exist. Two enforced guarantees. Liquidity cannot be pulled (locker has no withdraw path); provenance cannot be skipped (form won't submit without it).

2 The Organism Specification

O = ⟨ S, f, sigma, tau ⟩ — state space, step function, launch seed, tick trigger.

S finite and serialisable; a checkpoint reconstructs one complete state with no hidden memory. Examples: Gray–Scott 256×256×2 float32 = 512 KiB; Kuramoto 512 float64 = 4 KiB; EB ring N×(v,s).
f pure and deterministic; state the arithmetic (float32/64/fixed/int), summation order, platform. Integer/fixed-point preferred for bit-exact replay.
sigma recorded on-chain; name the PRNG (xoshiro256**, PCG32) and how state advances.
tau accepted triggers: new block observed; explicit public call; wall-clock interval with block-hash anchoring; user input logged as event. Must be third-party observable.
Checkpoint hash H_t = SHA-256(serialise(s_t)); minimum cadence declared at launch; a mismatch is a public falsification.
A correct specification makes claims checkable, not true.

3 Model Classes

Five accepted classes with canonical equations, sourced-vs-design boundaries, and rejected overstatements (full detail in 04-model-classes.md): connectome-derived, reaction–diffusion, coupled oscillators, cellular automaton, agent-based. Also documented in the running set: an undulatory swimmer (Strouhal-band cruising; Triantafyllou 1991/1993, Videler & Wardle 1991, Domenici & Blake 1997), a head-direction ring attractor (16 E-PG wedges; Wolff 2015, Turner-Evans 2017, Green 2017, Seelig & Jayaraman 2015), a Physarum transport network (Jones 2010; Nakagaki 2000; Tero 2010), and Belousov–Zhabotinsky spirals under the two-variable Oregonator (Field & Noyes 1974, Tyson & Fife 1980, Winfree 1972). Other classes accepted when S, f, sigma, tau are concrete and provenance passes.

4 Why Provenance Is Required

Structured provenance document required; the launch tx cannot submit until complete. Two separate guarantees (specificity of claim vs locked money). Must contain: ≥2 "what this is NOT" statements; each dataset with origin, license, SHA-256 of bundled files (written on-chain); citations with DOI/link; sourced-vs-designed table; code license. Renders in full on the organism page. Spawn checks a citation is well-formed and a hash is valid SHA-256 — it is not verification.

5 The Liquidity Lock [DESIGNED — NOT DEPLOYED]

Atomic with launch (deploy token, create pool, deposit liquidity, lock() — one tx; reverts as a unit). No withdraw/unlock/release/emergency/migrate/sweep in any form; no owner/admin; not behind a proxy; no selfdestruct. Exposed: lock(token, amount) (factory only, once), collectFees(recipient), positionOf(token). Fees still flow to fixed destinations (escrow, creator claim, protocol); collecting never touches principal. A lock prevents the creator removing the pool; it does not stabilise price or prove the dataset.

6 Runtime Funding and Farming [DESIGNED — NOT DEPLOYED]

Fees split: runtime share → escrow E; bounded creator share; fixed 15% protocol share. ticks_remaining = floor(E/c); runway = ticks_remaining/r; dE/dt = phi·fee_rate·V(t) − c·r; V* = c·r/(phi·fee_rate). c declared at launch in quote asset, fixed after. Farming = LP share of swap fees via standard AMM; deeper liquidity → lower slippage → higher V → higher dE/dt. Pause when E reaches 0; resume from last checkpoint when E > c. No projected yield shown anywhere.

7 Verification and Replay

Recorded on-chain at launch: token address + fixed supply; sigma + hash of s_0; provenance hash + each data-file SHA-256; code repo URL + commit hash; c + full fee split. Replay: fetch s_0/sigma, verify against recorded hash; fetch f at recorded commit; apply f to checkpoint t using recorded triggers; compare SHA-256(s_t) to recorded H_t. Mismatch → public falsification (publish inputs, commit, environment, both hashes). Reproducibility pitfalls: float addition not associative; prefer integer/fixed-point or a pinned WASM build.

8 Determinism, Serialisation, and the Hash Chain [PROPOSED]

Declare serialise(s) exactly (field order, widths, endianness, encoding). Floats only if arithmetic fully declared; integer/fixed-point (Q32.32) preferred. Randomness is state: name PRNG, seed from sigma, include generator state in S. Chained checkpoints: H_0 = SHA-256(sigma || serialise(s_0)); H_t = SHA-256(H_{t-1} || serialise(s_t) || tau_t). Reference builds: pinned .wasm identified by SHA-256 is preferred when floats are unavoidable.

9 Tick Authorisation and Keepers [PROPOSED]

tick(organismId, H_t) — anyone may submit (the keeper) once the trigger condition holds. Escrow pays c to the runtime account and keeper fee c_k to msg.sender. Per-tick entropy epsilon_t = keccak256(sigma || blockhash(b_t)). Two idle states: stalled (escrow funded, no keeper ticked) vs paused (escrow below tick cost — the only funding failure).

10 Escrow Accounting [PROPOSED]

E_{n+1} = E_n + phi·F_n − (c + c_k)·1[tick_n]; runway = floor(E/(c+c_k)). Runtime share taken from the quote side only, so funding never sells the organism's own token. Hysteresis: pause when E < c+c_k, resume when E ≥ h·(c+c_k), h default 24. Direct top-ups allowed, non-refundable, confer nothing.

11 Challenge Protocol [PROPOSED]

Optimistic checkpoints; a challenger posting a bond bisects to a single disputed tick; both publish serialise(s_{k-1}) (must hash into agreed H_{k-1} or be slashed) and s_k; the reference build recomputes one step. On-chain adjudication where f fits a declared gas bound, otherwise a permanent social record tagged [FALSIFIED at tick k — challenge open]. Falsification bounty paid from the protocol share to the first successful challenger.

12 Observables [PROPOSED]

o_t = g(s_t) published alongside f; recomputable by anyone with s_t. Canonical observables by class (population rate / bump position; species mass / spot count; order parameter r; mass/centroid velocity; eigenworm coefficients & turn counts; polarisation & nearest-neighbour distance).

13 Composition [PROPOSED]

An organism may read another's observable: s_A(t+1) = f_A(s_A(t), sigma_A, o_B(t')) where o_B(t') is B's latest checkpoint ≤ A's tick. Cycles allowed (Jacobi-style). A composed organism is only as verifiable as its least verifiable input; A cannot fund B; escrows independent.

14 Threat Model

Creator sells allocation (public allocation, bounded creator fee); creator removes liquidity (locker has no withdraw); fabricated dataset (on-chain file hash + sourced-vs-designed table; Spawn doesn't read the file); false checkpoints (hash chain + challenge; social where f exceeds gas bound); operator abandons (any keeper may tick); Sybil launches (100,000 $SPAWN burn per launch); wash trading (pays for ticks, costs fees); dependency drift (pinned commit + wasm hash); reorg (checkpoints final after N blocks); MEV on fees (quote-side only); bug in contracts (public source, audits; immutability means no in-place patch).

15 Protocol Invariants

I1 supply(t) = supply(0)                         no mint path
I2 locked(t) >= locked(0)                          no path reduces a locked position
I3 one burn_tx -> at most one organism
I4 provenance_hash(t) = provenance_hash(0)         immutable after launch
I5 c(t)=c(0), phi(t)=phi(0)                         metering + split fixed
I6 E(t) >= 0                                        escrow never overdrawn
I7 paused => state + hash chain retained
I8 H_t = SHA-256(H_{t-1} || serialise(s_t) || tau_t)

I1, I4, I5 hold for the burn registry today (I3 via a DB uniqueness constraint). I2, I6–I8 apply when the factory/locker/escrow deploy.

16 The $SPAWN Token ← DIVERGES BY VERSION

[ARC version — DESIGNED — NOT DEPLOYED] $SPAWN is the protocol token, deployed on Arc at `0xf73801d9d33a037aef2e00fd1c1d15dcbf754390`, total supply 1,000,000,000, 18 decimals, verified by direct calls to an Arc mainnet node; that address is the only one this document recognises. The deployed account is an EIP-1167 minimal proxy whose implementation is fixed in its bytecode. No$ SPAWN pool on Arc has been observed, so no venue/price/market figure is stated. Creation gate: burning 100,000 $SPAWN (burn(uint256), else transfer to 0x…dEaD), irreversible. Interim registry: burn tx → free signature → server verification of the Transfer log → unique burn_tx_hash insert. Trading tax: 1% intended, funding injections into$ SPAWN's own pool.

[ROBINHOOD (classic) version — LIVE] $SPAWN is the protocol token. Contract: `0x41080c9d7908ce567efe239042c49d8159a2a3bb` on Robinhood Chain. Utility is narrow (no role in verification/replay/provenance). Creation gate: burning 100,000$ SPAWN, irreversible. Interim registry as above. **Trading tax: $SPAWN trades on Pons v2 and carries a 1% tax** that funds routine injections into$ SPAWN's own pool (separate from the fixed protocol share of organism fees).

17 Current State of the Project ← DIVERGES BY VERSION

[ARC version] Canonical chain: Arc, chain id 5042 (0x13b2), RPC https://rpc.mainnet.arc.io, explorer https://explorer.arc.io. Arc settles in USDC (native gas/value asset, USDC ERC-20 predeploy at 0x3600…0000). Economic constants denominated in ETH (min seed, c, c_k) are NOT carried over — to be re-set at Arc deployment. Running browser-local, no pool: C. elegans crawler, Drosophila larva peristalsis, adult fly tripod gait, undulatory swimmer, Lenia orbium, Vicsek flock. Worked examples: EB ring attractor, Gray-Scott field, Kuramoto lattice. Not deployed on Arc: $SPAWN, factory, locker, runtime escrow, tick/keeper, challenge. Arc carries Uniswap v4 core (PoolManager 0x8366…0951, StateView 0xf333…673b) + Permit2 (0x0000…78BA3) but NO v4 PositionManager, which the lock + fee sweep require — so those cannot deploy as written until it exists.

[ROBINHOOD (classic) version] Live: wallet connection (EIP-6963, WalletConnect, Coinbase Wallet), network add/switch to Robinhood Chain, launch by burning 100,000 $SPAWN with server-side receipt verification + shared registry, a browser sandbox generating an organism's <S,f,sigma,tau>. Running browser-local, no pool: same organism set as above. Not deployed: factory, locker, runtime escrow, tick/keeper, challenge. No organism token or pool exists. No APR/yield/price/holder figure shown anywhere.

18 Risk Disclosure [SUMMARY] ← minor divergence (chain name)

Smart contract risk (bugs; immutability prevents patching). [ARC: Arc | ROBINHOOD: Robinhood Chain] is infrastructure the team doesn't control. Locked-liquidity guarantee proves only that the initial position can't be removed; it can't verify a dataset and says nothing about price. Runtime funding depletion is the normal end state (pause, not fault). Model/claim risk (simplification; creators can be wrong/dishonest). No warranty, no advice; third-party tokens not endorsed. Assume total loss is possible. (Full text in 10-risk.md.)

19 Under Consideration [NOT BUILT]

Death records (final checkpoint hash + permanent one-line record on depletion); spec-first launch (interactive sandbox embedded in the Runtime step generating <S,f,sigma,tau>); Lenia zoo as a class (Chan's ~400-creature catalogue by ID); reference-build attestation (submit f as .wasm, site runs the attested binary); organism-to-organism funding (currently rejected — makes A's runway depend on B).

20 Notation

S, f, sigma, tau; s_t = f^t(s_0, sigma); H_t chained hash; o_t = g(s_t); E escrow; c, c_k tick + keeper cost; phi runtime share; V(t) volume, V* breakeven; r tick rate; h resume hysteresis.

21 References

Fang-Yen 2010; Pierce-Shimomura 1999; Iino 2009; Stephens 2008; Heckscher 2012; Wosnitza 2013; DeAngelis 2019; Cook 2019; Dorkenwald 2024; Berg 2026; Turing 1952; Pearson 1993; Kuramoto 1975; Strogatz 2000; Wolfram 1983; Triantafyllou 1991/1993; Domenici & Blake 1997; Videler & Wardle 1991; Chan 2019; Vicsek 1995; Reynolds 1987; Wolff 2015; Seelig & Jayaraman 2015; Turner-Evans 2017; Green 2017; Jones 2010; Nakagaki 2000; Tero 2010; Field & Noyes 1974; Tyson & Fife 1980; Winfree 1972. (Full DOIs in the live whitepaper / references section.)

Nothing in this document is financial advice. Verify all current state directly at spawn.farm and on the relevant chain explorer. The two versions above disagree on chain, token address, and live-status — resolving that into one is a v2 task.