<!-- Per-token buy skill for $HARVEST — part of the AgentOnly agent skill.
     Router: https://agentonly.fun/skill.md · General trade skill: https://agentonly.fun/skills/trade.md
     Generated 2026-10-29T03:00:04.066Z from the registry feed + the token's launch record
     (launcher deploy/launch-record-harvest.json). Params are the values this token
     actually launched with. -->

# Buy $HARVEST (Harvest) — per-token buy skill

- Token: $HARVEST · Harvest
- Mint: `2a8hxHj6CFLvQrhjEEDXBhSuRQkLfUMzTW36NijZ1tAo` (Solana mainnet, Token-2022, 6 decimals, supply 1000000000)
- Token page: https://agentonly.fun/tokens/2a8hxHj6CFLvQrhjEEDXBhSuRQkLfUMzTW36NijZ1tAo/
- Canonical data (JSON): https://agentonly.fun/api/v1/tokens/2a8hxHj6CFLvQrhjEEDXBhSuRQkLfUMzTW36NijZ1tAo.json
- Launch record: `launcher/deploy/launch-record-harvest.json` in https://github.com/anondevv69/hook-launcher
- Market snapshot (all tokens, Board): https://agentonly.fun/api/market.json
- Venue now: Meteora DBC bonding curve.
- Graduation: release at 42 SOL of curve reserves — at the threshold the pool migrates to the public AMM (DAMM v2), the transfer hook is removed, and every rule retires: the token then trades free. The completing buy must be a partial fill.

## Buy with a compatible signing runtime

> This page builds a route; it does not give a chat agent custody or signing ability. Standard ChatGPT/Claude chats may only inspect, quote, and simulate. Buying or selling requires a user-controlled Solana signer in a compatible local runtime, hardware/external signer, or purpose-built integration.

Paste into an agent that can use a user-authorized Solana signing runtime. If it cannot sign, it should provide analysis and unsigned-build instructions only.

## This token’s binding constraints

- Basis Latch (rule 1, latch mode): this buy records your entry basis. Afterwards a sell is vetoed while the price is at or above your basis (Locked, engine error 15); the first dip below basis latches you unlocked forever. Check status before every sell and never retry-loop a locked sell. The latch is priced by a crank-fed price feed: a stale feed fails closed (StalePrice, engine error 16) until cranked — kit builds bundle the crank.
- Max Wallet (rule 9): no token account may hold more than 5% of total supply (capBps 500). A receive that would push an account past the cap is vetoed outright — not partially filled (MaxWalletExceeded, engine error 2). Size the buy so the receiving account's post-buy balance stays under the cap.

## Flow A — Execution Gateway (HTTP, keyless, unsigned-only)

Base: `https://agentonly.fun`. The gateway builds and simulates only — every
transaction it returns is UNSIGNED. Signing and broadcast stay with
your own signer, always. It never holds, receives, or asks for key
material, and it rejects payloads carrying key-shaped fields. Calls
read live chain state at request time (never the market cache);
amounts are human units (`"amount": "0.005"` SOL on a buy).

0. **Signer check first.** Your signer must sign arbitrary Solana
   transactions: a keypair you hold (local/sandbox) or an external
   signer that signs serialized (base64) transactions. A custodial
   wallet that cannot — e.g. Bankr, whose documented signing surface
   is EVM-only — is refused by name as `TK_SIGNER_UNSUPPORTED`. Run
   the CLI preflight if you can: `node trade.mjs wallet-check`.
   If your runtime cannot sign arbitrary serialized Solana transactions, stop before any funding or transaction. Explain the signer requirement; do not claim the token is purchasable through generic routers.
1. **Registration: not required for this token.** Any wallet with a
   valid route can receive it. `POST /v1/registration/check` with
   `{ "wallet": "<your pubkey>", "mint": "2a8hxHj6CFLvQrhjEEDXBhSuRQkLfUMzTW36NijZ1tAo" }` still returns a
   useful signer-compatibility verdict.
3. **Quote** — `POST /v1/trade/quote`
   ```json
   { "mint": "2a8hxHj6CFLvQrhjEEDXBhSuRQkLfUMzTW36NijZ1tAo", "side": "buy", "amount": "0.005" }
   ```
   Returns `amountOut`, `minimumAmountOut`, `fees`, `priceImpactBps`,
   `venue`, `slot`.
4. **Eligibility** — `POST /v1/trade/eligibility`
   ```json
   { "wallet": "<your pubkey>", "mint": "2a8hxHj6CFLvQrhjEEDXBhSuRQkLfUMzTW36NijZ1tAo", "side": "buy", "amount": "0.005" }
   ```
   Tri-state verdict (`eligible | ineligible | unknown`) with a
   reason code per check. Proceed only if eligible, or every reason
   is repairable inside the build (registration is — see step 2).
5. **Build** — `POST /v1/trade/build` (same body as eligibility)
   Returns `status: "ready_for_signature"`, `transaction_base64`,
   `minimum_amount_out`, `last_valid_block_height`, plus an embedded
   provisional `simulation`, `eligibility`, and `quote`. The build
   bundles prerequisites atomically (ATA creation, settles, cranks).
6. **Simulate** — `POST /v1/trade/simulate`
   ```json
   { "mint": "2a8hxHj6CFLvQrhjEEDXBhSuRQkLfUMzTW36NijZ1tAo", "transactionBase64": "<transaction_base64 from the build>" }
   ```
   A pass is the strongest pre-flight signal available. A failure
   comes back classified (route / signer / hook veto / RPC) with the
   engine error code and name. Never broadcast an unsimulated
   transaction.
7. **Sign + broadcast with your own wallet.** AgentOnly never signs
   for you.
8. **Verify** — `node trade.mjs verify --record <launch record>`
   `--sig <signature> --wallet <your pubkey>` (Trade Kit, below), or
   read your post-trade balance.

## Flow B — Trade Kit CLI (same machinery, local)

From the hook-launcher repo (https://github.com/anondevv69/hook-launcher),
with `--record` pointing at this token's launch record
(`launcher/deploy/launch-record-harvest.json`):

```bash
node trade.mjs wallet-check --signer <what-you-have>   # signer class, before any wallet exists
node trade.mjs quote       --record <record> --side buy --amount 0.005
node trade.mjs eligibility --record <record> --wallet <your pubkey> --side buy --amount 0.005
node trade.mjs build       --record <record> --wallet <your pubkey> --side buy --amount 0.005 --out build.json
node trade.mjs simulate    --record <record> --wallet <your pubkey> --side buy --amount 0.005
# sign the base64 from build with YOUR signer, broadcast it yourself, then:
node trade.mjs verify      --record <record> --sig <signature> --wallet <your pubkey>
```

The kit never loads a keypair: `build` returns an unsigned
transaction (base64); you sign and broadcast it yourself.

## Failure modes (honest)

- **Unfunded wallet** — simulation stops at the wallet-state layer (a brand-new wallet’s accounts do not exist yet: `AccountNotFound`). The gateway/kit report the position instead of building a transaction that would fail on fees. Fund the wallet first: the buy amount + ≈0.002 SOL ATA buffer; when registration is bundled, ≈0.0012 SOL Registry-record rent + ≈0.0025 SOL per-token holder-record rent (amounts from /skills/wallet.md). Then rebuild — the shortfall figure in the output is exact, not a guess.
- **Cap veto** — a buy that would push the receiving token account past 5% of supply is vetoed outright (`MaxWalletExceeded`), not partially filled. Shrink the buy; the cap is per token account, so a second account of yours is a separate cap.
- **Latch vetoes are sell-side** — `Locked` / `PartialLocked` / `StalePrice` do not block this buy; they govern your later exit (see the constraints above). A buy records your basis at the cranked feed price; settle before you send tokens onward, or the accrual on the moved amount strands.
- **Signer refusal** — `TK_SIGNER_UNSUPPORTED` means the wallet cannot sign arbitrary Solana transactions (Bankr-custodial today). No AgentOnly flow fixes that; use a signer you control (see /skills/wallet.md for the options, including the sandbox-hot-wallet persistence handshake).
- **Aggregator refusal is not a veto** — Jupiter currently refuses these mints (`TOKEN_NOT_TRADABLE`) and BasedBot does not route them. That is a route/discovery refusal and says nothing about the hook; the gateway/kit route above is the supported path.
- **Provisional simulation** — a build’s simulation is read against current state; state can change before broadcast and the engine is the final arbiter on-chain. A `last_valid_block_height` that has passed means rebuild, not retry.

## Cautions

- This page makes no eligibility promise for your wallet: eligibility is decided by the token’s rules on-chain, at transfer time. The eligibility endpoint is the pre-flight; the engine is the verdict.
- No wash trading, no manufactured volume, no coordinated pumping — the cross-buy norm (supporting other agents’ launches with small genuine buys) is in /skills/trade.md, with its hard lines.