shi500

On exit, a fee is taken from the ETH you would have received at the curve price for the tokens you burn. Longer holds unlock lower fees; after 31+ minutes the exit fee is 0% and a token bonus accrues per the immutable schedule.

TIER BREAKDOWN

┌─ TIER BREAKDOWN ─────────────────────────────┐
│                                              │
│  0–5 min    → 25% exit fee  (scalper tax)    │
│  6–15 min   → 15% exit fee  (trader tax)     │
│  16–30 min  → 5% exit fee    (fair exit)     │
│  31+ min    → 0% fee + 15% bonus tokens ✓    │
│                                              │
└──────────────────────────────────────────────┘

REAL EXAMPLES (ETH, consistent units)

Scenario A — Panic exit (2 minutes → 25% fee)
├─ Tokens sold:     1,000,000
├─ Spot price:      0.01 ETH / token (illustrative)
├─ Gross ETH:       10,000 ETH   (= 1e6 × 0.01)
├─ Exit fee (25%):  2,500 ETH
└─ Net ETH:         7,500 ETH

Scenario B — Fair trade (20 minutes → 5% fee)
├─ Tokens sold:     1,000,000
├─ Spot price:      0.02 ETH / token
├─ Gross ETH:       20,000 ETH
├─ Exit fee (5%):   1,000 ETH
└─ Net ETH:         19,000 ETH

Scenario C — Hodler reward (45 minutes → 0% fee + 15% bonus tokens)
├─ Tokens sold:        1,000,000
├─ Spot price:         0.05 ETH / token
├─ Gross ETH:          50,000 ETH
├─ Exit fee:           0 ETH
└─ Bonus tokens mint:  +150,000  (= 15% of 1,000,000)

FEE ALLOCATION (where exit fees go)

Every taxed exit splits the fee:
├─ 70% → LP Pool        (deepens liquidity / price support)
├─ 20% → Reserve Pool (funds provable bonus claims)
└─ 10% → Team Treasury (sustainability)

Nested mental model (numbers are illustrative, not live):
├─ 70% → LP Pool
│        ├─ accumulates until injected / paired
│        └─ benefits remaining holders via deeper books
├─ 20% → Reserve Pool
│        ├─ pays only what the contract can prove on-chain
│        └─ health is readable from reservePool()
└─ 10% → Team Treasury
         └─ public withdrawals, same transparency rules

FORMULA

price = 0.001 + (totalSupply / 1,000,000)

BREAKDOWN

• ├─ Base load: 0.001 ETH per token at zero supply (human model)
• ├─ Linear drift: +1 ETH per token for each +1,000,000 tokens minted
• └─ Result: strictly non-decreasing while buys increase supply

PRICE TABLE (illustrative human supply rows)

“Spot buy” and “mcap” columns reuse the same linear multiplication used in CURRENT STATE for quick mental math. Real fills integrate along the curve—simulate with the contract or an offline integrator before moving size.

KEY PROPERTIES

• ✓ Monotonic while only buys increase supply
• ✓ Deterministic: same global state ⇒ same getPrice()
• ✓ On-chain law: bytecode is the specification
• ✓ Transparent: anyone recomputes from public totals

WHY THIS MATTERS

There is no discretionary market maker. Compare to AMM pairs where routing and liquidity shape can change, or admin mints where policy can shift: here the pricing map is public math. If you disagree with the curve, you simply do not trade—nobody can restate the rules.

USER SELLS TOKENS
      ↓
Exit fee computed from holding timer
      ↓
┌───────────────────────────────────────┐
│ Fee (if any) split automatically      │
└───────────────────────────────────────┘
      ↓
      ├─→ 70% LP Pool
      ├─→ 20% Reserve
      └─→ 10% Team

POOL ANALYTICS (live)

├─ LP Pool (wei→ETH):        — ETH
├─ Reserve (wei→ETH):        — ETH
├─ Team Treasury (wei→ETH):   — ETH
├─ Tracked sum (3 pools):     — ETH
└─ Reserve / tracked sum:     — (diagnostic only)

“Reserve health vs outstanding bonuses” needs aggregate bonus liabilities from state or events—this static site only prints reservePool(). Treat the percentage above as a share of the three tracked balances, not a claims solvency test.

RESERVE HEALTH (qualitative)

Reserve > projected claims  →  All claims payable (invariant-dependent)
Reserve ≈ mid projection      →  Monitor on-chain events
Reserve ≪ projection          →  Claims may revert / queue

LP POOL GROWTH (illustrative — indexer not bundled)

Example only — not wired to an indexer:
├─ Day 1:  1,200 ETH
├─ Day 2:  2,800 ETH
├─ Day 3:  4,150 ETH
├─ Day 4:  5,340 ETH
├─ Day 5:  6,890 ETH
├─ Day 6:  8,750 ETH
└─ Day 7: 12,915 ETH (placeholder)

Ship an indexer or subgraph if you want authentic trailing windows. The live block above always reflects the contract at the last poll.

HOW IT WORKS

1. User buys → contract stamps holdingSince[user] = block.timestamp (name may differ; confirm in ABI).
2. Clock advances per block timestamp.
3. User sells → holdDuration = block.timestamp - holdingSince[user] (converted to minutes / seconds per implementation).
4. Fee tier = deterministic thresholds baked as constants.

TIMER RULES (product)

• ✓ Each new buy resets the timer to “now”.
• ✓ Selling does not itself reset the timer (you exit that position).
• ✓ Transfers: confirm in source whether P2P moves carry timer—do not assume.
• ✓ Only the seller’s clock matters for exit taxation.

EXAMPLE TIMELINE

T0   User A buys 100 tokens
     holdingSince[A] ← block N

T5m  User A buys 50 more
     holdingSince[A] ← block M   (RESET)

T25m User A sells 150 tokens
     Elapsed since last buy = 20m
     Tier = 16–30m → 5% fee

Even if wall-clock “total patience” was 25 minutes, only the 20 minutes since the last buy counts—this closes obvious timer-gaming paths where users drip-buy to stretch a single long window.

BLOCKCHAIN VERIFICATION

Read the mapping directly on Etherscan → Read Contract. If your deployment exposes holdingSince(address), call it with any wallet. Contract: 0x0000…0000

Open Read Contract tab

IMMUTABILITY GUARANTEE

Threshold literals live in bytecode. No admin path can retune minutes or percents without deploying a brand-new contract—which this UI does not hide behind marketing names.

Contract: 0x00000000000000000000000000000000 · Verified source · Read as proxy

CORE FUNCTIONS (WRITE PATH)

buyFromCurve() payable
├─ Input:  msg.value (ETH)
├─ Output: mints tokens to msg.sender
├─ Effect: updates holding timer for buyer
├─ Entry fee: none on buys (per product spec)
└─ Gas:     ~150k (estimate)

sellToCurve(uint256 tokenAmount)
├─ Input:  tokenAmount (wei of tokens, 18d typical)
├─ Output: ETH (net of duration-based fee)
├─ Effect: burns tokens, routes fee to tri-pools
├─ Fee:    25% / 15% / 5% / 0% + bonus path
└─ Gas:    ~200k (estimate)

claimBonus()
├─ Input:  none (pulls accrued bonus accounting)
├─ Output: mints bonus tokens if eligible
├─ Needs:  prior qualifying hold + sell sequence
└─ Gas:    ~180k (estimate)

VIEW FUNCTIONS (READ-ONLY)

getPrice() → uint256
├─ Current curve price (wei per token semantics per source)
└─ Always matches on-chain supply state

totalSupply() → uint256
└─ ERC-20 aggregate minted supply

lpPool() / reservePool() / teamTreasury()
└─ Each returns uint256 wei tallies this UI already polls

Optional (only if deployed):
getPoolStates() → (uint256,uint256,uint256)
getCurrentFeeInfo(address) → (uint8,uint256,string)
holdingSince(address) → uint256

If a selector is missing, Etherscan read calls revert—remove it from your ABI JSON locally or extend the contract. Never trust the marketing site over the verified file.

CONTRACT VERIFICATION

├─ Address:   0x0000…0000
├─ Full URL:  https://etherscan.io/address/0x00000000000000000000000000000000
├─ Interface: ERC-20 + curve + fee logic
└─ Source:    public on Etherscan (verify match)

VERIFY PRICE FORMULA

1. Open Read Contract.
2. Call getPrice().
3. Call totalSupply().
4. Cross-check against the human model 0.001 + (supply / 1e6) with correct decimal scaling.

VERIFY POOLS

Call lpPool(), reservePool(), teamTreasury() (or getPoolStates() if compiled in). Convert wei → ETH with ÷1e18. Compare to the CURRENT STATE panel—they must match block-by-block.

VERIFY EVENT HISTORY

Events tab filters: curve buys/sells, bonus claims, LP injections—whatever the verified ABI exposes.

NO HIDDEN MECHANICS

• ✓ Source code is open.
• ✓ Deployment is immutable (no proxy upgrade path in this product story).
• ✓ Pool balances update only via on-chain txs.
• ✓ Fee routing is automatic—no “ops dashboard”.

TRANSPARENCY COMMITMENTS. We cannot silently change bytecode, suppress events, or rewrite accounting: the chain is the log. This page is only a reader—it never signs transactions.

Read-only entry point used here: https://etherscan.io/address/0x00000000000000000000000000000000#readContract