planes.gno

  1package planes
  2
  3import (
  4	"chain"
  5	"strconv"
  6	"strings"
  7
  8	"gno.land/p/nt/bptree/v0"
  9	"gno.land/p/nt/grc721/royalty/v0"
 10	"gno.land/p/nt/grc721/v0"
 11)
 12
 13// The read side of the collection, exported for other realms and for
 14// vm/qeval, as GRC721 tokens are on gno.land. Neither type has a mutator: a
 15// Token hands out tellers that act as the calling realm and go through the
 16// ledger's approval checks, Royalty only reads. There is no metadata
 17// extension: the traits are in the table, read with TokenMetadata(tid) and
 18// PlaneJSON(id), and the token URI, the image, is computed by TokenURI(tid).
 19//
 20//	planes.TokenMetadata("42")
 21//	planes.Token.RealmTeller(0, cur).TransferFrom(0, cur, from, to, "42")
 22var (
 23	Token     *grc721.Token    // name, symbol, owners, balances, approvals
 24	Royalties *royalty.Royalty // EIP-2981 royalty
 25)
 26
 27// The rest of the state. Everything is unexported and nothing below is ever
 28// returned by reference: the ledgers and the trees are /p/ types with mutator
 29// methods, so handing one out would be handing out write access to the
 30// collection.
 31var (
 32	ledger        *grc721.PrivateLedger // the collection, write side: mint, burn
 33	teller        grc721.Teller         // acts as the caller of this realm: transfers and approvals
 34	royaltyLedger *royalty.Ledger       // royalty, write side
 35
 36	mintCount int64  // planes minted so far, burned ones included; the ids left are in pool (draw.gno)
 37	price     int64  // ugnot, what a mint costs
 38	mintOpen  bool   // whether Mint is accepting calls
 39	mintCap   int64  // how many planes one wallet may mint, over its lifetime
 40	imageBase string // "https://gnofly.xyz/nft/collections/planes/", the image of plane 42 is at <base>042.png
 41
 42	mints      bptree.BPTree // minter address -> int64, planes minted so far, for the cap
 43	tierMinted [4]int64      // planes minted so far per tier, in the order of tiers
 44	recent     [5]int64      // the last ids minted, newest first, 0 for none, for Render
 45
 46	webPath string // "/r/g1t2kg2vtr3fukg43eujkn6x53gfdyakhngt4sfd/gnofly/nfts/planes", used to build links in Render
 47)
 48
 49// The collection, and the settings at deploy.
 50const (
 51	supply      = int64(777)
 52	tokenName   = "gnofly planes"
 53	tokenSymbol = "PLANE"
 54	payDenom    = "ugnot" // the only coin planes are sold for
 55
 56	defaultPrice     = int64(77000000) // 77 GNOT
 57	minPrice         = int64(1000000)
 58	maxPrice         = int64(10000000000)
 59	defaultMintCap   = int64(7)
 60	defaultImageBase = "https://gnofly.xyz/nft/collections/planes/"
 61
 62	defaultRoyaltyBps = int64(500)  // 5% of a resale, to the treasury
 63	maxRoyaltyBps     = int64(1000) // the most SetRoyaltyBps accepts
 64
 65	// Models are what the game client renders, tiers are what the table
 66	// says. Both are validated against these lists.
 67	models = "prop,biplane,stunt,jet,seaplane,twin,delta,glider,supergnome"
 68	pilots = "none,gnome"
 69	tiers  = "common,rare,epic,legendary"
 70)
 71
 72// tierSupply is how many planes of each tier the table holds, in the order
 73// of tiers. The tests check it against the table.
 74var tierSupply = [4]int64{500, 200, 70, 7}
 75
 76// tierIndex returns the position of tier in tiers, or -1.
 77func tierIndex(tier string) int {
 78	for i, t := range strings.Split(tiers, ",") {
 79		if t == tier {
 80			return i
 81		}
 82	}
 83	return -1
 84}
 85
 86// init runs once, when the package is added to the chain. The realm has
 87// nothing to remember about its deployer: it has no role of its own.
 88func init(cur realm) {
 89	bootstrap(0, cur)
 90}
 91
 92// bootstrap (re)creates the initial state: the token, its extensions and the
 93// settings. The tests call it to start from a clean slate. rlm is the live
 94// realm of the caller: grc721 records its package path as the home of the
 95// Token.
 96func bootstrap(_ int, rlm realm) {
 97	// A table of the wrong shape is refused before anything is written, so
 98	// that a bad hand edit fails at publish rather than at the first mint.
 99	if first, last := rowID(0), rowID(len(table)-1); first != 1 || last != supply {
100		panic(errBadTable)
101	}
102
103	Token, ledger = grc721.NewToken(tokenName, tokenSymbol, 0, rlm)
104	// Minted from the ledger: the frame-relative teller is confined to this
105	// realm, which is where it is used.
106	teller = ledger.CallerTeller()
107	Royalties, royaltyLedger = royalty.NewRoyalty(ledger, maxRoyaltyBps)
108
109	mintCount = 0
110	resetPool(rlm.PkgPath())
111	recent = [5]int64{}
112	price = defaultPrice
113	mintOpen = false
114	mintCap = defaultMintCap
115	imageBase = defaultImageBase
116	mints = bptree.BPTree{}
117	tierMinted = [4]int64{}
118	webPath = webPathOf(rlm.PkgPath())
119
120	// Under `gno test` the game realm has no treasury yet (see roles.gno):
121	// the tests set one and call bootstrap again.
122	if roles.Treasury().IsValid() {
123		setRoyalty(defaultRoyaltyBps)
124	}
125}
126
127// setRoyalty points the royalty of every plane at the treasury of the game
128// realm, as it is now, at bps basis points.
129func setRoyalty(bps int64) {
130	if err := royaltyLedger.SetDefaultRoyalty(roles.Treasury(), bps); err != nil {
131		panic(err)
132	}
133}
134
135// SetMintOpen opens or closes the mint. Admin only. The mint starts closed.
136func SetMintOpen(cur realm, open bool) {
137	assertAdmin(0, cur)
138	mintOpen = open
139	chain.Emit("MintOpen", "open", boolString(open))
140}
141
142// SetPrice sets what a mint costs, from 1 to 10000 GNOT. Admin only. It
143// applies to the next mint.
144func SetPrice(cur realm, ugnot int64) {
145	assertAdmin(0, cur)
146	if ugnot < minPrice || ugnot > maxPrice {
147		panic(errInvalidPrice)
148	}
149	price = ugnot
150	chain.Emit("PriceSet", "price", itoa(ugnot))
151}
152
153// SetMintCap sets how many planes one wallet may mint over its lifetime, from
154// 1 to 777. Admin only. A wallet already over a lowered cap keeps its planes
155// and mints no more.
156func SetMintCap(cur realm, n int64) {
157	assertAdmin(0, cur)
158	if n < 1 || n > supply {
159		panic(errInvalidCap)
160	}
161	mintCap = n
162	chain.Emit("MintCapSet", "cap", itoa(n))
163}
164
165// SetImageBase sets where the images and the metadata of the planes are
166// served from: the image of plane 42 is <base>042.png and its token URI is
167// <base>42.json. Admin only.
168//
169// It applies at once to every plane: the URLs are computed on read, nothing
170// is stored per token.
171func SetImageBase(cur realm, base string) {
172	assertAdmin(0, cur)
173	if !validBase(base) {
174		panic(errInvalidBase)
175	}
176	imageBase = base
177	chain.Emit("ImageBaseSet", "base", base)
178}
179
180// SetRoyaltyBps sets the royalty of a resale, from 0 to 1000 basis points,
181// and points it at the treasury of the game realm as it is now. Admin only.
182//
183// The royalty is advisory, as EIP-2981 is: a marketplace reads RoyaltyInfo
184// and pays it, the realm cannot enforce it on a transfer.
185func SetRoyaltyBps(cur realm, bps int64) {
186	assertAdmin(0, cur)
187	if bps < 0 || bps > maxRoyaltyBps {
188		panic(errInvalidRoyalty)
189	}
190	setRoyalty(bps)
191}
192
193// Minted returns how many planes were minted so far, burned ones included.
194// Planes are drawn at random, so it says nothing of which ids. The
195// settings (price, open, cap, image base, royalty) are read with
196// CollectionJSON: every exported function costs storage at deploy, measured
197// at about 650 bytes each, so there is no getter per setting.
198func Minted() int64 {
199	return mintCount
200}
201
202// webPathOf turns "gno.land/r/g1t2kg2vtr3fukg43eujkn6x53gfdyakhngt4sfd/gnofly/nfts/planes" into "/r/g1t2kg2vtr3fukg43eujkn6x53gfdyakhngt4sfd/gnofly/nfts/planes".
203func webPathOf(pkgPath string) string {
204	for i := 0; i < len(pkgPath); i++ {
205		if pkgPath[i] == '/' {
206			return pkgPath[i:]
207		}
208	}
209	return ""
210}
211
212// imageURL returns where the image of plane id is: <image base><id>.png,
213// the id on three digits, "042.png", as the image files are named. The token
214// URI keeps the plain id, "42.json".
215func imageURL(id int64) string {
216	return imageBase + pad3(id) + ".png"
217}
218
219// pad3 writes an id of 1 to 777 on three digits: 7 -> "007", 42 -> "042".
220func pad3(id int64) string {
221	s := itoa(id)
222	for len(s) < 3 {
223		s = "0" + s
224	}
225	return s
226}
227
228func itoa(n int64) string {
229	return strconv.FormatInt(n, 10)
230}
231
232func boolString(b bool) string {
233	if b {
234		return "true"
235	}
236	return "false"
237}