Create a blockchain session. Call this tool when other tools fail with authentication or session errors (e.g. "not authenticated", "session expired"). In EVM mode this signs in via SIWE locally and stores the token. In AGW mode it returns a URL the user must open in their browser to approve. Once authenticated, subsequent wallet-dependent tools will work automatically. Pass force=true to discard the cached session and authenticate from scratch (e.g. after the game server was reset and the stored token references a stale user).

Return the game rulebook for the active network: the resource catalog (id → name), the building catalog (name, kind — extractor/crafter/hub — and $CPU cost; the full JSON also carries each building’s mine/craft bindings and build time), reveal-cost params (first reveal free; re-reveal price), how this network delivers randomness (self-service or push — it decides what cpu_reveal does), the on-chain contract addresses, and the recipe count (use cpu_list_recipes for the full recipe graph). A free reference read — call it once to ground planning. No session needed.

Read the live game world (public, background-synced). The world is a finite sphere of 48,990 cells keyed by tokenId — no coordinates: navigate via each cell’s neighbors (6 adjacent, 5 next to a pentagon vertex; owned/other/empty, empty = unminted) and cpu_next_hops; pos {face,i,j} is only a rough hint (wraps at face seams). Returns a summary, a resourceIndex of your cells, and per-resource storage (used/cap/full; a box with room for less than one whole cycle halts that resource’s production, cap null = uncapped). Scopes: mine | around (grid radius from aroundTokenId) | cells | all | summary. version/updated are epoch ms, serverTime/startAt unix seconds. server.reachable false means actions will fail; your to-do list is cpu_get_attention.

Inspect one cell in depth (any owner — the map is public). Returns the cell, its neighbours expanded as full cell states (the immediate surroundings of a target), and distanceFromMine — the grid distance (BFS steps) to your nearest cell (null if your wallet is unknown or it is farther than 50 steps). Each resource carries a storage box (used/cap/reserved/full) and the active process a stalled flag — true once the room holds less than one whole cycle of its output, which halts production before the box reads full, until you offload. For broader situational awareness use cpu_get_map.

Get only the cells that changed since a given version — react to other players without re-reading the whole map. Pass the version from a previous map response; the reply carries a new version for next time. Omit sinceVersion (or 0) to get everything. Also carries server: { reachable }: false means the API is unreachable, so any action (build/reveal/transport/trade) will fail — keep polling cpu_get_changes rather than retrying actions; the client reconnects in the background, and once reachable flips true you can act again (after an outage, call once with sinceVersion 0 for the full picture).

Owner-scoped roll-up of cells worth attention, most time-sensitive first — so you skip scanning the whole map. Flags, each with a severity: stalled mining/craft (the output box has room for less than one whole cycle, so nothing settles and the wait burns); a reveal request of yours still open long after the client should have settled it in the background, and a cell locked by a reveal request opened at a randomness source the chain config has since replaced — that one no call of yours can clear, only an admin cleanup of the contracts (critical); a near-full warehouse on an actively-produced resource, a job that has run its scheduled cycles and now idles the cell until claimed, an arrived delivery ready to finalize, an extractor on a depleted deposit, or one of your open lots frozen because the hub raised its live sale fee above your tolerance (buys revert; cancel stays fee-free) (warning); revealed-but-unbuilt cells, cells in a post-demolish rebuild cooldown, and an open lot whose live sale fee now sits exactly at your tolerance so the next hike freezes it (info — on a demolish_cooldown item arrivalAt marks when rebuild reopens and demolishingType names what is coming down, null when that detail was never recorded, which is normal and does not put the cooldown itself in doubt). A finished job loses nothing by waiting, unlike a stall — it only holds the cell idle. Items are purely descriptive (cell, resource, used/cap breakdown, deposit, delivery, and for a lot its lotId, hub cell and a message, for a reveal request its requestId and requestedAt) and suggest no action — you decide. Lot and reveal-request flags cover your own wallet only. Your own cells need an authenticated wallet; pass owner to scout another player read-only (all data is public). minSeverity filters by urgency. If the deliveries, lots or open-reveal-request lookup is down, the remaining items still return and a note says so.

Reveal the deposits of a cell you own (call cpu_authenticate first). Sends an on-chain Cell tx requesting randomness, paying the source fee in ETH — keep some ETH. First reveal is free; a re-reveal needs all deposits depleted and costs $CPU (auto-approved once). How the draw arrives depends on the network’s randomness mode — see cpu_get_game_config. On a self-service network this call also settles the draw and returns the deposits it rolled; call it again on a cell whose reveal is still pending to finish that one, which costs no new fee.

Finish reveal requests you already opened that have not delivered their draw yet (call cpu_authenticate first). Where the network’s randomness mode leaves delivery to the player — see cpu_get_game_config — this sends the missing draw on-chain: it costs gas but no new reveal fee. With no arguments it works through every open request you own; pass tokenIds to settle only those cells. If a request you know exists is not listed, name it directly with requestId plus source and it is settled without that list. Requests already settled are reported as such, not as errors. On a network where the randomness source delivers draws itself this call refuses — there is nothing to settle by hand there.

Place a building on a revealed Land cell you own (needs a session — cpu_authenticate first). Pick a buildingType from the catalog (cpu_get_game_config): an extractor mines a raw deposit, a crafter runs a recipe, the hub routes transport/trade. Costs $CPU (some buildings also consume refined resources from the cell's warehouse); the tool auto-approves the $CPU spend once, sends the on-chain place, and waits for confirmation. Building takes time — it is not usable until it finishes. Once ready, start an extractor with cpu_start_mining or a crafter with cpu_craft. A cell holds one building: re-running build on the same building is a safe no-op; to switch buildings cpu_demolish first (a just-demolished cell is locked from rebuilding until its cooldown ends). Inspect the result with cpu_get_cell.

Remove the building from a Land cell you own, clearing it for a different building. Requires a session — call cpu_authenticate first. Not free: it burns a fraction of the building’s build cost in $CPU (auto-approved) and consumes some of its build materials from the cell’s warehouse (no refund) — see each building's demolishCost in cpu_get_game_config for the exact amounts. The cell must have no active mining or craft process — a craft frees its slot once fully claimed, but a mining run only ends when its deposit is exhausted, so a mining extractor cannot be demolished mid-run; a hub can only be demolished when it is not mid-route or anchoring open trade lots. Deposits and other warehouse balances are preserved. Afterward the plot is locked from rebuilding until its demolish cooldown ends (its demolishFinishAt); cpu_get_cell/cpu_get_attention surface the cooldown.

List the craft recipes available in the game: each recipe’s inputs, outputs, duration per batch and $CPU cost. Public — no session needed. Use it before cpu_craft to pick a recipe and see what a paid forge will cost up front.

Run a craft recipe on a cell you own (refine raw resources, or forge $WCPU). Requires a session — call cpu_authenticate first; discover recipes with cpu_list_recipes. Inputs are debited upfront for all batches. Most recipes are free and start their timer immediately; forge_wcpu costs $CPU, which this tool auto-approves once (a one-time unbounded allowance) before submitting the on-chain payment and waiting for its confirmation — its timer then starts once the indexer settles the payment a few seconds later. Pointing a crafter at a recipe other than the one it is already set to also burns its Switch cost, in the same transaction and the same approval as the recipe cost — the first pick after building, and restarting the current recipe, are free. Check the price per recipe in cpu_get_cell (outputs) before you commit; the result reports the recipe cost and the Switch cost that actually burned separately. Track progress with cpu_get_craft_status and bank matured batches with cpu_claim_craft.

Get the craft job on a cell: its recipe, status (active / pending payment / stalled), how far through its schedule it is (completedBatches of batches), what is claimable right now, when the next batch matures and when the run ends. A craft stalls once any output box has room for less than one whole batch — batches settle whole or not at all, so nothing banks until you offload a blocked output (blockedResourceIds), and the wait resets while the schedule survives. isFinished means the run is done and now only holds the cell's process slot: claim it to bank the rest and free the cell. Timestamps are unix seconds on the same clock as serverTime. Public — works for any tokenId. This is the source of craft progress; bank matured batches with cpu_claim_craft.

Bank every matured craft batch on a cell you own into its resource balance. Requires a session — call cpu_authenticate first. With at least one craft process on the cell, claiming nothing matured is a no-op success; claiming on a cell that has no craft processes is an error. A fully-claimed process frees its slot. Check what is claimable first with cpu_get_craft_status.

Start a bounded extraction job on a cell you own that holds a finished extractor. Requires a session — call cpu_authenticate first. Pass the targetResourceId to mine — it must be a resource the extractor can mine (see cpu_get_game_config) with an active deposit on the cell; omit it when the extractor mines a single resource. Pointing the extractor at a resource other than the one it is already set to burns its Switch cost in this same transaction — the first pick after building, and restarting the extractor's current resource, are free. Check the price per resource in cpu_get_cell (outputs) before you commit; the result reports what actually burned. The building must have finished construction — building takes time after cpu_build. batches is how many cycles the job runs, and it is a commitment you cannot undo: the job ends itself once it has run them, or sooner if the deposit runs dry, and there is no cancel — the target cannot be switched nor the building demolished mid-job. It never overruns its schedule, so coming back late banks exactly what you booked and no more. Until the job ends it holds the cell's only process slot, so nothing can be crafted there; claiming a finished job frees the slot. Size batches against the cycle length in cpu_get_game_config and the deposit in cpu_get_cell — scheduling past the deposit just ends early. Track it with cpu_get_mining_status and bank matured cycles with cpu_claim_mining.

Read a cell's mining job: whether an extractor is active, which resource it mines, its yield per cycle and cycle length, how far through its schedule it is (completedBatches of batches), the units and whole cycles claimable right now, when the next cycle matures and when the job ends, the remaining deposit, and whether it is stalled. Mining matures in whole cycles — a cycle in progress banks nothing until it completes — and settles in whole cycles too: if one full cycle of output does not fit, nothing settles. That is a stall, and it begins before the box reads full. A stall burns time (the schedule survives, the wait does not), so offload to resume — transport it out, sell via create_lot, craft with it, or withdraw wCPU; a null cap means the warehouse is uncapped. isFinished means the job has run its schedule and will produce nothing more: claim it to bank the rest and free the cell for another job or a craft. Timestamps are unix seconds on the same clock as serverTime. Public — works for any cell, no session required. The owner banks matured cycles with cpu_claim_mining.

Bank every matured mining cycle an extractor has produced on a cell you own into its resource balance. Requires a session — call cpu_authenticate first. With an active job, claiming when nothing new has matured is a harmless no-op; claiming on a cell that has no extractor is an error. A cycle in progress matures nothing until it completes, and only whole cycles settle — if a full cycle of output does not fit, nothing banks and the wait resets. Claiming does not stop a running job. Claiming one that has run its schedule (or drained its deposit) retires it and frees the process slot, so the cell can take another job or a craft. Check what is available first with cpu_get_mining_status.

The road map of the world (read-only): every legal waypoint — your revealed cells and every finished Hub — as graph nodes (owner, hub flag, ready build state, the exact per-unit transit fee for your resourceId cargo, pos, connected-component id) plus every hop the contract would accept as edges (within radius(a)+radius(b)−1 grid steps; default balance: own↔own 1 = adjacent only, own↔hub 3, hub↔hub 5). A Hub counts only once its construction finishes: an unfinished one grants no hub reach and charges no fee, and a foreign one is not a node at all — your own cells stay nodes while they build, just with normal reach (ready: null = nothing built, false = under construction, true = finished). Foreign cells are never nodes: even a single foreign cell between two plain cells is a WALL — only a finished Hub reaches across. Different component ids show exactly that — no chain crosses today, goods stop at the border. Bridging is a strategic decision: a border Hub (it still needs an eligible landing point within reach on the far side), buying land across, or a detour — the sphere is closed, so a wall must encircle to truly seal. Pass from/towards to annotate each node with grid distances (a potential field to reason over). Routing over this map is YOUR job: pick the chain, then verify with cpu_quote_transport. WHEN: the heavy read — plan a journey or a big replan; for point checks while executing use the cheap cpu_next_hops.

Survey the legal next waypoints from a cell (read-only). Lists every eligible waypoint — your revealed cells and every finished Hub — within one hop under the reach rule: hop ≤ radius(from)+radius(to)−1 grid steps (default balance: own↔own 1 = adjacent only, own↔hub 3, hub↔hub 5). A Hub counts only once its construction finishes: until then it grants no hub reach and charges no fee, and a foreign one is no waypoint at all — fromReady says whether your own origin is still building, which is why its reach may be smaller than you expect. Foreign cells are never waypoints, so even a single foreign cell between two plain cells is a WALL — only a finished Hub reaches across; empty hops means goods can only be hauled up to here. Facts per candidate: hop distance, owner, hub flag, ready build state, the exact per-unit transit fee for your resourceId cargo, and — with towards — the remaining grid distance (a compass, not a route). Planning is YOUR job: pick each hop yourself (cheap vs short vs whose hub you trust), chain them into path, and verify with cpu_quote_transport. To break a wall: build a border Hub (it still needs an eligible landing cell within reach on the far side), buy land across, or go around. WHEN: the cheap point check — call it right before each leg and after cpu_get_changes shows movement (hubs get demolished, fees change while goods travel); replan via cpu_route_network only when a local fix is impossible.

Preview a transport route (a waypoint chain of tokenIds) without committing: returns fee — the actual $CPU (decimal) you will pay across foreign hubs — and discount, the same-clan member saving already applied (the nominal fee equals fee + discount), plus the summed grid distance and the arrival timestamp. Read-only on-chain view with no side effects. It also validates the route, surfacing the rejection reason if the chain is invalid (hop out of range, unrevealed or ineligible waypoint). Scout waypoints with cpu_next_hops; use this before cpu_transport.

Move a resource between cells along a waypoint chain of tokenIds, on-chain (needs a session — cpu_authenticate first). One atomic move: debits the source, pays the $CPU transit fee for every foreign Hub on the route (auto-approved once) plus gas, and escrows a time-delayed delivery. Every waypoint must be revealed and yours-or-a-finished-Hub; each hop must be within radius(from)+radius(to)−1 grid steps (default balance: own↔own 1 = adjacent only, own↔hub 3, hub↔hub 5). Recommended flow: cpu_next_hops (scout waypoints) → chain them yourself → cpu_quote_transport (verify fee/ETA) → cpu_transport. Returns the deliveryId and arrival time; the goods credit to the target only after arrival, when you call cpu_finalize_delivery (cpu_list_my_transports shows what is ready). A route over only your own cells pays no fee.

List your deliveries (the ones you paid for), optionally filtered: all, in_transit, delivered, or ready_to_finalize. Each entry shows source/target, amount, arrival time, and whether it is delivered or ready to finalize. Use it to find deliveries to complete with cpu_finalize_delivery.

Get one delivery by its on-chain deliveryId: source and target cells, resource and amount, arrival time, whether it has been delivered, and whether it is ready to finalize. Reads the deliveries projection.

Finalize one or more arrived deliveries by their on-chain deliveryIds, crediting each to its target cell. Permissionless and on-chain (you pay gas). A delivery can only be finalized once its arrival time has passed — see cpu_list_my_transports (ready_to_finalize). Requires a session — call cpu_authenticate first.

Scout the marketplace: one compact row per (Hub, resource) with open-vs-incoming lot counts, lowest price, distance, and the hub's live sale-fee percent for that resource (liveSaleFeePercent, enriched from the local world map — advisory, may trail the chain; null when the rate is unknown, i.e. the map has no read on the hub or it isn't serving sale fees yet). The recommended first look at what is for sale and where — compare hubs by fee in one call, then drill into specific lots with cpu_list_lots. Public read; supports hub / resourceId filters and an optional zone (aroundTokenId + radius in grid steps).

Browse marketplace lots with filters (hub, resourceId, seller, minPrice/maxPrice), sort (price_asc | recent | nearest — nearest needs a zone), pagination (limit ≤ 200, offset), and an optional zone (aroundTokenId + radius in grid steps). availability defaults to open (buyable now); use incoming for en-route lots or all. Public read — start with cpu_get_markets for a compact overview, then drill in here.

Inspect a single lot by id — resource, remaining/listed units, price per unit, Hub location, seller, and lifecycle state. Public read.

List the lots you have created, across all lifecycle states (optionally filtered by state). Requires a session. Use this to find your lotIds and track create / cancel progress.

The feed of executed buys (fills) — what buyers actually PAID, not what sellers ask. One fill is one buy against a lot, whole or partial; the fill that leaves 0 remaining bought the lot out. Filter by resourceId and/or hubTokenId, or read the whole world. Public read — pair it with cpu_get_markets (the cheapest ask right now) to see the gap between asks and real prices. PAGING GOES ONE WAY: rows come newest first, and before (the ":" cursor of the last row you got) pages DOWN to older fills. There is no "since" parameter. To read what is new since last time, read the head with no cursor and stop at the blockNumber:logIndex pair you already saw — do not page down looking for it. The feed CANNOT be filtered by buyer or seller, so your own trades cannot be assembled from it — use cpu_list_my_lots for those.

World price index — one call, no inputs, one row per resource: the 24h volume-weighted average price ($CPU per unit), the 24h percent change, and 24h volume in resource UNITS (not $CPU). A weekly spark series rides along in the JSON block only, never in the text summary — read the trend off changePct instead. This is a SERVER-CACHED AGGREGATE that can run up to an hour behind — do not use it where you need second-fresh data. A null price means NO TRADES settled for that resource in the 24h window — read it as "no trades", never as free or as zero. This answers a different question than cpu_get_markets (the cheapest ask available right now, per hub): that is what you could buy at this instant; this is what the world actually paid, on average, over the last day. The two are never combined into one call — mixing them would read as one price when it is really two.

Preview a buy priced by the Trade contract itself — read-only, reserves nothing, sends no tx (needs a session). Pass chain = [hub, ...waypoints, your destination cell] for the full preflight (sale leg + transit) — the exact total cpu_buy_lot would charge; omit it for the sale leg alone via quoteSale. Returns decimal $CPU: sale (nominal value × pricePerUnit), the hub's live saleFeePercent, your clan discount, salePaid (what you actually pay for the goods), the split (tax, ownerNet), plus transitFee/transitDiscount and arrivalAt when routed, with total = the actual full debit. The hub sale fee and burn come out of the seller proceeds, not on top. Because the quote runs the same checks as the buy, a failed quote explains why the purchase would revert (lot closed, amount exceeds remaining, a sale-fee-tolerance freeze, a foreign frozen hub on the route). It does NOT check pause, $CPU balance, or allowance — a fill can still revert on those. cpu_buy_lot re-quotes transit on-chain and authorizes ~10% over as headroom (a ceiling, not an extra charge). Use before cpu_buy_lot.

List units of a resource for sale at a Hub, on-chain (needs a session — cpu_authenticate first). One atomic tx: ships the goods from your source cell to the listing Hub (chain = [source, ...waypoints, hub]) and opens a lot at pricePerUnit $CPU, plus gas. A route through a foreign Hub costs a $CPU transit fee (auto-approved once); over only your own cells it is free. The hub owner charges a sale fee on every sale, carved out of the seller proceeds (the buyer still pays exactly price × value). maxSaleFeePercent is your tolerance: the highest rate you accept — omit it to lock in the live rate at listing (read on-chain). The hub settles its live rate each sale (never above your tolerance); if it later rises above the tolerance the lot freezes and buys revert until the hub lowers it — cpu_cancel_lot is always fee-free and returns the escrow. The lot is DELIVERING and becomes buyable (OPEN) only after its escrow arrives — call cpu_finalize_delivery on the returned deliveryId (or wait). Returns the lotId and the locked-in maxSaleFeePercent; track with cpu_list_my_lots / cpu_get_lot.

Buy units from an OPEN lot, delivered to your own cell, on-chain (needs a session). chain = [hub holding the lot, ...waypoints, your destination cell]. One atomic $CPU tx: seller price (value × pricePerUnit) + any foreign-hub transit fee, plus gas; the first buy auto-approves the sale exactly and the transit fee with ~10% headroom (a ceiling for on-chain fee drift, not a double charge). Preview the exact cost with cpu_quote_buy. Goods ship to your cell and credit only after arrival, when you cpu_finalize_delivery the returned deliveryId. If the lot is frozen — the hub raised its live sale fee above the seller tolerance — the buy reverts on-chain until the hub lowers the rate (or you pick another lot); cpu_get_lot flags it up front. Buying your own lot is allowed. The result reports the sale-leg clan economics: paid is what you were actually debited for the sale (= sale − discount, the syndicate discount when buyer and seller share a syndicate), while tax is the clan tax carved from the hub fee to the owner's syndicate manager and ownerNet is the hub owner's net proceeds.

Withdraw an OPEN lot; the unsold units return to you, on-chain. Requires a session. Pass chain = [hub, ...waypoints, your destination cell] for the return shipment (required). One atomic tx: a return through a foreign Hub costs a $CPU transit fee (auto-approved), otherwise it is free; you also pay gas. The units ship back and are credited only after they arrive and you cpu_finalize_delivery on the returned deliveryId. Track with cpu_list_my_lots / cpu_get_lot.

Set the sale-fee rate for one resource on a Hub you own, on-chain (needs a session — cpu_authenticate first). The rate is a percent of every sale of that resource settled on your hub (0–100, 0.01 granularity), carved out of the seller proceeds; set 0 to list that resource for free. One resource per call (loop for several). The rate settles live on every open lot of the resource, but never above each lot’s seller tolerance; a lot whose tolerance you exceed freezes (its buys revert) until you lower the rate back to its tolerance. Settable on a hub still under construction, so it is already in place when the hub becomes Ready. Reverts if you do not own the hub or the rate exceeds the 100% structural bound. Returns the confirmed rate and tx hash.

Browse the syndicate registry — the player clans that grant trade/transport fee discounts to members and levy a tax routed to the clan. Filter by name or member-count band, sort (members_desc | recent | name), and page with limit/offset. Each card carries the four fee rates as percentages, the member count, the manager address, and the creation time. Public read.

Open one syndicate by id — its card (name, manager, the four fee rates as percentages, member count, creation time) plus a page of its members. Members are returned in the registry order (joinedAt ascending, then address); page them with membersLimit/membersOffset. An unknown id is an error; a members page past the end is empty. Public read.

Check whether a wallet belongs to a syndicate — omit address to check your own. A non-member gets a plain "not a member" answer (not an error). A member gets their join time, the earliest time they may leave, and the full card of their syndicate (name, manager, the four fee rates as percentages, member count). Public read.

Join a syndicate by id (get ids from cpu_list_syndicates). Membership is effective immediately and the syndicate's four fee rates (trade/transport discount and tax, as percentages) apply to your activity from that moment — the returned card shows exactly what you are signing up for. COMMITMENT: leaving is gated by an exit cooldown that starts at your join time, so you cannot leave again right away; the result reports the earliest time you may leave. Writes on-chain (a wallet transaction). Fails clearly if you are already in a syndicate (leave first), if the id does not exist, or if the registry is not deployed on this network.

Leave the syndicate you currently belong to. Allowed only once the exit cooldown that started at your join time has elapsed — an early attempt fails clearly and reports the earliest time you may leave. Once you leave you may join another syndicate immediately. Writes on-chain (a wallet transaction). Fails clearly if you are not in any syndicate, or if the registry is not deployed on this network.

Found your own syndicate: pick a name, an optional link, and the four fee rates as percentages (same-syndicate trade/transport discounts and the trade/transport tax the manager collects). You are auto-joined as the first member the instant it is created — the result reports the assigned id, your join time, and the earliest time you may leave (an exit cooldown starts at that join time, so you cannot leave right away). The manager defaults to you; pass a different address to hand the tax stream to another wallet. Rates are percentages 0–100 on whole basis-point steps (finer than 0.01% is rejected). Writes on-chain (a wallet transaction). Fails clearly if you are already in a syndicate (leave first), on an empty/over-long name or over-long link, on a rate above 100%, or if the registry is not deployed on this network.

Update a syndicate you manage. This REPLACES the entire card at once — name, link, and all four rates — it is NOT a partial patch: every field you pass overwrites the stored one, and any field you leave out reverts to its default. Read the current card with cpu_get_syndicate FIRST and resubmit the full state with your edits applied, otherwise you will silently wipe the fields you omit. Rates are percentages 0–100 on whole basis-point steps. Manager and creation time are untouched. Writes on-chain (a wallet transaction). Fails clearly if you are not the manager, on an empty/over-long name or over-long link, on a rate above 100%, or if the registry is not deployed on this network.

Hand the manager role of a syndicate you manage to a successor wallet. IRREVERSIBLE: once transferred you can no longer change the syndicate’s params, and the entire member-tax stream (the tax members pay on trades and shipments) immediately starts paying the new manager instead of you — you cannot take it back unless the new manager transfers it back. Double-check the successor address. Writes on-chain (a wallet transaction). Fails clearly if you are not the current manager, if the successor is the zero address, or if the registry is not deployed on this network.

Preview an ETH↔$CPU swap without committing: returns the expected output from the Uniswap v4 Quoter (already net of the pool fee) and the minimum you would receive after slippage (a percent, e.g. 0.5 = 0.5%). It has no side effects — no approval, no transaction. Use it before cpu_swap to size the trade.

Swap between native ETH and $CPU on the game token pool (Uniswap v4), in either direction: sell: "ETH" buys $CPU, sell: "CPU" sells it for ETH. amount is how much of the sold token to spend. Preview the result first with cpu_quote_swap. The swap is exact-input: you spend amount and receive at least the quoted output minus slippage (a percent, e.g. 0.5 = 0.5%). Selling $CPU auto-approves it (via Permit2) once before the first swap; the trade is submitted on-chain and this waits for confirmation. A 1% pool fee applies.

Preview a primary-market land mint without committing: reads the live OpenSea SeaDrop public drop and returns the per-cell ETH price and the total for quantity cells, plus the drop window and per-wallet limit. It has no side effects — no transaction. Use it before cpu_mint_cell to size the buy and confirm the drop is active.

Mint new land cells on the primary market, straight from the collection’s OpenSea SeaDrop public drop — paid in native ETH, no $CPU involved. quantity cells are minted to your connected wallet at the on-chain drop price; preview the exact ETH cost first with cpu_quote_mint. The mint is submitted on-chain and this waits for confirmation. Check cpu_get_balance for enough ETH (mint price × quantity, plus gas) before calling. For existing cells on the secondary market, use OpenSea listings instead (see the land contract link in the server instructions).

Show the wallet's spendable funds: $CPU (the game currency — paid for reveal, build, craft, transport, and trade) and the native gas balance, each a human-readable decimal. Check this before paid actions to avoid failed or stranded payments. Requires a configured wallet (no session needed).

Cash out a cell’s wCPU (resource id 1, the CPU Forge output) to the on-chain $CPU token in your wallet, 1:1 (needs a session — cpu_authenticate first; you must own the cell). Pass the amount in whole wCPU units up to the cell’s wCPU balance; it debits the cell and mints $CPU to your wallet (no approve needed). If the on-chain $CPU emission budget cannot cover the full amount, only a partial tranche executes — up to what remains — and the rest stays in the cell; the result reports the requested and executed amounts separately. Waits for confirmation and returns the tx hash — check the result with cpu_get_balance. wCPU lives on the cell, so selling or transferring the cell takes it along: withdraw before you sell.