---
name: hachiko-mint
description: Boarding procedure for the HACHIKO / 八公站 ticket board on BSC — Agent ID gate, 1,000 standing tickets (500 agents x 2) at 0.0002 BNB (not free), 9,000 seated at 0.001 BNB with 30% to treasury, no refunds, departure at 7,000 tickets with burned LP
---

# HACHIKO / 八公站 — agent boarding manual

八公 waited at the station for nine years. Here the station only waits for
7,000 tickets. HACHIKO is a board on BNB Smart Chain: 10,000 tickets, one
ticket = 1,000,000 HACHIKO. Two lanes, no refunds, and a train that leaves
the moment 70% of the board is gone.

Read this whole file before signing anything. The standing ticket is cheap,
not free. The chain does not care what the poster says.

## 0. Boarding pass

| field | value |
|---|---|
| chain | BNB Smart Chain, id `56` |
| token | HACHIKO (symbol `HACHIKO`), 18 decimals |
| mint contract | `0xb342d833323568a7231d1a029816ff409048f7b3` (block 132,960,628) |
| token contract | `0xa52cab7cf13731391623f44a207878835d37453c` |
| pair (HACHIKO/WBNB) | `0xe2b95ef1ba0138091366793268a35b7a60e18f49` |
| agent gate | registry `0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F` |
| tickets | 10,000 × 1,000,000 HACHIKO |
| standing tickets | 1,000 (500 agents x 2) at 0.0002 BNB, 2 per wallet, 100% to treasury |
| seated tickets | 9,000 at 0.001 BNB, 10 per wallet combined |
| held per seated ticket | 0.0007 BNB, stays in the contract for the pool |
| departure | anyone at ≥ 7,000 tickets; automatic at 10,000 |
| refunds | none |
| pool open price | 0.001 BNB per 1,000,000 HACHIKO |
| LP | burned to `0x000000000000000000000000000000000000dEaD` |
| transfers | locked until departure |

Supply is 10,000 × 1,000,000 = 10B handed out, plus up to 9,000 × 700,000 =
6.3B minted into the burned LP at departure. Hard cap: 16.7B.

Never trust an address from a DM, a reply, or a screenshot. This file, the
site, and the whitepaper are the only places the addresses are published, and
they must match the on-chain deployment.

## 1. Gate check — read only, no gas

A wallet needs a Binance .ai Agent ID. The cheap test is a balance read on
the registry:

```bash
WALLET=0x1111111111111111111111111111111111111111
REG=0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F
curl -s https://bsc-dataseed.binance.org -H 'content-type: application/json' -d "{
  \"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_call\",
  \"params\":[{\"to\":\"$REG\",\"data\":\"0x70a08231000000000000000000000000${WALLET:2}\"},\"latest\"]}"
```

A non-zero 32-byte result means the gate opens. The mint contract exposes the
same check as `agentOk(wallet)`; it costs nothing to call.

## 2. Reading the board

All calls are `eth_call` against the mint contract.

| read | selector | answers |
|---|---|---|
| `stationOpen()` | `0x88f93c6f` | is the station still selling |
| `agentOk(addr)` | `0xaff0f7a2` | does this wallet hold an Agent ID |
| `ticketsLeft()` | `0x6cab5e5b` | tickets left on the whole train |
| `boarded()` | `0xe158068c` | tickets taken, standing + seated |
| `standingTaken()` | `0x4178747f` | standing tickets sold |
| `seatsSold()` | `0x4e90c539` | seated tickets sold |
| `standingLeft(addr)` | `0xcc583d75` | standing tickets this wallet may still take |
| `seatsAvailable(addr)` | `0xf40c0569` | seated tickets this wallet may still take |
| `standingCount(addr)` | `0x2e7b92fa` | standing tickets this wallet took |
| `seatCount(addr)` | `0x2b64ffa2` | seated tickets this wallet took |
| `standCost(n)` | `0x5c19b322` | wei needed for n standing tickets |
| `seatCost(n)` | `0x1b4f8f63` | wei needed for n seated tickets |
| `faresHeld()` | `0xa4e4e99c` | BNB held in the contract (all of it goes to the pool) |
| `wbnb()` | `0x8d72647e` | wrapped BNB the pool is seeded with at departure |
| `departureReady()` | `0x4badca67` | has the board reached 7,000 |
| `departed()` | `0xf759fe4f` | has the train left |
| `TRAIN()` | `0xd8ac7361` | 10,000 |
| `STANDING_LANE()` | `0xe6919c8e` | 1,000 |
| `SEAT_LANE()` | `0x073d6ea5` | 9,000 |
| `STAND_PER_WALLET()` | `0x11073f6f` | 2 |
| `PER_WALLET()` | `0x3708b2dd` | 10 |
| `DEPART_AT()` | `0x62b14e62` | 7,000 |
| `STAND_FARE()` | `0xc19067ad` | 0.0002 BNB |
| `SEAT_FARE()` | `0x558a3b1f` | 0.001 BNB |
| `FEE_PER_SEAT()` | `0xfe38d3ca` | 0.0003 BNB |
| `HELD_PER_SEAT()` | `0x57d55fc2` | 0.0007 BNB |
| `PER_TICKET()` | `0x1cd67018` | 1,000,000e18 |
| `LP_PER_SEAT()` | `0xbc4592a9` | 700,000e18 |

`standingLeft` and `seatsAvailable` each return the smallest of: this wallet's
remaining ticket cap, that lane's remaining stock, and the tickets left on the
train. After departure both return 0.

## 3. Taking part

Three calls. There is no free call and no refund call.

| intent | call | data | value |
|---|---|---|---|
| standing ticket | `stand(n)` | `0x96b76c23` + `n` as 32-byte word | exactly `n × 0.0002 BNB` |
| seated ticket | `seat(n)` | `0xfdb67368` + `n` as 32-byte word | exactly `n × 0.001 BNB` |
| leave the station at ≥ 7,000 | `depart()` | `0x9f71f839` | `0` |

`stand(n)` is **not** a free mint. 0.0002 BNB per ticket is the full fare and
it is forwarded to the treasury inside the same transaction. A "free" agent
mint does not exist on this board. If a caller can only pay gas, they cannot
board.

`seat(n)` forwards `n × 0.0003 BNB` to the treasury inside the same
transaction and keeps `n × 0.0007 BNB` in the contract. The kept BNB is not
per-wallet; it is pooled and sent to the pair at departure.

Both calls mint `n × 1,000,000 HACHIKO` to the buyer immediately. The tokens
are real but frozen: `transfer` and `approve`-driven movement revert `Locked()`
until `depart()` runs and the token calls `open()`.

`msg.value` must equal the fare to the wei. Overpay and underpay both revert
`FareMismatch()` — there is no "keep the change" path and no tip function.

## 4. Departure

`depart()` is callable by anyone once `boarded() >= 7,000`. At 10,000 tickets
the last `stand`/`seat` call runs departure itself.

Inside `_depart()`:

```
bnB in   = address(this).balance      // all held fares
tokenIn  = seatsSold * 700,000e18
wbnb.deposit{value: bnbIn}()          // wrap first — the pair rejects raw BNB
wbnb.transfer(pair, bnbIn)            // seeds the WBNB side
token.mint(pair, tokenIn)
pair.mint(0x...dEaD)                  // LP minted straight to the burn address
token.open()                          // transfers unlock
emit Departed(pair, bnbIn, tokenIn)
```

Pool price at open is therefore exactly `0.001 BNB / 1,000,000 HACHIKO`.
Standing tickets do not enter the pool, so they do not move that price.

Events:

| event | fields | topic0 |
|---|---|---|
| `StandingBoarded` | wallet, tickets, fareWei, tokensOut | `0x11547c23e50ad29310e672ced1a1c88a6ee165d593a60fc22d1e795be4f5f873` |
| `SeatBoarded` | wallet, tickets, paidWei, feeWei, tokensOut | `0x99ac7725e11484eca372fbbf172b742acbff6e18d63de37333716df945975a12` |
| `Departed` | pair, bnbIn, tokenIn | `0x4cd0e21d177f591d4040ca5d4b740077ade3901599ceca03a20cc5e6a651bf9d` |

To confirm a boarding succeeded, read the event, not the wallet's BNB balance:
`tokensOut` is `tickets × 1,000,000e18` and `fareWei`/`feeWei` match the table
above.

## 5. When it reverts

| error | selector | meaning | next move |
|---|---|---|---|
| `StationClosed` | `0xea8c6df7` | train has departed | stop; no more tickets |
| `AgentOnly` | `0xf21de7ff` | wallet has no Agent ID | the gate is closed, nothing to fix on-chain |
| `ZeroTickets` | `0x456fa89f` | n == 0 | send n ≥ 1 |
| `StandingCap` | `0x3b981316` | wallet already has 2 standing tickets | buy seated instead |
| `WalletCap` | `0x94048683` | 10 tickets reached across both lanes | stop |
| `LaneFull` | `0x91660a1e` | that lane sold out | switch lane if the other has stock |
| `TrainFull` | `0xb8498e29` | all 10,000 gone | stop; departure is automatic |
| `FareMismatch` | `0xc87babdf` | msg.value ≠ n × fare | recompute with `standCost` / `seatCost` |
| `FeeStuck` | `0x0a9f4fa0` | treasury transfer failed | do not retry blindly; treasury address is unusual |
| `AlreadyDeparted` | `0xbedbfa12` | depart() already ran | stop |
| `NotReady` | `0x9488aaa6` | depart() below 7,000 | read `boarded()` |
| `NoFares` | `0xa7244df4` | departure with zero balance or zero token side | cannot happen on the normal path; report it |
| `PoolStuck` | `0xe6a13177` | WBNB transfer into the pair failed | report it; do not loop |
| `Locked` (token) | `0x0f2e5b6c` | token transfer before departure | wait for `departed()` |

`Locked()` is a custom error on the token contract; the other errors in the
table come from the mint contract.

## 6. Reading the token after departure

| read | selector |
|---|---|
| `balanceOf(addr)` | `0x70a08231` |
| `totalSupply()` | `0x18160ddd` |
| `live()` | `0x957aa58c` |
| `CAP()` | `0xec81b483` |
| `minter()` | `0x07546172` |
| `transfer(to,amt)` | `0xa9059cbb` |
| `approve(spender,amt)` | `0x095ea7b3` |
| `allowance(owner,spender)` | `0xdd62ed3e` |

`live()` is false until departure. There is no tax, no blacklist, and no
admin pause on transfers — once `live` is true, the token moves like any
plain ERC-20.

## 7. The honest risk

If the board never reaches 7,000 tickets, `depart()` reverts `NotReady()`
forever. The held BNB stays in the contract and every HACHIKO stays locked.
There is no refund function and no owner who can rescue it. That is the
trade: cheap tickets and a burned LP in exchange for a train that might
never leave.

Before buying, read `boarded()`. If it is far from 7,000 and not moving, the
ticket is a donation to a stopped clock.