Acki Nacki tokenomics & consensus, a structured brief

August 17, 2025 • 2 weeks ago • 7 min read
an-graphics-brief

TL;DR

Acki Nacki runs on two tokens, NACKL (value & security) and Shell (gas). Rewards are computed per epoch, governed by an auto-tuning reward-per-second parameter.

Emission splits 67.5% Block keepers / 22.5% Mobile Verifiers / 10% Block Managers.

Licenses sit at the center of validator economics (with a limited privilege period). MinStake auto-adjusts with network load to keep capacity healthy.

Shell is sold for USDC at a fixed rate and those USDC are locked in an Accumulator; validators can burn NACKL to redeem a pro-rata share, this builds a price floor for NACKL. Consensus finalizes in two interactive steps, about as fast as physics and distributed systems let you go.

Transcript and full video here.

1) Roles & responsibilities

  • Block keepers (validators)
    Produce blocks. Receive the largest share of emission (67.5%) because they anchor liveness and safety.
  • Block managers (RPC/edge)
    Provide reliable access to the network (10% of emission). Fewer are needed relative to Block keepers; think “front-of-house API”.
  • Mobile verifiers
    Many lightweight participants (22.5% of emission). Individually tiny, collectively meaningful, crowd-secured attestations that harden the network.

Management-speak: three lanes, one highway. Capacity (Block keepers), access (Block Managers), and broad-based assurance (Mobile Verifiers).

2) Rewards & emission (How money flows)

2.1 Epoch-based accounting

  • Rewards are tallied per epoch (not per block).
  • A system parameter reward_per_second (RPS) controls current emission and auto-adjusts based on minted supply vs. the planned curve.

Core math (conceptual):

  • Total emission this epoch = RPS × epoch_duration
  • Split among roles by policy:
    • Block keepers: 67.5%
    • Mobile Verifiers: 22.5%
    • Block Managers: 10%

2.2 How Block keeper rewards are split

  1. Across Block keepers: proportional to stake share × reputation (both snapshot at epoch start).
  2. Within a Block keeper: the Block keeper’s reward is split equally across licenses delegated to that Block keeper.

Practical tip: because the per-license split is equal after the Block keeper’s pie is sized, node operators should curate fairly homogeneous licenses (stake & rep) to avoid perceived imbalances.

3) Licenses, reputation & minStake

  • License: the unit you delegate to a Block keeper. Each license holds stake and has a reputation coefficient.
  • Reputation: rises with correct participation; can be lost if a license stops behaving or under-restakes.
  • License privilege (limited window): for the initial license era (≈ two years), a license that restakes all its earnings and keeps reputation can be treated as if it meets MinStake even if it’s a bit short. If it stops restaking or loses reputation, privilege is gone.

3.1 Dynamic MinStake

  • There’s a base MinStake driven by the target free float and current supply.
  • The system lowers MinStake when more Block keepers are needed (e.g., exits) and can raise it when capacity is ample.
  • This is the primary control loop that keeps network capacity aligned with actual load (TPS headroom signals).

Plain English: exits happen. When they do, MinStake flexes down so new operators can step in and restore capacity. Upswings in demand? MinStake can rise to preserve economics and security.

4) Two tokens by besign

4.1 NACKL — security & value

  • Finite supply + declining issuance → value capture akin to Bitcoin logic.
  • Higher NACKL price = higher cost to attack = stronger security.

4.2 Shell — gas that stays predictable

  • Users buy Shell directly from a sale contract at a fixed USDC rate (e.g., 1 USDC = 100 Shell).
  • Price cannot go above the official rate (arbitrage blocks it); it can trade below on secondary markets if someone wants out instantly.

4.3 The Accumulator (the “floor engine”)

  • All USDC from Shell sales are locked in an Accumulator contract.
  • Validators can burn NACKL to redeem a pro-rata share of the USDC pool based on their share of current total NACKL, this destroys those NACKL and lifts the floor under the remaining supply.
  • Selling NACKL into the Accumulator is usually worse than selling on market (market prices future value; the Accumulator reflects past deposits), so USDC tends to accumulate, steadily strengthening the floor.

Cheat sheet: Shell stabilizes cost to compute; NACKL accrues value & security. The Accumulator is the bridge between them that compounds NACKL’s safety net over time.

5) Liquidity, Bridge & DEX (Getting in, getting out)

  • Bridge: 1:1 design, not a liquidity pool. If you bridged USDC in, you can bridge out the same amount, no fractional reserve games.
  • DEX: order book (not AMM). Expect active pairs versus NACKL and Shell; stables are present via the bridge.
  • Circulating supply reporting: all mined NACKL is circulating (minus anything burned). Validators can exit at will; there’s no “team escrow” hidden from float stats.

6) Game theory scenarios

  • “15% Validators Exit”: Emission curve is unchanged. With fewer participants, the same pie is split fewer ways → higher rewards per remaining license (stake & rep equal). If capacity dips, MinStake lowers to attract replacements.
  • Big holder sells licenses: Most buyers will continue validating (that’s the economic point), so the network keeps capacity. If someone only dumps tokens, MinStake and reward incentives nudge new validators in.

Bottom line: exits reallocate flow; the system’s dials (MinStake, rep, equal-per-license split within a BK) pull the network back to equilibrium.

7) Consensus in two interactive steps (fast by design)

  • Message complexity ≈ 2
    1. Producer broadcasts block.
    2. Verifiers attest.
      (An additional small, parallel notify can occur, doesn’t stall finality.)
  • If a producer misses timing, the protocol replaces it; blocks keep flowing.
  • This is about as fast as interactive BFT can get while respecting the speed of light (latency) and safety thresholds.

Translation: fewer back-and-forths → lower latency to finality, without hand-waving safety assumptions.

8) Ceremony @ Mainnet (ZK Setup, Public Good)

  • At mainnet start, users can join a massively parallelized Powers-of-Tau-style ceremony to generate a CRS for Groth16 proofs.
  • The app grants slots, pulls a large transcript (use Wi-Fi), derives randomness (yes, with on-screen gestures), and uploads your contribution.
  • Security property: if at least one contributor destroys their “toxic waste,” the setup is sound. With hundreds of thousands participating, compromise probability drops off a cliff.

9) Worked mini-examples

Example A: Two validators, uneven license counts

  • BK-A: 1 license; BK-B: 20 licenses; equal stake & rep across licenses.
  • Network computes BK pies by stake×rep share. If equal shares, BK-B’s pie ≈ 20× BK-A.
  • Per-license payout is equal within the BK, so one license on BK-A earns ≈ one license on BK-B.

Example B: Exits

  • 15% of validators leave. Emission is constant per schedule. Remaining validators (and their licenses) share more per head. If capacity is tight, MinStake is lowered to recruit newcomers.

10) Operator & analyst quick notes

  • Use the calculator as if you’re configuring licenses (not just “nodes”). It’s exact when each node runs the optimal ~20 licenses; deviations introduce small drift because of license privileges and rep differences.
  • Curation matters: align license stakes & rep under a BK to avoid uneven outcomes.
  • Restake discipline: to retain the temporary license privilege (treated at MinStake), restake earnings and maintain uptime; otherwise the privilege is lost.

11) Governance & upgrades

  • No on-chain “voting token.” Critical changes (e.g., adding a basket for the Accumulator beyond USDC) would be shipped as client updates that validators choose to run.
  • Early on, some contracts may be upgradeable for safety, but the economic primitives (two-token split, Accumulator floor logic) are intended to be stable.

12) FAQ speed round

  • Why two tokens, again?
    You cannot optimize for security appreciation and stable gas with a single asset. Split concerns, align incentives.
  • Can Shell moon?
    The official sale caps Shell’s price. On the open market it can dip below the cap if sellers want speed over price.
  • Does Accumulator redemption hurt others?
    No. You burn your NACKL to take your pro-rata USDC, leaving the per-NACKL backing for others unchanged.
  • Is 67.5 / 22.5 / 10 set in stone?
    It reflects assessed contribution: production (BK), mass assurance (Mobile), access (Managers). That’s the current design target.

13) Launch sequence (high level)

  • Finish refactors → pre-net shakedown (wallet + Popit mini-apps + mining) → fix issues → mainnet.
  • Wallets installed for pre-net roll over to mainnet. First-run experience surfaces the ceremony.

14) Glossary

  • Epoch – Accounting window for rewards.
  • RPS (reward_per_second) – Auto-tuned emission rate.
  • MinStake – Minimum effective stake per license (dynamic).
  • License privilege – Temporary rule treating a good-standing license as meeting MinStake if it continuously restakes.
  • Accumulator – Contract holding USDC from Shell sales; enables NACKL burn → USDC redemptions; creates a floor.
  • CRS / Powers-of-Tau – Public setup for zkSNARKs (Groth16), massively parallelized here.

Closing thought

This architecture cleanly decouples security value (NACKL) from usage cost (Shell), then stitches them with a floor mechanism (Accumulator) and adaptive capacity controls (MinStake + license rules).

Net-net: credible economics, predictable UX, and a consensus layer tuned for two-round finality. High-tempo, low-drama, exactly what production chains need.

NACKL News