planes state

pool

pool holds the ids not minted yet, two bytes each. Its length over two is how many are left.

mintedBits

mintedBits has one bit per id, set once the id is minted (burned or not): what tells a burned plane from one not minted yet, without scanning pool.

lastDraw

lastDraw is the hash of the previous draw, chained into the next.

testDraw

testDraw, when set by a test, replaces the hash to pick an index in a pool of n ids. It is never set outside the tests.

resetPool

resetPool fills the pool with every id, from 777 down to 1, and seeds the chain of draws from the realm's path.

left

left returns how many ids are not minted yet.

drawHash

drawHash is the hash a draw picks its index from. It is a pure function of its inputs, so that the tests can check what moves it.

drawID

drawID takes one id out of the pool, at random, for minter, and marks it minted. The pool must not be empty.

wasMinted

wasMinted reports whether id was ever minted, burned since or not.

errSpoofedRealm

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errNotAdmin

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errBadTable

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errCorruptRow

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errUnknownPlane

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errNotMinted

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errNotPlaneOwner

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errMintClosed

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errSoldOut

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errCapReached

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errNotUserCall

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errInvalidCount

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errInvalidPrice

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errInvalidCap

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errInvalidBase

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

errInvalidRoyalty

The refusals of this realm, as strings. The game and arena realms keep theirs as error values; this one is published with a 42 KB table and every byte of state is paid for at deploy. Measured on a mainnet-like node, an errors.New value costs about 1.15 KB of storage (a pointer, a heap item and a struct, each with its header) where a string constant costs its length: twenty of them are 2 GNOT against 0.1. A panic with a string aborts the call with the same message.

PlaneJSON

PlaneJSON returns one plane as a JSON object, minted or not: { "id": 42, "name": "Storm Saint", "model": "delta", "pilot": "gnome", "body": "#1e1b4b", "wing": "#1e293b", "accent": "#00f5ff", "tier": "epic", "laser": "#39ff14", "image": "https://gnofly.xyz/nft/collections/planes/042.png", "owner": "g1..." } The output has no whitespace. "owner" is "" for a plane not minted, or burned. An id outside 1 to 777 returns "". Which plane a pilot flies is not on-chain: the game server checks the owner when a pilot picks one.

PlanesOf

PlanesOf returns the ids of the planes addr owns as a JSON array, in ascending order: \[3,42,700]. It is \[] for an address without planes.

maxMintedPage

maxMintedPage is the most ids MintedJSON looks at in one call.

MintedJSON

MintedJSON returns who owns the minted planes among the ids offset+1 to offset+limit, as a JSON array in id order: [{"id":3,"owner":"g1..."},{"id":42,"owner":""},...] Ids not minted are left out; "owner" is "" for a burned plane. limit is capped at 200, so four calls (offsets 0, 200, 400, 600) cover the 777, whatever was minted: planes are drawn at random, minted ids are not a prefix. It is what the website's grid reads. An empty range is \[].

CollectionJSON

CollectionJSON returns the state of the collection as one JSON object: { "name": "gnofly planes", "symbol": "PLANE", "supply": 777, "minted": 12, "burned": 0, "price": 77000000, "open": true, "cap": 7, "royaltyBps": 500, "treasury": "g1...", "imageBase": "https://gnofly.xyz/nft/collections/planes/", "tiers": { "common": { "supply": 500, "minted": 8 }, "rare": { "supply": 200, "minted": 3 }, "epic": { "supply": 70, "minted": 1 }, "legendary": { "supply": 7, "minted": 0 } } } The output has no whitespace. "minted" counts every mint so far, burned planes included; "minted" minus "burned" is what exists.

writePlane

writePlane writes the nine fields of a plane, in the order of a row, so that a caller can add fields after them.

encode

encode marshals a document built above. It cannot fail on a document built from the builder, so a failure is a bug and panics.

maxBatch

maxBatch is the most planes one Mint call mints. It is a constant, apart from the per-wallet cap that admins tune with SetMintCap.

Mint

Mint mints count planes for the caller, 1 to 7 in one call, drawn at random among the ids not minted yet (draw.gno), and returns their ids in the order drawn. Exactly count times the price must be attached to the transaction (-send "\<count\*price>ugnot"); it is forwarded to the treasury of the game realm, in one send, before the call returns. Each id comes out once, while the mint is open. A batch is minted whole or not at all: one that would take the caller over the per-wallet cap, or past the last plane, is refused with how many are left. It must be called directly by a user (maketx call): a call relayed by another realm or by a maketx run script is refused. That is also what keeps the draw fair: a contract could otherwise look at the ids it got and panic to draw again. The caller pays the storage of their planes as a deposit on top of the price, given back on burn: the ledger entries only, the traits stay in the table (see the numbers in docs/spec.md, section 9.2).

mintedBy

mintedBy returns how many planes addr minted so far.

TokenMetadata

TokenMetadata returns the metadata of a minted plane as JSON, built from the table on every read: the realm stores no metadata per token. {"name":"Storm Saint","description":"Plane 42 of 777, ...", "image":"https://gnofly.xyz/nft/collections/planes/042.png", "attributes":[{"traitType":"model","value":"delta"}, ...]} The keys are the ones Adena reads, traitType included.

mintedID

mintedID reads a token id, "1" to "777", and checks the plane is minted.

parseID

parseID reads "1" to "777" in decimal, 0 for anything else.

description

description is one sentence about a plane: "Plane 42 of 777, an epic delta flown by a gnome." The tier is the only word that may start with a vowel.

Burn

Burn destroys a plane. Only its owner can, and nobody can mint it again: the id stays out of circulation.

TransferFrom

TransferFrom moves plane id from one address to another. The caller must own it or be approved for it.

Approve

Approve lets to move plane id once. The caller must own it. An empty address revokes.

SetApprovalForAll

SetApprovalForAll lets operator move every plane of the caller, or revokes it.

ownerOf

OwnerOf

BalanceOf

BalanceOf returns how many planes addr owns.

TotalSupply

TotalSupply returns how many planes exist: minted and not burned.

GetApproved

IsApprovedForAll

IsApprovedForAll reports whether operator may move every plane of owner.

TokenURI

TokenURI returns the image of a minted plane, "\<image base>\<nnn>.png": what a wallet shows (Adena puts it in an \<img>). The metadata is TokenMetadata, or "\<image base>\<id>.json" on the website. It is computed, not stored: a mint writes no URI.

RoyaltyInfo

RoyaltyBps

RoyaltyBps returns the royalty of a resale, in basis points.

Token

// name, symbol, owners, balances, approvals

Royalties

// EIP-2981 royalty

ledger

// the collection, write side: mint, burn

teller

// acts as the caller of this realm: transfers and approvals

royaltyLedger

// royalty, write side

mintCount

// planes minted so far, burned ones included; the ids left are in pool (draw.gno)

price

// ugnot, what a mint costs

mintOpen

// whether Mint is accepting calls

mintCap

// how many planes one wallet may mint, over its lifetime

imageBase

// "[https://gnofly.xyz/nft/collections/planes/](https://gnofly.xyz/nft/collections/planes/)", the image of plane 42 is at \<base>042.png

mints

// minter address -> int64, planes minted so far, for the cap

tierMinted

// planes minted so far per tier, in the order of tiers

recent

// the last ids minted, newest first, 0 for none, for Render

webPath

// "/r/g1t2kg2vtr3fukg43eujkn6x53gfdyakhngt4sfd/gnofly/nfts/planes", used to build links in Render

supply

The collection, and the settings at deploy.

tokenName

The collection, and the settings at deploy.

tokenSymbol

The collection, and the settings at deploy.

payDenom

// the only coin planes are sold for

defaultPrice

// 77 GNOT

minPrice

The collection, and the settings at deploy.

maxPrice

The collection, and the settings at deploy.

defaultMintCap

The collection, and the settings at deploy.

defaultImageBase

The collection, and the settings at deploy.

defaultRoyaltyBps

// 5% of a resale, to the treasury

maxRoyaltyBps

// the most SetRoyaltyBps accepts

models

The collection, and the settings at deploy.

pilots

The collection, and the settings at deploy.

tiers

The collection, and the settings at deploy.

tierSupply

tierSupply is how many planes of each tier the table holds, in the order of tiers. The tests check it against the table.

tierIndex

tierIndex returns the position of tier in tiers, or -1.

init.82

bootstrap

bootstrap (re)creates the initial state: the token, its extensions and the settings. The tests call it to start from a clean slate. rlm is the live realm of the caller: grc721 records its package path as the home of the Token.

setRoyalty

setRoyalty points the royalty of every plane at the treasury of the game realm, as it is now, at bps basis points.

SetMintOpen

SetMintOpen opens or closes the mint. Admin only. The mint starts closed.

SetPrice

SetPrice sets what a mint costs, from 1 to 10000 GNOT. Admin only. It applies to the next mint.

SetMintCap

SetMintCap sets how many planes one wallet may mint over its lifetime, from 1 to 777. Admin only. A wallet already over a lowered cap keeps its planes and mints no more.

SetImageBase

SetImageBase sets where the images and the metadata of the planes are served from: the image of plane 42 is \<base>042.png and its token URI is \<base>42.json. Admin only. It applies at once to every plane: the URLs are computed on read, nothing is stored per token.

SetRoyaltyBps

SetRoyaltyBps sets the royalty of a resale, from 0 to 1000 basis points, and points it at the treasury of the game realm as it is now. Admin only. The royalty is advisory, as EIP-2981 is: a marketplace reads RoyaltyInfo and pays it, the realm cannot enforce it on a transfer.

Minted

Minted returns how many planes were minted so far, burned ones included. Planes are drawn at random, so it says nothing of which ids. The settings (price, open, cap, image base, royalty) are read with CollectionJSON: every exported function costs storage at deploy, measured at about 650 bytes each, so there is no getter per setting.

webPathOf

webPathOf turns "gno.land/r/g1t2kg2vtr3fukg43eujkn6x53gfdyakhngt4sfd/gnofly/nfts/planes" into "/r/g1t2kg2vtr3fukg43eujkn6x53gfdyakhngt4sfd/gnofly/nfts/planes".

imageURL

imageURL returns where the image of plane id is: \<image base>\<id>.png, the id on three digits, "042.png", as the image files are named. The token URI keeps the plain id, "42.json".

pad3

pad3 writes an id of 1 to 777 on three digits: 7 -> "007", 42 -> "042".

itoa

boolString

Render

Render returns the state of the collection as markdown, for gnoweb: "" the collection: minted, price, tiers, the last mints "plane/<id>" one plane: traits, owner "player/<addr>" the planes of one address Everything printed here is a row of the table, whose charset the tests pin, a setting validated when it was written, or an address the chain gave the realm. The two caller-supplied values, an id and an address, are printed only once parsed and found valid. Nothing needs markdown escaping. No images: the planes are drawn by the game and by the website.

link

link returns the gnoweb URL of a Render path of this realm.

renderHome

renderPlane

renderPlayer

planeLink

planeLink is "\[42 Storm Saint](.../plane/42)".

playerLink

playerLink is "\[g1...](.../player/g1...)".

gnot

gnot formats an amount of ugnot in GNOT, without trailing zeros: 77000000 gives "77 GNOT", 9500000 gives "9.5 GNOT".

percent

percent formats basis points as a percentage, without trailing zeros: 500 gives "5%", 250 gives "2.5%", 1 gives "0.01%".

plural

yesNo

recentIDs

recentIDs returns the last ids minted, newest first.

authority

authority is the set of questions this realm asks about roles.

gameRoles

gameRoles answers with the roles of the game realm.

roles

roles is the authority of this realm: the game realm, always. It is a variable for one reason. Under \`gno test\` an imported realm is initialized without a deployer, and a test of this package has no way to become an admin of the game realm, so the tests put their own answers here. Nothing outside the test files assigns it, and there is no setter.

callerOf

assertAdmin

plane

plane is one row of the table: what a plane looks like. Nothing here is stored per token, the table is the only copy.

row

row returns the line of plane id, or "" when there is no such row.

lineAt

lineAt returns the bounds of the line containing offset i: start is its first byte, end the offset of its newline, or len(table) for the last line.

rowID

rowID reads the id of the line containing offset i, or 0 when the line does not start with a number.

idAt

idAt reads the id at the start of the line table\[start:end].

parsePlane

parsePlane turns a row into a plane. It checks the shape of the row, not its values: those are the table's promise, checked by the tests.

getPlane

getPlane returns plane id from the table, or false when the id is out of range.

mustPlane

mustPlane returns plane id from the table, or panics.

tokenID

tokenID is the GRC721 id of plane id: its number, in decimal.

validName

validName reports whether s matches \[A-Za-z0-9 -]{1,24}.

validColor

validColor reports whether s is "#rrggbb" with lowercase hex digits.

validBase

validBase reports whether s can be an image base: an https URL ending in "/", 12 to 200 characters of \[A-Za-z0-9./\_-:]. The charset keeps it safe in JSON and markdown without escaping.

validAddress

validAddress reports whether addr is a valid address in its canonical, lowercase form, the only form the game realm and this one key on.

oneOf

oneOf reports whether s is one of the comma-separated words of list.

table

table holds the traits of the 777 planes, one per line, in id order: id|name|model|pilot|body|wing|accent|tier|laser Ids run from 1 to 777 with no gap. Names are unique and match \[A-Za-z0-9 -]{1,24}. Tiers are common (500), rare (200), epic (70) and legendary (7). Models are those the client draws: prop, biplane, stunt for a common plane, jet, seaplane, twin for a rare one, delta, glider for an epic one, any of them for a legendary one, and supergnome for id 777 alone. Pilot is none or gnome; the super-gnome is the gnome, its pilot is none. Colours are #rrggbb in lowercase, the first three all different; on the super-gnome they are its cape, its suit and its emblem. The laser is the colour of the shots the plane fires; it comes last, added after the first version of the table. It is one string, parsed on read: 777 rows as structs would cost about ten times the storage deposit at deploy. See rows.gno for the parser.