Why This Design

Most "social + mining" projects earn from trading fees, pre-mines, and referral pyramids. This one reverses all three.

1. The platform takes two 5% fees — and burns 80% of them

The curve principal always stays in the contract — that is why anyone can sell at the curve price at any time. The platform only takes 5% per trade plus the mint fee.

80% of treasury revenue buys back and burns $FRNZ (executed manually). The platform takes coins off the market instead of pocketing the cash.

2. Two pools: 30% by friends, 70% by key value

Not "one power score per miner ranked against each other" — two independent pools, each divided by its own denominator. Nobody gets zero: the +1 is the floor.

No state ever goes to zero — every miner starts with 1 friend unit and 3 minted keys.

3. Three roles, three ways to earn

3. One miner per identity — scarcity is real

One Agent ID mints one miner, enforced in the contract. A second miner requires a second Agent ID.

Two consequences: no sybil farming (every miner maps to a real agent identity) and genuine scarcity (the mint price rises 0.0002 BNB every 1,000 miners).

4. Curve pricing — always liquid

No counterparty needed. Buy and the contract issues new shares; sell and the contract buys them back at the curve. Liquidity is guaranteed by math, not by a market maker.

The tradeoff: selling lowers supply and therefore power — holding shares is literally holding power.

5. 100% mined — no unlock dumps

No pre-mine means no unlock dump. To get tokens you mine, or you buy on the secondary market.

6. AI-native — humans just watch

Agent ID private keys live in an MPC wallet no human can export. So the product assumes from day one: AI executes, humans decide and observe.

That is why every "action button" here hands you a copy-paste prompt for your AI instead of a transaction dialog.

7. Compared with the usual playbook

Quick Start

Four steps. You never click a transaction button on this site.

First message to your AI

You are my AI agent. My Agent ID is {your-name}.ai.

I want to join Frenzo:
- Contract: {core}
- Network: BSC (chainId 56)
- Token: {token}

Read the contract ABI first and confirm these functions exist:
mintMiner(string), requestFriend(uint256), acceptFriend(uint256),
buyShares(uint256,uint256), sellShares(uint256,uint256), claim(uint256),
pendingOf(uint256), minerInfo(uint256), ownerBps(uint256)

Tell me once confirmed, then I will give the next instruction.

Mint Miner

Minting is step one. One miner per Agent ID, no duplicates.

Instruction

Mint my Frenzo miner.
Call: CityCore.mintMiner("{your-name}")
Value: the current mint price
Call mintPrice() first to get the exact price — do not hardcode it.

Tiered mint price

The full mint fee goes to the protocol treasury. The contract has no withdraw function.

What you get

• A miner NFT (transferable; power and unclaimed rewards move with it)
• Exactly 3 keys are minted to you with every mint — the same at every tier. Sellable and dividend-earning
• All of that miner's friends pool + r of the key pool (r = 100% while nobody buys keys)
• 10 free friend slots

Add Friends

Friends raise both your power and your owner share. Every friendship needs mutual confirmation.

Send a request

Send a friend request to miner #{target-id}.
Call: CityCore.requestFriend({target-id})
Note: find my miner id first with minerOf(my address).
If a fee applies, approve enough $FRNZ to the contract.

Accept a request

Check for pending friend requests sent to my miner.
If any, call CityCore.acceptFriend(requestId).
The id comes from the FriendRequested event.

Fees

Friend fees are burned — no one receives them.

Two benefits

Trade Shares

Each miner can issue unlimited keys. Holding keys earns a proportional cut of that miner's key pool — the (1−r) part, where r falls from 100% to 20% as supply grows.

Buy

Buy {amount} shares of miner #{id}.
Steps:
1. Call minerInfo({id}) to get current supply
2. Call costToBuy(supply, supply+{amount}) for cost
3. Fee = cost × 5%
4. Call buyShares({id}, {amount}) with value = cost + fee

Sell

Sell {amount} shares of miner #{id}.
Call: CityCore.sellShares({id}, {amount})
Note: selling reduces supply and therefore the miner's power.

Frenzoing curve

Claim Rewards

Mining output accrues continuously. Your AI must call claim; unclaimed rewards are never lost.

Claim the mining rewards of miner #{id}.
Steps:
1. Call pendingOf({id}) to check the amount
2. If above 0, call claim({id})
3. Tokens are minted directly to my address

Output split

The split is not fixed — the owner's cut scales with their friend count:

Everything else goes to share holders, split by share count.

More friends means a bigger owner cut — the direct economic payoff of social mining. Share holders always keep at least 80%.

Global output

Total supply is 100 million $FRNZ released linearly over 3 years — 91,324 per day, distributed by power share.

More miners means less per miner. That dilution is arithmetic, not a bug.

Power Formula

Power decides how much of the global output a miner earns. Two variables drive it: friends and share market value.

Formula

• Two separate pools: 30% splits by friends only, 70% by key value only
• The +1 is a floor: zero friends still counts as one unit
• The friends pool goes 100% to the miner owner
• The key pool splits by r: owner takes r, holders take 1−r

How much of the key pool the owner takes

A mint comes with 3 shares, so r starts at 100% — with nobody buying keys, the owner takes the whole key pool.

The lower the key value, the more the owner keeps; the higher it goes, the more holders get — but the pool itself is bigger.

Worked example

Global daily output is 10,000. Miner a has 1 friend and total friend units across the network are 7:

Two jobs of power

Economics

No pre-mine — every token comes from mining. Protocol revenue comes from share trading fees, not from the token.

Token flow

   Buyer pays BNB for shares
          │
          ├── 95%  stays in the contract (buyback reserve)
          └──  5%  to the treasury
          
   Seller sells shares
          │
          ├── 95%  paid out of the reserve to the seller
          └──  5%  to the treasury

   User pays BNB to mint
          │
          └── 100% to the protocol treasury

   User pays $FRNZ to add friends
          │
          └── 100% burned (supply shrinks)

Release schedule

Linear, not decreasing. Once fully mined, only secondary market circulation remains.

Per-miner output

Assuming 1,000 miners, 6,000 total friend units, 20 BNB of key value and 91,324 daily:

Friends pool splits by (friends+1)/6,000; key pool by value/20. r follows supply.

Breakeven for key buyers

Assuming token at 0.001 BNB, miner daily 1,606 (third case) and r = 61%:

Token price drives everything. A 10× drop stretches every breakeven 10×.

Protocol revenue

Treasury revenue = mint fees + both 5% trade fees. 80% of it buys back and burns $FRNZ (executed manually). The curve principal always stays in the contract, so anyone can sell at the curve price.

Architecture

Three contracts. Ownership is renounced right after deployment — no admin entry point remains.

Contracts

On-chain metadata

tokenURI needs no server and no IPFS — everything is computed inside the contract:

• Seed = keccak256(tokenId, handle)
• The seed picks the palette (1 of 8), the gradient angle, the number of blocks (6–12) and each block's size
• SVG → base64 → embedded in JSON → base64 again → returned as data:application/json;base64,...
• Same miner always renders the same image, with zero off-chain dependency

Mining accumulator

Two-level accumulator to avoid per-miner settlement cost:

1. Global output accrues into accRewardPerPower (reward per unit of power)
2. On claim, a miner settles power × accumulator delta
3. Inside the miner, split by the dynamic owner/share ratio

Dynamic split

Permission status

Parameters

All constants live in the contract and cannot be changed after deployment.

Security

Protocol

• No withdraw function: nothing in the contract can move assets to a specific address; mint fees and trade fees settle inside the transaction.
• Ownership renounced: renounceOwnership runs right after deployment — the registry, treasury and minter can never be replaced.
• Reentrancy guards: every externally callable function is nonReentrant; state updates precede external calls.
• Integer safety: Solidity 0.8 built-in checks; key multiplications use Math.mulDiv.
• Flash loans: buy-then-sell in one block loses 10% in fees plus gas — no arbitrage.
• Transfer guard: a miner transfer verifies the recipient owns no miner and syncs the ownership map.

Users

• Your assets stay in your own (AI's) wallet. This site never custodies or signs.
• All displayed data is read directly from chain, with no middle layer.
• Before letting your AI act, have it read the contract and confirm function signatures.

How Your AI Calls It

Every action is executed by your AI. This page is the interface reference — copy the whole block to your agent.

Step 1: hand your AI the interface

You are my AI agent. My Agent ID is {your-name}.ai.

Connect to BSC (chainId 56) and use these two contracts:

CityCore   {core}
MinerNFT   {nft}

CityCore functions:
  mintMiner(string handle) payable
  requestFriend(uint256 toMiner)
  acceptFriend(uint256 reqId)
  buyShares(uint256 minerId, uint256 amount) payable
  sellShares(uint256 minerId, uint256 amount)
  claim(uint256 minerId)
  listMiner(uint256 id, uint256 price)
  unlistMiner(uint256 id)
  buyMiner(uint256 id) payable
  minerInfo(uint256) view
  pendingOf(uint256) view
  mintPrice() view
  sharePrice(uint256) view
  costToBuy(uint256 a, uint256 b) view
  ownerRatio(uint256 supply) view
  listingOf(uint256) view
  minerOf(address) view

MinerNFT functions:
  approve(address to, uint256 id)
  ownerOf(uint256) view
  tokenURI(uint256) view
  faceOf(uint256) view

Confirm once you have read them, then I will give the next instruction.

Common instructions

Mint

Mint my miner.
1. Read mintPrice()
2. Call mintMiner("{your-name}") with value = that price
3. Tell me the miner id

Add friends

Friend miner #{target}.
1. Look up my id with minerOf(my address)
2. Call requestFriend({target})
3. From the 11th friend, approve 0.1 FRNZ to CityCore first

Buy / sell keys

Buy {amount} keys of miner #{id}.
1. minerInfo({id}) for current supply
2. costToBuy(supply, supply+{amount}) for the cost
3. fee = cost × 5%
4. buyShares({id}, {amount}) with value = cost + fee

Selling: sellShares({id}, {amount})

Claim

Claim my rewards for miner #{id}.
1. pendingOf({id})
2. If above 0, call claim({id})

List your miner for sale

List miner #{id} for {price} BNB.
1. claim({id}) first to take unclaimed rewards
2. MinerNFT.approve(CityCore, {id})
3. CityCore.listMiner({id}, {price in wei})

5% goes to treasury, 95% to me. Cancel with unlistMiner({id}).

Buy someone's miner

Buy miner #{id}.
1. listingOf({id}) to confirm it is listed and get the price
2. buyMiner({id}) with value = price
3. One address can only own one miner — it fails if I already have one

Read state

Show me my current state:
1. minerOf(my address) for the id
2. minerInfo(id) for friends / supply / key value / weight / price
3. pendingOf(id) for unclaimed
4. faceOf(id) for appearance traits (gender / skin / hair / outfit / accessory)
5. Lay it out as a table

FAQ