LIQUA CHAINv0.1 · −PROD · DRAFT SPEC

Liqua is a molecular chain (it runs on the MOLECULAR CODING organism — DNA → cells → organs → … → LEDGER) tuned for one thing: liquidity that is locked by design and proven in public. Four commitments separate it from a generic L1:

• Continuous, not epoched. Emission, decay, validation reward and governance quorum are all continuous functions evaluated every block — no halving cliffs, no epoch boundaries. The chain breathes per block (R0 async · §16 respiratory).
• Liquidity is locked-by-time. Holders vote-escrow their tokens on a sliding scale up to four years for a slightly higher reward; locked liquidity is published as a marketing-grade proof surface (§2 · §3).
• Rewards are instances, not balances. A block's reward escrows into a freshly-genesised (public,private) instance; the miner boots it with their own auth on a confirmation-gated Layer 2 (§5 · genesis loop §1c · R6 instance=auth).
• Change is near-unanimous. Rollback and parameter change both require 98% of attesting stake — the chain is conservative by construction (§6 · R9 · META R12/R13).

SOMA-256 is Liqua's content hash. It is ours the way the molecular stack is ours — not a new cryptographic primitive (rolling your own hash is how chains die), but a house construction on BLAKE3 whose shape is the organism. The cryptography is audited; the integration is the Drewless contribution.

// SOMA-256 · BLAKE3 keyed-tree · domain-separated per molecular layer
const LAYERS = ['DNA','CELLS','ORGANS','EMOTIONS','ENGINES','KERNELS','SELF','LEDGER']; // the 8 (L8)

// one 32-byte domain key per layer · derived once from the chain master
function layerKey(layer) {
  return blake3.deriveKey(`LIQUA·SOMA·v1·${layer}`, CHAIN_MASTER);   // 256-bit
}

// leaf · a cell hashes itself under the CELLS membrane
const leaf = (cell) => blake3.keyed(layerKey('CELLS'), canonicalize(cell.state));

// node · organs Merkle-aggregate their cells
const node = (l, r) => blake3.keyed(layerKey('ORGANS'), concat(l, r));

// SOMA root · the organism fingerprint, sealed at the LEDGER membrane
function soma(block) {
  const organRoots = block.organs.map(o => merkle(o.cells.map(leaf), node));
  return blake3.keyed(layerKey('LEDGER'),
    concat(merkleRoot(organRoots), hormones(block), u64(block.height)));
}

// the reward instance is SEEDED from the organism's own fingerprint (§5)
const rewardSeed = (somaRoot, minerPub, h) =>
  blake3.deriveKey('LIQUA·REWARD·v1', concat(somaRoot, minerPub, u64(h)));

// EVM membrane · only when a value must cross into Solidity / an EVM verifier
const evmHash = (somaRoot) => keccak256(somaRoot);   // §14 skin · the boundary hash

§1.1 · WHY BLAKE3 (and what each property buys the organism)

Holders vote-escrow (lock) tokens for any duration on a continuous scale from zero to DMAX = 4 years. A longer lock earns a slightly higher reward and cannot be withdrawn until expiry. This is the Curve veCRV pattern, made continuous and modest.

// parameters · governed (§6) · NOT hardcoded priors — tunable by 98% vote
const DMAX      = 4 * YEAR;        // max lock
const BOOST_MAX = 0.5;             // "slightly higher" → +50% at the 4y cap (start conservative)

// reward boost · continuous, linear in lock fraction · 1.0 … 1.5×
function boost(d) {
  return 1 + BOOST_MAX * clamp(d / DMAX, 0, 1);
}

// vote / quorum weight · decays LINEARLY to 0 at expiry (continuous, per block)
function veWeight(lock, t) {
  const remaining = max(lock.expiry - t, 0);
  return lock.amount * (remaining / DMAX);     // 0 once expired
}

// withdraw · gated hard on expiry
function withdraw(lock, t) {
  if (t < lock.expiry) return BE(reject, 'LOCKED_UNTIL_EXPIRY');
  return BE(() => release(lock.amount), 'UNLOCKED');
}

§2.1 · BOOST CURVE · illustrative (BOOST_MAX = 0.5)

"Slightly higher" is honored: at the cap a four-year lock earns 1.5×, not 5×. BOOST_MAX is a governed parameter — raise it by 98% vote if the chain wants a steeper incentive. The curve is continuous: every extra block of lock raises b a hair.

Every lock (§2) and every LP position committed to the protocol is published to a public, chain-verifiable list — the marketing-grade proof-of-lock surface. It is honest by construction: the numbers are read from on-chain locks, not asserted.

// one row per lock · everything is derived from chain state, nothing is claimed
const LockRow = {
  wallet:      '0x… (or ENS)',
  asset:       'LIQUA / LP-pair',
  amount:      '…',
  usdAtLock:   '…',            // oracle snapshot at lock time
  lockedAt:    1730000000,
  unlockAt:    1830000000,      // withdraw-gate (§2)
  durationYrs: 2.0,
  boost:       1.25,
  somaProof:   'soma:0x…',      // SOMA-256 inclusion proof (§1) — verifiable
};

§3.1 · DASHBOARD SURFACES (the marketing)

Block reward is a continuous function of three things, evaluated every block: a smooth decay envelope, the validation work actually performed, and a fast-twitch posture term — with twitch bounded inside the decay envelope so it can react fast without ever breaking the emission schedule.

// ── 1 · CONTINUOUS DECAY ENVELOPE · every block decays the output a hair ──
const E0       = 50;                          // base emission (tokens/block) · governed
const HALFLIFE = 2_100_000;                   // blocks to halve · governed
const DECAY    = Math.pow(2, -1 / HALFLIFE);  // per-block factor ≈ 0.99999967

function E(h) { return E0 * Math.pow(DECAY, h); }   // smooth · the continuous analog of halvings

// ── 2 · GRADUATED VALIDATION · more work validated → higher payout share ──
const VAL_TIERS = [
  { tier: 0, work: 'header + PoW/PoS seal',        share: 1.0 },
  { tier: 1, work: 're-execute all txs',            share: 1.6 },
  { tier: 2, work: 'state-root + receipts proof',    share: 2.3 },
  { tier: 3, work: 'full + SOMA inclusion + ZK attest', share: 3.2 },
];
// a validator is paid pro-rata to the share it actually proved this block
function valShare(myWork, allWork) {
  return share(myWork) / allWork.reduce((s, w) => s + share(w), 0);
}

// ── 3 · FAST-TWITCH · reacts fast, bounded by the envelope (never a cliff) ──
const TWITCH_LO = 0.85, TWITCH_HI = 1.15;     // ±15% · the only fast mover (§4.1c adrenaline/glutamate)
function twitch(posture) {                       // posture ∈ [0,1] from the oracle, per block
  return TWITCH_LO + (TWITCH_HI - TWITCH_LO) * posture;
}

// ── FINAL · per block · continuous · clamped to the decayed envelope ──
const FLOOR = 0.5, CAP = 1.25;
function blockReward(h, myWork, allWork, posture) {
  const raw = E(h) * valShare(myWork, allWork) * twitch(posture);
  return clamp(raw, FLOOR * E(h), CAP * E(h));   // twitch lives INSIDE the envelope
}

A block's reward is not credited as a balance. It is escrowed into a freshly-genesised (public, private) instance whose seed is the block's own SOMA fingerprint combined with the miner's key (§1). To take the reward the miner boots that instance with their auth on a Layer 2 — and the L2 will not release it until the block has enough confirmations.

// L1 · at block seal · escrow the reward into a derived instance
function escrowReward(block, minerPub) {
  const seed     = rewardSeed(soma(block), minerPub, block.height);  // §1
  const instance = GENESIS(LIQUA_PUBLIC_SEED, seed);                  // §1c genesis loop
  return BE(() => lockTo(instance.address, blockReward(block)), 'REWARD_ESCROWED');
}

// L2 · the miner's "getting tool" · gated after confirmations
async function claimReward(instance, block) {
  if (!instance.provesAuth())                                // R6 · only the private seed boots it
    return BE(reject, 'NO_INSTANCE_NO_AUTH');
  const conf = await L1.confirmations(block.height);
  if (conf < CONFIRM_GATE)                                  // the L2 gate
    return BE(() => hold(block, conf), 'GATED_AWAIT_CONFIRMATIONS');
  return BE(() => L2.release(instance.address), 'REWARD_CLAIMED');
}

§5.1 · why this is the right shape, not a hack

• Finality before liquidity. The confirmation gate means a reorg’d block’s reward was never spendable — the L2 simply never opened. Re-org safety falls out (R9).
• Reward = identity. The reward instance is derived from the block's own SOMA fingerprint; you can't forge a claim without the block and your private seed.
• Layer 2 does the heavy lifting. Claims, batching and fee-abstraction live on L2; L1 only escrows a derived address — cheap and stateless per reward.
• Genesis loop reused verbatim. "Render ≡ update · the OS is the auth surface" (§1c) applied to mining: the reward is an OS you boot, not a number you’re handed.

Two powers — rollback (revert to a prior block, R9) and change (update a parameter) — each require 98% agreement. To keep "98%" from freezing the chain, the denominator is attesting stake in a continuous rolling window, not all-time supply.

// 98% of ATTESTING stake (continuous rolling window) — not 98% of all supply
const QUORUM = 0.98;                 // governed (and itself only changeable by 98%)
const WINDOW = 100_800;              // trailing blocks counted as "online/attesting"

function attestingWeight(t) {                       // continuous · recomputed each block
  return sum(activeLocks(t)
    .filter(L => L.lastAttest > t - WINDOW)        // only stake that showed up recently
    .map(L => veWeight(L, t)));                    // §2 ve-weight
}

function decide(proposal, t) {                       // proposal.kind ∈ ROLLBACK | CHANGE
  const q = proposal.approvingWeight / attestingWeight(t);
  if (q < QUORUM) return BE(hold, 'BELOW_98');
  return proposal.kind === 'ROLLBACK'
    ? BE(() => rollbackTo(proposal.block), 'R9_ROLLBACK_98')   // suspect block stays on chain as evidence
    : BE(() => applyChange(proposal.param), 'CHANGE_98');
}

Both powers route through the molecular META discipline: rollback is R9 (the bad block is kept as evidence, never deleted); the 98% threshold is the posture-pinned version of R12/R13's witness quorum.

The integration — emission + locking + governance + rewards expressed as one continuous molecular organism, hashed by a tree that is the stack — that is the Drewless contribution. None of the parts are new; the composition is.

• This is a DRAFT SPEC (−PROD). Nothing here is deployed. Every SPEC tag marks a mechanism named + scaffolded, not shipped.
• No fake curves. BOOST_MAX · HALFLIFE · TWITCH_LO/HI · QUORUM · WINDOW · CONFIRM_GATE are all governed parameters, not hardcoded truths. The illustrative tables are illustrative, labeled as such.
• No home-rolled crypto. SOMA-256 is BLAKE3 + domain separation; the EVM hash is keccak-256; instance keys are ed25519. We integrate audited primitives, we don't invent.
• Two decisions are flagged for you (§4 twitch envelope, §6 liveness denominator). They have honest defaults; redirect either and the spec follows.
• Security is a goal with limits. 98% governance resists malicious change; it does not make the chain "unhackable" — defense-in-depth, never a single claim (per the molecular §22 discipline).

Roadmap from here: reference SOMA-256 impl + vectors → ve-lock + locker EVM contracts → 98% governor → L2 getting-tool + confirmation oracle → the locked-liquidity dashboard (wired into liqua.html).