This page hosts the Neo Tokyo Contract Navigator skill for AI agents. To use it, fetch the raw page text via ?action=raw and take the content inside the pre blocks.
SKILL.md
# Neo Tokyo Contract Navigator ## Purpose Teach members to verify contract addresses and read contracts on Etherscan themselves — verify, don't trust. This is the "verify" pillar of Neo Tokyo self-sufficiency: instead of asking in chat whether an address is legit or what a function does, members learn to check the chain directly. It covers the proxy pattern behind every Neo Tokyo NFT contract, the address cross-checks that prove an address is genuine, the most useful read/write functions on each contract, and how to use Etherscan's Read/Write tabs. Like the mechanic skill, it guides members through transactions they sign themselves; it never touches keys. ## Terminology Same convention as the rest of the suite, because "Citizen" is a community catch-all: - **Citizen** = Season 1 (S1) Citizen. An unqualified "Citizen" always means S1 here. - **Outer Citizen** = Season 2 (S2) Citizen. Always called "Outer Citizen," never shortened to "Citizen." - Where a rule covers both seasons, this skill says **"Citizens and Outer Citizens"** explicitly. - **The Citadel** = the Neo Tokyo community itself — the Discord server and its members. ## Privacy Neo Tokyo is a pseudonymous community. Wallet addresses are public on the blockchain, but they are still someone's pseudonym — treat them with the same care as a real name. - Never attempt to link a wallet address to a real-world identity, Discord handle, or any other off-chain identity. This skill works with addresses as opaque identifiers only. - Never record, publish, or share another member's position, holdings, or transaction history without their explicit consent. - Examples use constructed hypothetical addresses and positions, never a real member's. - The only credential this skill touches is the user's own Etherscan API key for reads (see Auth). It is never logged, stored in files, or transmitted anywhere except the Etherscan API. - This skill never asks for, accepts, or handles anyone's private keys or seed phrases. All transactions are signed by the member in their own wallet. ## The proxy pattern — read this first Six of the eight contracts below are **ERC1967 proxies**: the address members use (the proxy) holds the state, while the logic lives in a separate implementation contract. On Etherscan this means: - The proxy's own *Read Contract* / *Write Contract* tabs show almost nothing — its ABI is nearly empty. **This is expected, not broken.** - The real functions appear under the ***Read as Proxy*** and ***Write as Proxy*** tabs. That is where `disassembleCitizen` lives. - **The #1 beginner mistake:** "I can't find `disassembleCitizen` on the Citizen contract." You're on the *Write Contract* tab. Switch to *Write as Proxy*. - **Correction:** `proxiableUUID()` reverts when called through a proxy — it carries the `notDelegated` modifier, so call it directly on the *implementation* address instead. To find the implementation behind a proxy, read the ERC1967 implementation slot (`0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`) with `eth_getStorageAt`, or check the proxy information on the contract's Etherscan page. - The $BYTES token and the NeoTokyoStaker are **not** proxies — use their plain *Read Contract* / *Write Contract* tabs. ## Verifying an address — the core workflow Never trust an address pasted in chat or DMs. Check it yourself: 1. Paste the address into Etherscan's search bar. 2. Confirm the contract is **verified** (green checkmark) and the **contract name** matches what you expect (e.g. `NTS1Citizen`, `BYTES2`, `NeoTokyoStaker` — full names below). 3. For a token, read `name()`, `symbol()`, and `decimals()` — a fake token often has a subtly wrong name or wrong decimals. Real $BYTES: 18 decimals. 4. **Cross-check against the staker.** The NeoTokyoStaker exposes the addresses it is wired to: `S1_CITIZEN()`, `S2_CITIZEN()`, `IDENTITY()`, `VAULT()`, `BYTES()`, `NT_STAKED_CITIZEN()`. Read each and compare to the address you're checking. If any doesn't match the known list, stop. 5. The $BYTES token cross-checks back: its `STAKER()` must return the staker address, and its `S1_CITIZEN()` must return the S1 Citizen proxy. ## Contract directory (Ethereum mainnet) Proxy address = what you paste into Etherscan. READ = free, no signature (*Read Contract* / *Read as Proxy*). WRITE = costs gas, signed in your own wallet. **S1 Citizen** — proxy `0xb9951b43802dcf3ef5b14567cb17adf367ed1c0f` (impl `0xe26bdc753ad17619f0f0a3c240932ed6c7374e75`, verified name `NTS1Citizen`) - READ: `ownerOf(tokenId)`, `balanceOf(owner)`, `tokenOfOwnerByIndex(owner, index)`, `tokenURI(tokenId)`, `totalSupply()`, `name()`, `symbol()` - READ (component lookups): `getIdentityIdOfTokenId`, `getVaultIdOfTokenId`, `getItemCacheIdOfTokenId`, `getLandDeedIdOfTokenId` (each takes a citizenId, returns the component token ID) — see exactly what's inside any Citizen. - READ: `getSpecialMessageOfTokenId`, `getGenderOfTokenId`, `getCreationTimeOfTokenId`, `getCitizenMigrated` (whether it went through the 2023 migration) - WRITE (via *Write as Proxy*): `disassembleCitizen(citizenId)`; `createCitizen(identityId, vaultId, itemCacheId, landDeedId, genderFemale, specialMessage)` (the on-chain assembly — four components, in order); `changeGender(tokenId)` and `changeSpecialMessage(tokenId, message)` (both cost $BYTES) **S2 Outer Citizen** — proxy `0x4481507cc228fa19d203bd42110d679571f7912e` (impl `0xe28bab67c1d1cf4bc59ba66ad41346c7268394a3`, `NTS2Citizen_V2`) - Same core READ set as S1, plus `citizenData(tokenId)` (packed S2 data struct). - WRITE (via *Write as Proxy*): `disassembleCitizen(citizenId)`; `createCitizen(identityId, itemCacheId, landDeedId, genderFemale, specialMessage)` — **no vault parameter**. This is the on-chain proof that S2 Outer Citizens don't use vaults. **S1 Identity** — proxy `0x059174c2fef43f06178d23572fe5556f078f2f99` (impl `0x26e79d1298589886172bdfd35655c1027dced93c`, `NTS1Identity_V2`) - READ (traits, each takes tokenId, returns string): `getCredits` (the credit-yield tier — drives staking yield), `getClass`, `getRace`, `getGender`, `getAbility`, `getCool`, `getStrength`, `getIntelligence`, `getTechSkill`, `getEyes`, `getAttractiveness` - WRITE: `mintIdentity()` (costs $BYTES) **S1 Vault** — proxy `0x17b2f2b8927a8f11edfd7a27e153be17d68e69c7` (impl `0xe0e3eb007746db37481e49bcbe0870f4332c9698`, `NTS1Vault_V2`) - READ: `getCreditMultiplier(tokenId)` — **the single most important Vault read** (multiplies staking yield); `getCredits(tokenId)`, `getAdditionalItem(tokenId)`, `getClaimantIdentityIdByTokenId` / `getTokenClaimedByIdentityTokenId` (which Identity claimed which Vault, both directions) **S1 Item Cache** — proxy `0xe7489ea1847395d7eead33e9c85fe327d513d249` (impl `0xa686d108e03354bd0ff9bcecfa3c7f2587113b9e`, `NTS1Item`) - READ: `getWeapon`, `getHelm`, `getVehicle`, `getApparel` (each takes tokenId, returns string), `checkSpecialItems(tokenId)` - WRITE: `buyItems()` (costs $BYTES) **S1 Land Deed** — proxy `0xcfc6a15b2952b6014a993a0c16c9d580d862e21a` (impl `0x8e4cb89a9e281924e36f82a697722f117ac94550`, `NTS1Land`) - READ: `getLocation(tokenId)`; claim-relationship lookups in both directions (`getTokenClaimedByIdentityTokenId`, `getClaimantIdentityIdByTokenId`, and the Item Cache / Vault variants) - WRITE: `buyLand()` (costs $BYTES) **$BYTES token** — `0xa19f5264f7d7be11c451c093d8f92592820bea86` (verified name `BYTES2`, **not** a proxy) - READ: `name()`, `symbol()`, `decimals()` (must be **18**); `balanceOf(account)`; `totalSupply()`; `allowance(owner, spender)` (check what you've approved — revoke stale approvals) - READ (cross-checks): `STAKER()`, `S1_CITIZEN()`, `TREASURY()`, `BYTES1()` (legacy 1.0 contract) - WRITE: `transfer(to, amount)`, `approve(spender, amount)`, `increaseAllowance` / `decreaseAllowance` - **Decimals gotcha:** every raw `uint256` amount from `balanceOf` or reward reads must be divided by 10^18 to read as $BYTES. When *writing* an amount (transfer, approve), multiply by 10^18. This is the #1 beginner mistake. **NeoTokyoStaker** — `0x67e1ecfa9232e27eaf3133b968a33a9a0dca9e16` (verified name `NeoTokyoStaker`, **not** a proxy) - READ (address cross-checks — the verify-don't-trust toolkit): `S1_CITIZEN()`, `S2_CITIZEN()`, `IDENTITY()`, `VAULT()`, `BYTES()`, `NT_STAKED_CITIZEN()` (soulbound CTZN, `0xd37ea75dd3c499eda76304f538cbf356ed9e7ed9`) - READ (positions & rewards): `getPendingPoolReward(assetType, wallet)` (0 = S1, 1 = S2 — see below), `getStakerPosition(wallet, assetType)`, `getStakerPositions(wallet)`, `stakedS1` / `stakedS2`, `lastRewardTime`, `rewardAccrued`, `getCreditYield(citizenId, vaultId)`, `getConfiguredVaultMultiplier(vaultId)`, `VAULT_CAP()` (2,000), `NO_VAULT_CAP()` (200) - WRITE: `stake(assetType, timelockId, …)`, `withdraw(assetType, …)` (reverts until the timelock fully clears), `claimReward(recipient)` (not blocked by the timelock — claim anytime) **Shared asset-type enum** (staker `stake` / `withdraw` / `getPendingPoolReward` / `getStakerPosition`): `0` = S1 Citizen, `1` = S2 Outer Citizen, `2` = $BYTES, `3` = LP. ## Checking for unclaimed mints Several Neo Tokyo NFTs could mint or claim later NFTs, and an unclaimed one adds value. Answer "does this item have unclaimed ___?" with these reads (all on *Read as Proxy* of the proxy address). Each returns a token ID: `0` means nothing has been claimed (unclaimed), any other number is the claimed token's ID. - **Identity → Vault:** Vault contract (`0x17b2f2b8927a8f11edfd7a27e153be17d68e69c7`) → `getTokenClaimedByIdentityTokenId(identityId)`. - **Identity / Item Cache / Vault → Land Deed:** Land Deed contract (`0xcfc6a15b2952b6014a993a0c16c9d580d862e21a`) → `getTokenClaimedByIdentityTokenId(identityId)`, `getTokenClaimedByItemCacheTokenId(itemCacheId)`, or `getTokenClaimedByVaultTokenId(vaultId)`. - **Reverse lookups** (which Identity claimed this Vault or Land): `getClaimantIdentityIdByTokenId(tokenId)` on the Vault or Land Deed contract. **Unopened Vaults (the $BYTES inside):** unopened Vaults still contain their initial $BYTES; opening one withdraws it into a wallet, and opening requires an S1 Identity that has never opened a vault. Check status on the legacy $BYTES 1.0 contract `0x7d647b1a0dcd5525e9c6b3d14be58f27674f8c95` (*Read Contract* tab): - `hasVaultBoxBeenOpened(vaultId)` → `false` = unopened (still contains its $BYTES), `true` = opened. - `identityBoxOpened(identityId)` → nonzero = that Identity has already opened a vault, `0` = it hasn't (and can still open one). ## Etherscan Read/Write primer - **Read tab** (or *Read as Proxy*): free, no wallet needed. Paste the contract address, open the tab, expand a function, enter parameters, click Query. - **Write tab** (or *Write as Proxy*): costs gas. Click "Connect to Web3", connect your own wallet (e.g. MetaMask) on Ethereum mainnet, enter parameters, click Write, confirm in your wallet. - **Approve-before-stake:** to stake $BYTES (asset type 2), first call `approve` on the $BYTES token with the staker as spender — then call `stake`. Skip the approval and the stake reverts. - **Admin functions** (`upgradeTo`, `setConfig`, ownership transfers) exist on every contract. Members should never touch them. If a guide tells you to, it's a scam. - After any write, find your transaction hash on Etherscan and confirm it succeeded before assuming anything happened. ## Safety rules - **Verify every address** with the workflow above before interacting. Never trust an address pasted in chat or DMs — not even from a familiar name. - If a cross-check read returns an address that doesn't match the known list, **stop** and ask in the Citadel before proceeding. - Never share private keys or seed phrases with anyone, including anyone claiming to help you verify something. - Reads are free and safe — when in doubt, read first. ## Auth - **Reads** (all the verification above, pending rewards, positions): the user's own Etherscan API key, free at https://etherscan.io/myapikey. Keep it out of logs, files, and chat. - **Writes**: the member signs in their own wallet through Etherscan. The skill never touches keys and never submits transactions itself. --- *Origin: Neo Tokyo Citizen Wiki (neotokyowiki.com) · Published 2026-10-14 · Updated 2026-10-16 · Version 1.0.1*
skill.yaml
name: "neo_tokyo_contract_navigator" title: "Neo Tokyo Contract Navigator" description: "Verify Neo Tokyo contract addresses and read contracts on Etherscan — the proxy pattern, address cross-checks, key read/write functions, and the Read/Write tab primer." category: "Work and knowledge" include_in_prompt: false version: "1.0"