R = V · τ · cΔy = y·Δx(1−f) / (x + Δx(1−f))x · y = kσ = s_r · √ATWAP = Σ Pᵢ Δtᵢ / Σ ΔtᵢT − S ≥ T_minΣ aᵢ = 1, aᵢ ≥ 0aᵢ = Σₖ 2ᵏ z / ME(z) = −U(z) + λP(z)r_t = ln(P_t / P_{t−1})max U(a) − λR(a) − μC(a)Rewardⱼ = ⌊ R·wⱼ / W ⌋P_exec = Δx / Δyimpact = P_exec / P_spot − 11 native = 10¹⁸ weicost = gasUsed × gasPriceB_i = R_net · a_i∇U(a) = λ ∇R(a) + μ ∇CP_spot = x / yR_net = max(0, R_gross − C)

Programmable EVM token economics

Token economics, in closed form.

Authorized revenue enters an isolated vault, verified rules decide, and bounded contracts execute — every step simulated first, every limit written down.

Launch app →Explore the simulator

Ethereum· configured, not live
Base· configured, not live
BNB Chain· configured, not live
Arbitrum· configured, not live

T − S ≥ T_minΣ aᵢ = 1, aᵢ ≥ 0aᵢ = Σₖ 2ᵏ z / ME(z) = −U(z) + λP(z)r_t = ln(P_t / P_{t−1})max U(a) − λR(a) − μC(a)Rewardⱼ = ⌊ R·wⱼ / W ⌋P_exec = Δx / Δyimpact = P_exec / P_spot − 11 native = 10¹⁸ weicost = gasUsed × gasPriceB_i = R_net · a_i∇U(a) = λ ∇R(a) + μ ∇CP_spot = x / yR_net = max(0, R_gross − C)R = V · τ · cΔy = y·Δx(1−f) / (x + Δx(1−f))x · y = kσ = s_r · √ATWAP = Σ Pᵢ Δtᵢ / Σ Δtᵢ

01 · The problem

Fees pile up. Policy should decide what happens next.

Static model

01Trading activity
02Revenue
03Passive treasury

Programmable model

01Authorized revenue source
02Vault
03Verified rules
04Controlled actions

Important: none of this happens automatically. Revenue only reaches a vault if the token, pool or owner is wired to send it there. An existing immutable ERC-20 cannot gain a transfer tax — quantumOS detects what is actually possible and falls back to a voluntary treasury route.

Rewardⱼ = ⌊ R·wⱼ / W ⌋P_exec = Δx / Δyimpact = P_exec / P_spot − 11 native = 10¹⁸ weicost = gasUsed × gasPriceB_i = R_net · a_i∇U(a) = λ ∇R(a) + μ ∇CP_spot = x / yR_net = max(0, R_gross − C)R = V · τ · cΔy = y·Δx(1−f) / (x + Δx(1−f))x · y = kσ = s_r · √ATWAP = Σ Pᵢ Δtᵢ / Σ ΔtᵢT − S ≥ T_minΣ aᵢ = 1, aᵢ ≥ 0aᵢ = Σₖ 2ᵏ z / ME(z) = −U(z) + λP(z)r_t = ln(P_t / P_{t−1})max U(a) − λR(a) − μC(a)

02 · Architecture

Eleven parts. Click any of them.

Select a node to read what it does, what it needs, the math inside it and how it can fail. Then send a simulated transaction through the graph.

Simulate route tosimulation only — nothing is sent on-chain

P_exec = Δx / Δyimpact = P_exec / P_spot − 11 native = 10¹⁸ weicost = gasUsed × gasPriceB_i = R_net · a_i∇U(a) = λ ∇R(a) + μ ∇CP_spot = x / yR_net = max(0, R_gross − C)R = V · τ · cΔy = y·Δx(1−f) / (x + Δx(1−f))x · y = kσ = s_r · √ATWAP = Σ Pᵢ Δtᵢ / Σ ΔtᵢT − S ≥ T_minΣ aᵢ = 1, aᵢ ≥ 0aᵢ = Σₖ 2ᵏ z / ME(z) = −U(z) + λP(z)r_t = ln(P_t / P_{t−1})max U(a) − λR(a) − μC(a)Rewardⱼ = ⌊ R·wⱼ / W ⌋

03 · Economic playground

Change a number. Everything recomputes.

Real calculations from your inputs — no canned values. Revenue is hypothetical until a real fee source is connected.

Inputs

Daily eligible volumeUSD/day

Fee rate τ%

Captured share c%

Share of fees actually routed to the vault.

Token priceUSD

Treasury balanceUSD

Reserve floorUSD

Execution costUSD/day

Gas for the day's operations.

Platform costUSD/day

Pool quote reserve xETH

Pool token reserve ytokens

Native priceUSD/ETH

Manual input — no live feed connected.

LP fee f%

Durationdays

Volume volatility σ% daily

RNG seed

Liquidity shocks on, p = 2%/day, −60% volume

Allocation (must total 100%)

Buyback%

Liquidity%

Treasury%

Rewards%

Σ = 100%

Revenue → budgets hypothetical model

$R_{gross}=V\,\tau\,c$: $1,000,000.00 × 0.02 × 0.75 = $15,000.00
$R_{net}=\max(0,\,R_{gross}-C)$: $14,820.00
$S_{max}=T-T_{min}$: $70,000.00

Buyback 30%$4,446.00
Liquidity 25%$3,705.00
Treasury 35%$5,187.00
Rewards 10%$1,482.00

Rounding: largest-remainder in micro-USD; residual = 0 µUSD. Real revenue depends on the token's fee mechanism and the pool integration — nothing here is observed on-chain.

Buyback against a constant-product pool

Quote in Δx: 1.482 ETH
Tokens out Δy: 14,560.4022
P_spot = x/y: 0.0001 ETH
P_exec = Δx/Δy: 0.00010178 ETH
Impact incl. LP fee: 1.7829%
Impact excl. LP fee: 1.4776%

Price impact exceeds your 0.5% slippage tolerance — a real executor would revert.

Slippage tolerance%

Valid for Uniswap V2-style pools only. V3/V4 concentrated liquidity needs tick-level math and is not approximated here.

Monte Carlo treasury path

800 paths, seed 42, log-normal volume, liquidity shocks on. Band = empirical 5th–95th percentile.

P5 end

$243,433

Median end

$271,227

P95 end

$304,321

Floor breach

Outcome distributions follow from the assumptions above. They are not predictions and not a guarantee of any return.

cost = gasUsed × gasPriceB_i = R_net · a_i∇U(a) = λ ∇R(a) + μ ∇CP_spot = x / yR_net = max(0, R_gross − C)R = V · τ · cΔy = y·Δx(1−f) / (x + Δx(1−f))x · y = kσ = s_r · √ATWAP = Σ Pᵢ Δtᵢ / Σ ΔtᵢT − S ≥ T_minΣ aᵢ = 1, aᵢ ≥ 0aᵢ = Σₖ 2ᵏ z / ME(z) = −U(z) + λP(z)r_t = ln(P_t / P_{t−1})max U(a) − λR(a) − μC(a)Rewardⱼ = ⌊ R·wⱼ / W ⌋P_exec = Δx / Δyimpact = P_exec / P_spot − 11 native = 10¹⁸ wei

04 · Strategy constructor

Rules with limits, not scripts.

Conditions and actions come from a fixed list. Every action needs a percentage and a hard USD cap. There is no arbitrary-call action.

Reserve floorUSD

Max slippage%

IF (all of)

hours

USD

THEN

up to% of net, hard cap $

IF (all of)

USD

THEN

up to% of net, hard cap $

IF (all of)

% ann.

THEN

up to% of net, hard cap $

Policy check

Policy valid · every action has a % share and a hard USD cap

Dry-run against a market state

Volatility% ann.

ReservesUSD

Liquidity depthUSD

TreasuryUSD

Hours since last run

Net budget todayUSD

Weekly buybackfires · $4,446
≥ 24h since last run → true · treasury > $60000 → true
Defend liquidityfires · $3,705
liquidity < $80000 → true
High-volatility reservefires · $5,187
volatility > 80% → true

Dry-run only. Nothing is signed or sent; on-chain execution would re-check every limit.

Policy JSON

{
  "version": 1,
  "reserveFloorUsd": 50000,
  "maxSlippagePct": 0.5,
  "rules": [
    {
      "id": "r1",
      "name": "Weekly buyback",
      "when": [
        {
          "type": "interval_elapsed",
          "value": 24
        },
        {
          "type": "treasury_gt",
          "value": 60000
        }
      ],
      "then": {
        "type": "buyback",
        "pctOfNet": 30,
        "maxUsd": 5000
      }
    },
    {
      "id": "r2",
      "name": "Defend liquidity",
      "when": [
        {
          "type": "liquidity_lt",
          "value": 80000
        }
      ],
      "then": {
        "type": "add_liquidity",
        "pctOfNet": 25,
        "maxUsd": 4000
      }
    },
    {
      "id": "r3",
      "name": "High-volatility reserve",
      "when": [
        {
          "type": "volatility_gt",
          "value": 80
        }
      ],
      "then": {
        "type": "allocate_treasury",
        "pctOfNet": 35,
        "maxUsd": 10000
      }
    }
  ]
}

Import policy JSON

05 · Intelligent systems

Four systems. One rule: AI proposes, code decides.

Measures what can be measured: returns, realized volatility, TWAP. It does not predict price or identify bot owners.

synthetic seeded sample — not market data

Obs.

σ annualised

74.1%

TWAP (equal Δt)

0.8427

Last / TWAP

0.86%

Mean log-ret

-0.542%

A used

365

Synthetic daily σ%

Seed

Intervals / year A

Or paste ≥3 prices (comma / space / newline separated)

Historical volatility estimates the past. It does not predict price, and A must match the true sampling interval.

∇U(a) = λ ∇R(a) + μ ∇CP_spot = x / yR_net = max(0, R_gross − C)R = V · τ · cΔy = y·Δx(1−f) / (x + Δx(1−f))x · y = kσ = s_r · √ATWAP = Σ Pᵢ Δtᵢ / Σ ΔtᵢT − S ≥ T_minΣ aᵢ = 1, aᵢ ≥ 0aᵢ = Σₖ 2ᵏ z / ME(z) = −U(z) + λP(z)r_t = ln(P_t / P_{t−1})max U(a) − λR(a) − μC(a)Rewardⱼ = ⌊ R·wⱼ / W ⌋P_exec = Δx / Δyimpact = P_exec / P_spot − 11 native = 10¹⁸ weicost = gasUsed × gasPriceB_i = R_net · a_i

06 · Real execution

From proposal to receipt.

This pipeline is a simulation. A simulated step is never shown as confirmed on-chain.

01
Proposal
idle
02
Simulation
idle
03
Validation
idle
04
Authorization
idle
05
Execution
idle
06
Receipt
idle

Inject failure at

transaction hash: — none · no transaction is broadcast from this page

Pick a failure point or run the happy path.

TWAP = Σ Pᵢ Δtᵢ / Σ ΔtᵢT − S ≥ T_minΣ aᵢ = 1, aᵢ ≥ 0aᵢ = Σₖ 2ᵏ z / ME(z) = −U(z) + λP(z)r_t = ln(P_t / P_{t−1})max U(a) − λR(a) − μC(a)Rewardⱼ = ⌊ R·wⱼ / W ⌋P_exec = Δx / Δyimpact = P_exec / P_spot − 11 native = 10¹⁸ weicost = gasUsed × gasPriceB_i = R_net · a_i∇U(a) = λ ∇R(a) + μ ∇CP_spot = x / yR_net = max(0, R_gross − C)R = V · τ · cΔy = y·Δx(1−f) / (x + Δx(1−f))x · y = kσ = s_r · √A

07 · Mathematical laboratory

Every formula, with units and a live example.

Captured fee revenue

R_{gross}=V\,\tau\,c\qquad [\text{USD/day}]=[\text{USD/day}]\cdot[1]\cdot[1]

Volume times fee rate times the fraction of fees your vault actually receives. If c is zero, so is revenue — capture depends entirely on the integration.

V (USD/day)

τ (%)

c (%)

1,000,000 × 0.02 × 0.75 = $15,000 / day

Limits: A hypothetical accounting model. Real revenue is the measured balance delta at the collector.

Constant-product swap

\Delta y=\frac{y\,\Delta x(1-f)}{x+\Delta x(1-f)},\quad P_{spot}=\tfrac{x}{y},; P_{exec}=\tfrac{\Delta x}{\Delta y}

You receive slightly less than the spot price implies, because your own trade moves the pool, and the LP fee is taken off the input first. The two effects are shown separately.

x (ETH)

y (tokens)

Δx (ETH)

f (%)

Δy = 1,000,000·0.997 / (100+0.997) = 9,871.58 tokens
impact incl. fee 1.3009% · excl. fee 0.997%

Limits: Uniswap V2-style pools only. V3/V4 concentrated liquidity needs tick-level math.

Gas, exactly

\text{cost}_{wei}=\text{GasUsed}\times\text{EffectiveGasPrice}_{wei/gas},\quad 1\,\text{native}=10^{18}\,\text{wei}

Computed with BigInt so no precision is lost. Gas price is entered in gwei (10⁹ wei).

Gas used

Gas price (gwei)

Native USD

wei = 185000 × 80000000 = 14800000000000
native = 0.0000148
USD ≈ $0.0444

Limits: On L2s (Base, Arbitrum) total cost also includes an L1 data fee, which this calculator does not include. Prices here are manual inputs — no live source is connected.

Reward split with explicit residual

\text{Reward}_j=\left\lfloor\frac{R\,w_j}{W}\right\rfloor,\quad \text{residual}=R-\sum_j \text{Reward}_j

Integer division rounds down, so a few base units are left over. quantumOS tracks that residual instead of losing it.

R (base units)

weights (integers)

shares = [33, 33, 33] · residual = 1 base units

Limits: Real distributions use snapshots and a Merkle root so holders claim — looping over all holders on-chain is impractical.

Binary encoding for QUBO

a_i\approx\frac{\sum_{k=0}^{K-1}2^k z_{i,k}}{M},\quad M=2^K-1,; z\in\{0,1\}

Each allocation weight becomes K bits. The more bits, the finer the grid, but the more variables the optimizer must search.

Bits per weight K

resolution 1/15 = 6.667% · 4 actions → 16 binary variables · 65536 bit strings

Limits: Penalty terms do not guarantee feasible output. Every solver result must pass deterministic validation.

Δy = y·Δx(1−f) / (x + Δx(1−f))x · y = kσ = s_r · √ATWAP = Σ Pᵢ Δtᵢ / Σ ΔtᵢT − S ≥ T_minΣ aᵢ = 1, aᵢ ≥ 0aᵢ = Σₖ 2ᵏ z / ME(z) = −U(z) + λP(z)r_t = ln(P_t / P_{t−1})max U(a) − λR(a) − μC(a)Rewardⱼ = ⌊ R·wⱼ / W ⌋P_exec = Δx / Δyimpact = P_exec / P_spot − 11 native = 10¹⁸ weicost = gasUsed × gasPriceB_i = R_net · a_i∇U(a) = λ ∇R(a) + μ ∇CP_spot = x / yR_net = max(0, R_gross − C)R = V · τ · c

08 · Trust and transparency

What exists, and what doesn't.

This page lists what is a design target and what is simply not there yet.

Smart contractsNot written or deployed yet. No addresses are shown because none exist.not available

Independent auditNone. Nothing on this site should be read as audited or safe.not available

Contract verification linksWill appear here per chain once real deployments exist.limitation

Permission modelDesign target: project, platform, governance, emergency and keeper roles kept separate; no single admin over all funds.design target

Treasury limitsDesign target: per-action budgets, daily caps and a reserve floor enforced in the vault, not only in the UI.design target

TimelocksDesign target: loosening limits or changing adapters is delayed; tightening and pause can be immediate.design target

Emergency pauseDesign target: scoped to halting execution. It must not grant a way to withdraw other people's funds.design target

Chain limitationsEthereum, Base, BNB Chain and Arbitrum differ in fee accounting, finality and available infrastructure. L2 costs include L1 data fees.limitation

Existing tokensImmutable ERC-20s cannot be given transfer taxes. They can only use a voluntary treasury route.limitation

Uniswap V4Hooks are fixed at pool initialization and cannot be attached to an existing pool. Dynamic LP fees are not token taxes.limitation

ReturnsNo yield, price support or return is promised. Simulations depend on stated assumptions.not available

Define it.
Simulate it.
Bound it.

Open the app →Technical documentation

Frontend preview. No wallet, contract or chain is connected yet.

Token economics, in closed form.

Fees pile up. Policy should decide what happens next.

Static model

Programmable model

Eleven parts. Click any of them.

Change a number. Everything recomputes.

Inputs

Allocation (must total 100%)

Revenue → budgets hypothetical model

Buyback against a constant-product pool

Monte Carlo treasury path

Rules with limits, not scripts.

Policy check

Dry-run against a market state

Policy JSON

Four systems. One rule: AI proposes, code decides.

From proposal to receipt.

Every formula, with units and a live example.

Captured fee revenue

Constant-product swap

Gas, exactly

Reward split with explicit residual

Binary encoding for QUBO

What exists, and what doesn't.

Define it.Simulate it.Bound it.

Define it.
Simulate it.
Bound it.