---
name: pixcade
description: Use PIXCADE ($PXCD) on BNB Chain: free mint with a .ai Agent ID, pay-what-you-want mint, gift mint, claim mining tickets, play the claw machine (commit then reveal), and trade on the 0%-fee market.
---

# PIXCADE ($PXCD) · skill for AI agents

PIXCADE is 3,000 fully on-chain pixel arcade cabinets on **BNB Smart Chain (chainId 56)**. Site: https://pixcade.pages.dev

| | |
|---|---|
| NFT (Pixcade, ERC-721) | `0x21136e5ecBE886572b59a7e5B5D576fcE9534b89` |
| Arcade (mining + claw) | `0x3a6c7D41c2540f69801BDA9162CC9769Db116b66` |
| Market (0% fee) | `0xE5E66D39218976EC4b99c343e6a6a6F371Abd68f` |
| Renderer | `0x40EBCAd8885a02Fb6b9B5b22A03EA49B23903f71` |
| RPC | `https://bsc-dataseed.bnbchain.org` |
| Status | live since block 131113915 |

Nothing here promises value or profit. Fees are not refundable. Contracts are unaudited. Always read the switches first and simulate (`eth_call`) before sending.

## 1. Read state

`Pixcade.stats()` returns `uint256[14]`:
`[totalMinted, freeMinted, giftMinted, minPrice, maxPerWallet, revealStage, totalRaised, flags, neonAt, goldAt, payersCount, standardCount, neonCount, goldCount]`.
`flags` bits: 1 = paid mint open, 2 = free mint open, 4 = gift open, 8 = renderer locked.

`Pixcade.walletInfo(wallet)` returns `uint256[7]`: `[paidMinted, totalPaid, giftCredits, freeClaimed, giftReceived, isAgent, paidMintsLeft]`.

## 2. Free mint with a .ai Agent ID

- Your wallet must hold a .ai Agent ID: registry `0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F`, `balanceOf(wallet) > 0`.
- **1 free cabinet per Agent ID wallet; 1,500 free in total.** Free cabinets are Standard tier.
- Call `freeMint()` with no value (gas only). Reverts: `free mint off`, `already claimed`, `free cap reached`, `no Agent ID`, `sold out`.

## 3. Pay-what-you-want mint

- `mint(qty)` payable. `value / qty` must be ≥ `minPrice` (0.0003 BNB at launch). Max 7 paid cabinets per wallet (`maxPerWallet`).
- Tier is set by what you pay **per cabinet** (`value / qty`) and never changes: < 0.0005 Standard, ≥ 0.0005 Neon, ≥ 0.001 Gold (read `neonAt` / `goldAt`).
- The whole `value` is forwarded to the project wallet in the same transaction; nothing is refunded, so send exactly what you mean to pay.
- Example: `mint(2)` with `value = 0.002 BNB` → 2 Gold cabinets.

## 4. Gift mint

- Every 2 paid cabinets earn 1 gift credit (`giftCredits(wallet)`).
- `giftMint(to)` mints a free Standard cabinet to `to`. Rules: `to` ≠ you, each wallet can receive only 1 gift ever, 300 gifts in total.

## 5. Reveal stages

`revealStage()` advances automatically with supply: 0 (< 750 minted, silhouette) → 1 (≥ 750, cabinet + marquee) → 2 (≥ 1,500, side art + controls) → 3 (≥ 2,250, game on screen) → 4 (3,000, rare effects). Traits are fixed at mint by a seed; `tokenURI` is on-chain JSON + SVG.

## 6. Ticket mining

- Mining runs for 30 days from the moment the owner first switches it on (`Arcade.stats()[2]` = start, `[3]` = end).
- Each cabinet accrues Standard 10, Neon 15, Gold 25 tickets per day (pro-rata by second). Cabinets minted later also accrue from the start.
- `claimable(id)` / `claimableMany(ids)` to check, then `claim(ids)` as the **current holder** (gas only). Unclaimed tickets stay with the cabinet if it is sold.
- Tickets are a non-transferable balance (`tickets(wallet)`), only spent in the claw machine.

## 7. Claw machine (commit → reveal)

1. `play()` payable with `value = clawFee` (0.0001 BNB at launch); it also burns `ticketCost` tickets (50). Emits `ClawPlayed(playId, player, fee, ticketsPaid, targetBlock)`.
2. Wait until `block.number > targetBlock` (next block), then call `reveal(playId)`. Anyone may reveal; prizes always go to the player. Use `pendingOf(wallet, 400)` to find unrevealed plays.
3. Result `ClawResult(playId, player, prize, bnbWon, bonusTickets)`: 0.5% win 20% of the pot, 4% win 3%, 20% win 0.5%, the rest get 5–30 bonus tickets. Every BNB prize is capped by `maxWin` and can never exceed the pot.
4. If nobody reveals within 256 blocks, `reveal` returns only 5 tickets (the fee stays in the pot). Reveal promptly.

Fee split: 60% stays in the pot, 40% goes to the project wallet. The pot can only leave the contract as claw prizes: there is no owner withdrawal. Anyone may add to it with `fund()`.

## 8. Market (0% fee)

- Approve once: `Pixcade.setApprovalForAll(MARKET, true)`, then `list(id, priceWei)`. The cabinet stays in your wallet.
- `buy(id)` with `value = price`: 100% goes to the seller. A listing is void once the cabinet moves (even if it comes back) or approval is revoked: check `isValid(id)`.
- `listingsIn(1, 3000)` returns valid listings; `cancel(id)` removes yours.

## Script example (ethers v6)

```js
import { ethers } from "ethers";
const p = new ethers.JsonRpcProvider("https://bsc-dataseed.bnbchain.org");
const w = new ethers.Wallet(process.env.PK, p);              // never paste keys into chats
const nft = new ethers.Contract("0x21136e5ecBE886572b59a7e5B5D576fcE9534b89", NFT_ABI, w);
const arc = new ethers.Contract("0x3a6c7D41c2540f69801BDA9162CC9769Db116b66", ARCADE_ABI, w);
if ((await nft.walletInfo(w.address))[5] === 1n) await (await nft.freeMint()).wait();    // free with Agent ID
await (await nft.mint(1, { value: ethers.parseEther("0.0005") })).wait();               // Neon
const rc = await (await arc.play({ value: await arc.clawFee() })).wait();
const id = rc.logs.map(l => { try { return arc.interface.parseLog(l) } catch {} }).find(e => e?.name === "ClawPlayed").args.playId;
while (await p.getBlockNumber() <= Number((await arc.plays(id)).commitBlock) + 1) await new Promise(r => setTimeout(r, 1500));
await (await arc.reveal(id)).wait();
```

## ABIs (human-readable)

NFT:
```
function approve(address to, uint256 tokenId)
function freeMint()
function giftCredits(address a) view returns (uint256)
function giftMint(address to)
function isAgent(address a) view returns (bool)
function mint(uint256 qty) payable
function ownerOf(uint256 tokenId) view returns (address)
function payersIn(uint256 start, uint256 end) view returns (address[] a, uint256[] paid, uint256[] minted)
function revealStage() view returns (uint256)
function seedOf(uint256 id) view returns (uint256)
function setApprovalForAll(address operator, bool approved)
function stats() view returns (uint256[14] s)
function tierOf(uint256 id) view returns (uint8)
function tokenURI(uint256 id) view returns (string)
function tokensOfOwnerIn(address o, uint256 start, uint256 end) view returns (uint256[] ids)
function walletInfo(address a) view returns (uint256[7] w)
```
Arcade:
```
event ClawExpired(uint256 indexed playId, address indexed player, uint256 ticketsRefunded)
event ClawPlayed(uint256 indexed playId, address indexed player, uint256 fee, uint256 ticketsPaid, uint256 targetBlock)
event ClawResult(uint256 indexed playId, address indexed player, uint8 prize, uint256 bnbWon, uint256 bonusTickets)
function accrued(uint256 id) view returns (uint256)
function claim(uint256[] ids)
function claimable(uint256 id) view returns (uint256)
function claimableMany(uint256[] ids) view returns (uint256 sum)
function fund() payable
function outcome(uint256 r) view returns (uint8 prize, uint256 win, uint256 bonus)
function pendingOf(address who, uint256 lookback) view returns (uint256[] ids)
function play() payable returns (uint256 id)
function playersIn(uint256 start, uint256 end) view returns (address[] a, uint256[] claimed, uint256[] won, uint256[] wins, uint256[] nplays)
function plays(uint256) view returns (address player, uint64 commitBlock, uint32 ticketsPaid, uint8 state)
function reveal(uint256 id)
function revealMany(uint256[] ids)
function stats() view returns (uint256[12] s)
function tickets(address) view returns (uint256)
```
Market:
```
function buy(uint256 id) payable
function cancel(uint256 id)
function isValid(uint256 id) view returns (bool)
function list(uint256 id, uint256 price)
function listings(uint256) view returns (address seller, uint96 nonce, uint256 price)
function listingsIn(uint256 start, uint256 end) view returns (uint256[] ids, address[] sellers, uint256[] prices)
function marketOn() view returns (bool)
```