game33 state

order

padU

hexDigits

priceKey

priceKey = want-per-give × 1e12 as a fixed-width 24-hex-digit number (96 bits; amounts ≤ 1e15 keep it \< 2^90). Lexicographic = numeric order, so ascending book keys are the cheapest asks first for takers.

sideEntryLen

// priceKey(24) + id(12) + maker address(40)

sideSortLen

// entries sort by priceKey then id (FIFO within a price)

maxSideOrders

// open orders per book side; bounds every string we rewrite

encodeOrder

maker record: id12|give|want|remGive|remWant|expiry|pk

decodeOrder

makerRecs

setMakerRecs

loadOrderOf

loadOrderOf finds one of maker's open orders (≤ 20 records scanned).

saveOrder

sideKey

sideEntry

sideStr

sideSearch

sideSearch returns the index of the first entry whose sort key is ≥ key.

sideInsert

sideRemove

iterSide

iterSide walks a taker's side (pays \`pay\`, gets \`get\`) best price first.

sideCount

grinValueMilli

grinValueMilli = amt × reference value (milli-grin), saturating at 2^64-1.

openOrderCount

PlaceOrder

PlaceOrder escrows giveAmt of \`give\` and lists it for wantAmt of \`want\` (any pair). No upfront posting fee — the 0.90% maker fee is deducted from the maker's proceeds at fill time. Returns the order id. expirySecs 0 = 72 h; max 7 days.

closeOrder

closeOrder refunds the remaining escrow to the MAKER (never anyone else) and deletes the order. Every close path goes through here.

CancelOrder

CancelOrder: the maker gets the remaining escrow back. Works while paused and for banned makers; only the maker can cancel.

SweepExpiredOrders

SweepExpiredOrders closes up to maxScanPerTx expired orders of one book side, refunding each maker. Anyone may call it (also while paused).

fillStep

planFills

planFills walks the book for a taker (read-only). budget is the most the taker will spend INCLUDING the taker fee. Own orders are skipped (no self-match); expired orders are returned for closing.

executeFills

executeFills applies a plan: the taker pays each maker x (plus taker fee), receives g from escrow. The maker receives x minus the 0.90% maker fee (deducted from proceeds, not from escrow). Returns total received by taker.

FillOrders

FillOrders: spend at most payAmt of \`pay\` (taker fee included) on the best-priced orders that give \`get\`; receive at least minGet or revert. ≤ 10 fills and ≤ 20 scanned entries per call.

orderJSON

Order

Order shows one open order of \`maker\` (lookups are per maker by design).

OrdersOf

OrdersOf lists an address's open orders (≤ 20 by construction).

BookDepth

BookDepth lists asks for a taker who pays \`pay\` and gets \`get\`, best price first (≤ 50 rows; offset \< maxSideOrders).

QuoteFill

QuoteFill previews FillOrders for a budget (fee included): {"spent","got"}.

hubCoin

poolFeeBps

protoFeeBps

minLiquidity

// first-deposit shares burned forever

minOpenDepthGrin

// a pool takes swaps only once rGrin ≥ this

warmupSecs

// LP fee warm-up (principal always instant)

rootKScale

takerFeeBps

makerFeeBps

minOrderGrinX1k

// 50 grin of value (reference table) — size floor only

maxOpenOrders

defaultExpiry

maxExpiry

maxFillsPerTx

maxScanPerTx

maxViewLimit

maxAmount

// 1e15

prefMilli

Reference value per rarity in milli-grin (RARITY\_VALUE ×1000). Used ONLY for the 50-grin minimum order size — never for prices.

pools

// coin → \*pool

lpPositions

// coin+":"+addr → \*lpPos

adminFees

// coin → admin's accrued protocol fees (pull)

casinoPool

// coin → casino pool balance (fees in, capped jackpots out)

makerBooks

// maker → ";"-joined compact order records (≤ maxOpenOrders)

sides

// want+">"+give → sorted fixed-width entries (≤ maxSideOrders)

openOrderTotal

nextOrderId

exPaused

adminFeesWithdrawn

// coin → lifetime withdrawn by the admin

adminGnotWithdrawn

// ugnot withdrawn by WithdrawFunds (≤ passRevenueUgnot)

addChk

subChk

mulDiv

mulDiv = floor(a\*b/c) with a 128-bit product; panics if c == 0 or the quotient does not fit in 64 bits.

mulDivUp

mulDivUp = ceil(a\*b/c).

isqrt128

isqrt128 = floor(sqrt(a\*b)) for the 128-bit product (Newton, bounded).

isqrt

mulLess

mulLess reports a\*b \< c\*d using 128-bit products.

requireBalance

requireBalance checks a balance before any write, so a failing call changes nothing (validate-then-write).

requireAmount

u

exchangeCaller

exchangeCaller returns the caller for exchange writes. Only end users (an EOA MsgCall or the user's own MsgRun) may trade: other realms can't act through the exchange, so there is no cross-realm call surface at all.

requireMarketOpen

requireMarketOpen gates NEW activity (swaps, deposits, orders, fills). Trading opens only after FinalizeMigration: MigrateBatch SETs balances, so trading before that could duplicate or lose escrowed coins.

requireDeadline

requireCoin

accrueProtocolFee

accrueProtocolFee splits amt of coin 50/50: the floor half to the admin's fee ledger, the rest to the casino pool. Both stay inside the realm.

WithdrawProtocolFees

WithdrawProtocolFees moves the admin's OWN accrued fees for \`coin\` into the admin's balance. It reads only adminFees (never reserves, escrow, the casino pool or anyone's balance) and works while paused.

SetExchangePaused

SetExchangePaused stops NEW swaps, deposits, orders and fills. It can't stop RemoveLiquidity, CancelOrder, SweepExpiredOrders or fee withdrawals.

ExchangeStatus

ProtocolFees

DepositGnot

DepositGnot wraps the ugnot attached to this MsgCall into the exchange's internal "gnot" balance, enabling the player to trade or provide GNOT liquidity. Attach the desired ugnot amount to the MsgCall as a send value.

WithdrawGnot

WithdrawGnot converts internal "gnot" balance back to real ugnot and sends it to the caller. Works while the exchange is paused — it is an exit, not a trade. Any player can call this for their own balance at any time.

gnotPools

// coin → \*pool (reuses the pool struct from exchange\_pool.gno)

gnotLpPositions

// coin+":"+addr → \*lpPos

gnotPool

gnotPool returns the COIN/GNOT pool for coin, panicking if it doesn't exist.

OpenGnotPool

OpenGnotPool creates a new COIN/GNOT pool and seeds the first liquidity, atomically setting the opening price. Any player who holds the coin and enough deposited GNOT can call this — no admin required. coinAmt/gnotAmt set the price ratio; whoever opens the pool first controls the opening price. 1,000 shares are permanently burned as a seed.

AddGnotLiquidity

AddGnotLiquidity deposits up to coinMax of \`coin\` and gnotMax internal GNOT. Follows the current pool ratio. Reverts unless at least minShares are minted.

RemoveGnotLiquidity

RemoveGnotLiquidity is always available — works while the exchange or pool is paused. Returns (coinOut, gnotOut).

poolSwapGnot

poolSwapGnot executes one hop (coin↔gnot) for internal routing. The caller's input must already have been debited.

GnotBalance

GnotBalance returns the caller's internal GNOT balance (deposited ugnot).

GnotPoolInfo

GnotPoolInfo returns the state of the COIN/GNOT pool for \`coin\`.

GnotPools

GnotPools lists COIN/GNOT pools (paginated, ≤ 50 per call).

QuoteGnotSwap

QuoteGnotSwap quotes a single GNOT-pool swap; "0" if unavailable.

GnotLpPosition

GnotLpPosition shows one GNOT LP position and current withdrawal value.

GnotLpPositions

GnotLpPositions lists all GNOT LP positions for an address (paginated).

pool

lpPos

getPool

rootKPerShare

CreatePool

CreatePool opens an empty COIN/GRIN pool (admin, per the launch schedule). It holds nothing until players deposit; the admin can't deposit for anyone, withdraw from it or close it.

OpenPool

OpenPool creates a new COIN/GRIN pool and immediately deposits the first liquidity, atomically setting the opening price. Any player who holds the coin and enough Grin can call this — no admin required. coinAmt and grinAmt set the price ratio; whoever calls this first for a coin controls the opening price, so choose amounts that reflect the coin's real value. 1,000 shares are permanently burned as a sandwich-resistance seed. Returns the number of LP shares minted for the caller.

SetPoolPaused

SetPoolPaused stops new swaps and deposits on one pool. Withdrawals stay open.

AddLiquidity

AddLiquidity deposits up to coinMax of \`coin\` and grinMax grin. The first deposit sets the price (open economy: any ratio) and burns minLiquidity shares; later deposits take the current ratio (never more than either cap). Reverts unless at least minShares are minted.

lpPayout

lpPayout computes what \`shares\` of a position withdraw right now: pro-rata of CURRENT reserves (floor). Within the warm-up the fee growth since entry (√k/share above entry) stays in the pool for the other LPs; principal is never cut below its entry-value share.

RemoveLiquidity

RemoveLiquidity is instant and ALWAYS available: it works while the exchange or the pool is paused, before or after a ban, and needs no tool. Nobody but the position owner can call it for that position.

poolQuote

poolQuote returns (out, protoFee) for amountIn of the input side; no writes.

poolOpenForSwaps

poolSwap

poolSwap executes one hop (coin↔grin) for \`caller\`, crediting nothing to the caller: it returns the output so routes can chain hops. The caller's input must already have been debited.

SwapExactIn

SwapExactIn swaps amountIn of coinIn for at least minOut of coinOut through one pool (one side must be grin). For X→Y via grin use SwapRoute.

poolJSON

PoolInfo

Pools

Pools lists pools in coin order (paginated, ≤ 50 per call).

QuoteSwap

QuoteSwap quotes a single-pool swap; "0" if the pool can't take it.

LpPosition

LpPosition shows one position and what it would withdraw right now.

LpPositions

LpPositions lists an address's positions (bounded: at most one per pool, paginated by pool order, ≤ 50 pools scanned per call).

poolPathOut

poolPathOut quotes amountIn of coinIn → coinOut through the grin pools (one hop if either side is grin, else coinIn→grin→coinOut). ok=false if a needed pool is missing or not open. Read-only.

gnotPathOut

gnotPathOut quotes amountIn of coinIn → coinOut through GNOT pools. Handles: gnot↔coin (one GNOT pool hop), coin↔coin via gnot hub (two hops). Read-only; ok=false if no suitable GNOT pool exists or is open.

bestPathOut

bestPathOut returns the best available output from either GRIN or GNOT pools. Read-only; used by routePlanAny for GNOT-aware routing.

routePlan

routePlan splits amountIn between book fills (direct pair) and the pool path. A book fill is taken while its rate is at least the pool path's average rate for the whole remainder; everything else goes to the pools.

SwapRoute

SwapRoute swaps up to amountIn of coinIn for at least minOut of coinOut, using the order book (direct pair) while it beats the pools and the grin pools for the rest. Coins not needed are never debited.

QuoteRoute

QuoteRoute previews SwapRoute: how much goes to the book vs the pools and the expected output (fees included).

requireCoinOrGnot

requireCoinOrGnot validates a coin for GNOT-aware routes.

gnotRoutePlan

gnotRoutePlan is routePlan extended to also check GNOT pools. It uses bestPathOut (max of GRIN and GNOT pool outputs) for the pool comparison.

executeGnotPoolSwap

executeGnotPoolSwap executes the pool leg of a GNOT-aware swap, choosing the better route (GRIN or GNOT pools) for the given pair.

SwapRouteGnot

SwapRouteGnot swaps coinIn for coinOut where either side may be "gnot". Uses the order book first (same as SwapRoute) then the best available pool (GRIN or GNOT, whichever gives better output).

QuoteRouteGnot

QuoteRouteGnot previews SwapRouteGnot (either side may be "gnot").

init.130

isAdmin

requireAdmin

TransferAdmin

TransferAdmin hands the admin role to another address.

transferAdmin

UpdateConfig

UpdateConfig is kept for game27/28 API compatibility (= TransferAdmin).

SetClaimSigner

SetClaimSigner registers the ed25519 public key (64 hex chars) of the server's claim signer. Pass "" to disable all vouchered calls (kill switch).

ClaimSigner

Admin

SetPaused

IsPaused

requireNotPaused

BanAddress

BanAddress bans a player address. durationSecs=0 means permanent.

UnbanAddress

BlacklistStatus

isBlacklisted

requirePlayer

veinMax

veinMintedOf

takeFromVein

takeFromVein returns how much of amt can still be minted for coinId and records it as minted.

SetVeinMax

SetVeinMax overrides a coin's vein size. It can't go below what was minted.

setVeinMax

RegisterVein

RegisterVein is the game28 name for SetVeinMax.

VeinSupply

SetPassPrice

SetPassPrice sets the ugnot price per 30-day period.

PassPrice

ActivateGnomePass

ActivateGnomePass buys durationDays (30..360, multiple of 30) of Gnome Pass. The tx must attach exactly passPrice × durationDays/30 ugnot (MsgCall send).

GnomePassExpiry

HasActivePass

GnomePassCount

PassRevenue

TreasuryBalance

TreasuryBalance returns the ugnot held by this realm (pass revenue not yet withdrawn).

WithdrawFunds

WithdrawFunds sends GNOT the admin is OWED — Gnome Pass revenue not yet withdrawn — to \`to\`. It can never touch other ugnot the realm holds (donations, anything a future feature would hold for players).

WithdrawableFunds

WithdrawableFunds = pass revenue the admin may still withdraw (ugnot).

MigrateBatch

── Migration (game31 → game32) ────────────────────────────────────────────── MigrateBatch(batchId, kind, rowsJson) imports one batch. rowsJson is a JSON array of string arrays. Kinds and row shapes: balance [addr, coinId, amount] → balances (SET, not add) lifetime [addr, coinId, amount] → lifetimeMined (SET) + miners total tools [addr, "t1,t2,..."] → ownedTools (SET, unknown ids dropped) toollife [addr, toolId, life] → toolLife (SET, clamped to max) skill [addr, skillId, rank] → skillRanks (SET, clamped to max) medal [addr, achievementId] → achievements (allowlisted ids only) pass [addr, expiryUnix] → gnomePasses (SET) guild [guildId, name, leader, "m1,m2,..."] → guilds + members ban [addr, reason, expiryUnix] → blacklist (expiry 0 = permanent) A batchId that was already applied is skipped, and every write is a SET, so re-running a whole migration is a no-op. FinalizeMigration locks it forever. Every unique player address in a batch is recorded in migrationAddrs so that MigrationStatus can report how many distinct players were migrated.

FinalizeMigration

MigrationStatus

MigrationStatus returns a JSON object with: - finalized: bool — true once FinalizeMigration has been called - batches: int — number of distinct batch IDs applied - addresses: int — number of distinct player addresses migrated across all batches

MigrationBatch

validAddr

migrateRow

casinoBets

// roundId+":"+addr → \*casinoBet

casinoReserved

// coin → largest net payouts of unsettled bets (string)

casinoDay

// coin → "day:snapshot:paid:received" (UTC day)

casinoWinRange

// winning rolls per pick (of 100) for flip/wheel

rpsWinBelow

// rps: roll \< 33 player wins

rpsPushBelow

// rps: 33..64 push

casinoBetWindowSec

// a committed round takes its bet within 1 h

casinoSeedTimeoutSec

// refunds open 30 min after the bet if s is never revealed

casinoSecretTimeoutSec

// the bet forfeits 24 h after s if c is never revealed

casinoMaxBetBps

// flip / wheel / rps bet ≤ 0.5% of the free pool

slotsMaxBetPPM

// slots bet ≤ 0.004% of the free pool

casinoOpenBps

// open reservations on a coin ≤ 20% of the pool

casinoDayBps

// daily net payout ≤ 10% of the day's snapshot

casinoMinPoolMilli

// ≥ 20,000 grin-equivalent …

casinoMinPoolUnits

// … and ≥ 200 units of the coin

casinoMaxAmount

casinoRefMilli

Reference value per unit by rarity, in milli-grin (same table as the exchange plan): only used for the pool's opening threshold.

casinoRound

casinoBet

isOperator

isOperator: the casino operator key commits and reveals server seeds. Once an operator is set, only that key can; the admin (treasury) key only stands in while no operator has been named yet (bootstrap and tests).

SetOperator

SetOperator lets the admin name the server account that commits and reveals casino seeds. It must be its own key, never the admin/treasury key. The operator can't move anyone's coins.

Operator

casinoStats

// coin:field or coin:game:field → uint (string)

casStat

casRecord

CasinoStats

CasinoStats reports a coin's accounting: pool, reserved, jackpots, seeded, staked, paid, the conservation check and per-game rounds/staked/paid.

casGet

casSet

casAdd

casSub

casMulDiv

casMulDiv = floor(a\*b/c) with a 128-bit product.

casMul

casU

casBalOf

casCredit

casDebit

casGrinValueMilli