BSC Agent — From Fragments to Core

◆ Mint Fragments

◆ Stake & Mine

Mint more = mine faster. Every extra Fragment you stake doubles your speed: 5 staked = x16.

◆ Rules (enforced by the contract)

◆ BSCA V2: migration, Reward Vault & Daily Draw

BSCA moves to V2 after Mining ends on 9 Nov 2026 (04:03 UTC+7). Swap old BSCA 1:1, earn BNB from every trade, and help grow a locked PancakeSwap pool.

◆ How it works

◆ Timeline

◆ V2 contracts (BSC, chain 56)

Fee 2% of sale price (1% platform + 1% royalty), paid by the seller. Bids are collection-wide: any token can fill them.

Listings

◆ Agent skill (SKILL.md)

Give this to your AI agent so it can mint, fuse, trade and claim safely. It always simulates and asks you to confirm before signing.

The skill text is in English for agent compatibility.

---
name: bsc-agent-mint
description: Mint BSC Agent Fragments, stake Fragments to mine BSCA, fuse 5 Fragments into a Core, trade on the BSC Agent markets, and claim BSCA rewards on BNB Smart Chain (chain 56). Use when an agent or user asks to mint, stake, unstake, fuse, bid, list, buy, or claim for the "BSC Agent" project.
---

# BSC Agent — From Fragments to Core

One .ai identity opens the door. Mint Fragments, stake them to mine BSCA (5 staked = x16), or fuse 5 into a Core.

Network: BNB Smart Chain mainnet, chain id 56 (0x38).
Read RPC: https://bsc-dataseed.bnbchain.org (fallback https://bsc-mainnet.public.blastapi.io)
Logs (eth_getLogs, ≤5,000-block chunks from block 129522000): https://bsc-rpc.publicnode.com — bsc-dataseed rejects getLogs.

## Golden rule

Always show the simulation result (eth_call / staticCall + gas estimate) and the exact
contract, function, arguments and BNB value to the user, and get the user's explicit
confirmation before signing ANY transaction. If the simulation reverts, do not send.

## Contracts (BSC, chain 56)

| Name | Address |
|---|---|
| Fragment (ERC-721) | 0xadEC4072dAAb830017d82189734696A9cCe834dD |
| Core (ERC-721) | 0x71A7aaDe687Ba7610755f594046a9Dbf286B70b9 |
| BSCA token (ERC-20, 21,000,000) | 0x6528D8A2aB01445a2B7Df8785733933cD9aa4468 |
| Mining | 0xd8e1897197992368a7F4e643cC3Af11df1F1e881 |
| Fragments Market | 0xd8Ff7F85CdA30aED53000922d9D020B708E46c85 |
| Cores Market | 0xd28fd4656c5991421f3AB3B01EE0C226F247e1eD |
| Liquidity Locker | 0xfE7b30305020825a63382978cd754e6bcd7F2b4a |
| Fragment Staking (Stake & Mine) | 0xF1AdDB99fc10A1B4A9Ba97a8253a3c3aB8FB4A64 |
| .ai Agent ID registry (external, read only) | 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F |

## 1. Eligibility (original mint only)

- The minting wallet must hold a Binance .ai Agent ID:
  `AgentIDRegistry.balanceOf(wallet) > 0` on 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F.
  If it is 0, the mint reverts with `NotAgent()` — stop and tell the user.
- Fusion, market trading and mining claims do NOT need a .ai Agent ID.

## 2. Mint Fragments

Supply: 5,000 Fragments. Max 5 original mints per wallet.
Price ladder per wallet: 1st FREE, 2nd 0.001, 3rd 0.002, 4th 0.003, 5th 0.005 BNB.

Steps:
1. `Fragment.mintOpen()` must be `true` (else `MintClosed()`).
2. `Fragment.totalMinted() + qty <= 5000` (MAX_SUPPLY).
3. `Fragment.mintedBy(wallet) + qty <= 5` (MAX_PER_WALLET); choose `qty` accordingly.
4. `value = Fragment.quote(wallet, qty)` — use this exact wei amount as msg.value.
5. Simulate `Fragment.mint(qty)` with `{ from: wallet, value }` (eth_call + estimateGas).
   Show the result and the cost to the user and wait for confirmation.
6. Send `Fragment.mint(qty)` with `value`. Report the tx hash as https://bscscan.com/tx/<hash>.

Mint revenue: 50% to the Liquidity Locker, 50% to the treasury.

## 3. Stake & Mine (Fragment Staking)

Contract: 0xF1AdDB99fc10A1B4A9Ba97a8253a3c3aB8FB4A64 (verified on BscScan).
Mint more = mine faster. Reward pool: 1,000,000 BSCA, emitted linearly over 15 days
(`startTime()` → `endTime()`), shared by weight. No .ai Agent ID needed to stake.

- Weight per wallet by number of Fragments staked (max 5 per wallet):
  1 → x1, 2 → x2, 3 → x4, 4 → x8, 5 → x16 (`weightFor(n)`).
- Your share of emission = `weightOf(wallet) / totalWeight()`; `rewardRate()` = BSCA wei per second.
- Emission while nobody is staked is not lost: it rolls over to the next stakers.
- Custodial: staked Fragments are held by the contract; `unstake` returns the exact token IDs.
  The owner has no function to move staked Fragments. After `endTime()` the owner can only
  recover BSCA that was never allocated to stakers (`recoverUnallocated`); earned rewards stay claimable.

Reads: `pending(wallet)` (claimable BSCA, 18 decimals), `stakedOf(wallet)` (uint256[] ids),
`stakedCount(wallet)`, `weightOf(wallet)`, `totalWeight()`, `totalStaked()`, `rewardRate()`,
`startTime()`, `endTime()`, `CLAIM_FEE()` (= 0.0001 BNB), `stakerOf(id)`, `unallocatedEmission()`.

Stake (choose one):
- A) With approval: if `Fragment.isApprovedForAll(wallet, Staking)` is false, simulate + confirm
  `Fragment.setApprovalForAll(Staking, true)`; then simulate + confirm `Staking.stake([ids])`;
  then offer to revoke with `Fragment.setApprovalForAll(Staking, false)`.
- B) No approval: `Fragment.safeTransferFrom(wallet, Staking, id)` (one tx per id) stakes that id for the wallet.
- Reverts: "Max 5 per wallet", "Not owner", "No ids".

Unstake (free, no fee; rewards are settled and stay claimable):
- `Staking.unstake([ids])` (only ids you staked, else "Not your stake") or `Staking.unstakeAll()`.

Claim:
- `Staking.claim()` with `value = CLAIM_FEE()` exactly (0.0001 BNB = 100000000000000 wei).
  Pays all pending BSCA. The fee is forwarded in the same tx to the project wallet
  0x53FddB2Fbfceb049c599941a09f4a1d95307e3B4. Reverts: "Fee is 0.0001 BNB", "Nothing to claim".
- Staked Fragments can't be fused or sold until unstaked.

Honest note: BSCA has NO PancakeSwap liquidity yet. Liquidity only gets added from the
Liquidity Locker after mint revenue accumulates, so BSCA can't be sold for BNB today.

## 4. Fuse 5 Fragments into 1 Core

- Max 1,000 Cores. Fee `Core.FUSION_FEE()` = 0.0005 BNB (must be exact). No .ai Agent ID needed.
- Steps:
  1. `Core.fusionOpen()` must be `true`; `Core.totalSupply() < 1000`.
  2. Pick exactly 5 distinct Fragment IDs owned by the wallet (`Fragment.ownerOf(id) == wallet`).
  3. If `Fragment.isApprovedForAll(wallet, Core)` is false: simulate, confirm, then send
     `Fragment.setApprovalForAll(Core, true)`.
  4. Simulate `Core.fuse([id1,id2,id3,id4,id5])` with `value = FUSION_FEE`, confirm, send.
     The 5 Fragments are burned and a Core is minted to the wallet.
  5. Offer to revoke: `Fragment.setApprovalForAll(Core, false)`.

## 5. Core Mining (BSCA)

- LIVE: `Mining.startTime()` = 1792875788 (2026-10-25 04:03:08 UTC+7 / 2026-10-24 21:03:08 UTC);
  ends 1794171788 (2026-11-09 04:03:08 UTC+7). 16,000,000 BSCA emitted linearly over 15 days
  (`Mining.DURATION()`), split equally per live Core (`Mining.totalCores()`).
- Per-Core rate now ≈ remaining emission ÷ days left ÷ live Cores (≈1,066,667 BSCA/day in total).
- While `totalCores() == 0`, emission is not lost: the first Core takes 100% plus everything
  emitted so far (rolled over).
- Choosing a path for 5 Fragments: stake them (x16 weight in the 1,000,000 BSCA staking pool,
  reversible) or fuse them into 1 Core (equal share of the 16,000,000 BSCA mining pool,
  Fragments burned). Compare with live numbers (staking `rewardRate()`/`totalWeight()` vs
  `Mining.totalCores()`), never promise returns. BSCA has no PancakeSwap liquidity yet.
- Past rewards stay with the holder at the time they accrued; after a Core is sold, future
  weight follows the buyer.
- `Mining.claimable(wallet, coreIds)` → pending BSCA (18 decimals).
- Simulate, confirm, then `Mining.claim(coreIds)` (caller must own every Core in the list).

## 6. Markets (Fragments Market and Cores Market — same ABI)

Fee: 2% of the sale price (1% platform + 1% royalty), paid by the seller. Minimum price 0.000001 BNB.

- Bids (collection-wide, funded in BNB):
  - `placeBid()` payable, `msg.value` = bid price.
  - `bids(id)` → (bidder, price, active); ids are `0 .. nextBidId()-1`.
  - `cancelBid(bidId)` (bidder only) refunds the bid.
  - Seller fills with `fillBid(bidId, tokenId, minPrice)` after `NFT.approve(market, tokenId)`;
    set `minPrice` = the bid price you saw. Seller receives price × 98%.
- Listings:
  - `list(tokenId, price)` after `NFT.approve(market, tokenId)`.
  - `listings(id)` → (seller, tokenId, price, active); ids are `0 .. nextListingId()-1`.
  - `buyListing(listingId)` payable with `msg.value == price` exactly.
  - `cancelListing(listingId)` (seller only).
- If a direct BNB payout fails it is credited: check `credits(wallet)` and call `withdrawCredit()`.

## 7. Tokenomics (BSCA, 21,000,000 total)

- 16,000,000 — mining (15 days, equally per Core)
- 4,000,000 — held by the Liquidity Locker; paired on PancakeSwap only once mint revenue has accumulated there, LP then locked 15 days. No pool exists yet.
- 1,000,000 — official allocation, deposited into Fragment Staking as the 15-day staking reward pool

## Safety

- Read state first, simulate every write, show the user the simulation and the exact cost,
  and get confirmation before signing. Never sign on a failed simulation.
- Only use the addresses above; verify on https://bscscan.com.
- Revoke approvals you no longer need.
- Experimental project, not affiliated with Binance. DYOR.