market.gno
18.35 Kb · 548 lines
1// Package market is the platform's immutable fixed-price market
2// (design §2.5.4). It never holds a token: the seller approves this
3// realm in core, the token stays in the seller's wallet, and Buy moves it
4// through core's official grc721 RealmTeller in the same transaction that
5// pays everyone. It never holds coins either (I-3).
6//
7// A token has at most one listing, addressed by (cid, tid). Stale listings
8// (RA H-2) cannot be bought: a listing pins the token's move counter and
9// core's approval nonces at listing time, and Buy requires owner == seller,
10// the counter unchanged and the approval it was listed under still in
11// place, unchanged (I-8). Once stale, a listing stays dead: approving the
12// market again later never revives it (SA-L3). A stale listing never blocks
13// the new owner: List overwrites it and anyone may CancelStale it.
14//
15// Storage (storage-cost-analysis M1-M3): a listing is one packed string in
16// `listings` (key cid:tid) plus one key in the price index `byCollection`
17// (floor, collection pages). Per-seller history comes from the indexer
18// ("Listed"/"Cancelled" events), not from an on-chain index.
19//
20// Deposit return: gno refunds a freed storage deposit to the signer of the
21// transaction that frees it, so a Buy hands the buyer the deposit the
22// seller locked for the listing. Buy therefore charges the buyer that
23// amount on top of the price and pays it to the seller (ListingDeposit,
24// measured). It is exact up to a few bytes because every listing costs the
25// same storage objects: a sentinel key keeps both trees non-empty (an avl
26// insert into an empty tree creates one node, any later insert two). Net,
27// the seller is whole and the buyer pays the price (the chain's refund
28// cancels the extra). Not compensated: the deposit of a per-token Approve,
29// which the sale's transfer clears (~0.1-0.2 GNOT to the buyer, depending
30// on the collection's other pending approvals); an approval-for-all is not
31// cleared, so listing under SetApprovalForAll leaves nothing behind.
32//
33// Pause ("trade" in core) stops List and Buy only. Cancel, CancelStale and
34// UpdatePrice are never paused (I-2).
35package market
36
37import (
38 "chain"
39 "chain/banker"
40 "chain/runtime"
41 "chain/runtime/unsafe"
42 "strconv"
43 "strings"
44
45 "gno.land/p/nt/avl/v0"
46 "gno.land/p/nt/grc721/v0"
47
48 "gno.land/p/g1jz6j9hj6rdf5ltl2kcrpa4jwtdh3w30z0yul06/sinopia/safe/v1"
49 "gno.land/p/g1jz6j9hj6rdf5ltl2kcrpa4jwtdh3w30z0yul06/sinopia/types/v1"
50 "gno.land/r/g1jz6j9hj6rdf5ltl2kcrpa4jwtdh3w30z0yul06/sinopia2/core"
51)
52
53const (
54 MaxPageSize = 50
55 priceWidth = 16 // types.MaxUnitPrice has 16 digits
56
57 // Deposit-return estimate (ugnot), from the bytes measured in this
58 // package's z_bytes_* filetests at gno.land's storage price of 100
59 // ugnot/byte (vm param storage_price on Onyx and gnoland-1). Re-measure
60 // before a deploy to a chain with another price.
61 StoragePrice = 100
62 ListingBytes = 4_070 // one listing: a listings key + a byCollection key, two avl nodes each (measured 4,049-4,101 locked, 4,032-4,091 freed)
63 ListingDeposit = ListingBytes * StoragePrice
64
65 // sentinel is a key of both trees that is never a listing (it sorts
66 // after every "cid:" prefix range), so neither tree is ever empty.
67 sentinel = "~"
68)
69
70// listing is the decoded form of one packed `listings` value.
71type listing struct {
72 cid, tid string
73 id int64
74 seller address
75 price int64
76 moves int64 // core.TokenMoves at listing time
77 height int64
78 feeBps int64 // protocol fee at listing time; a sale never pays more (SA-I5)
79 engBps int64 // engine-author fee at listing time; a sale never pays more
80 deposit int64 // deposit return the buyer pays the seller (ListingDeposit, not stored)
81 // approval the listing was made under (SA-L3): per-token and/or
82 // approval-for-all, each pinned to core's nonce at listing time
83 viaToken, viaAll bool
84 tokenNonce, operatorNonce int64
85}
86
87var (
88 listings avl.Tree // cid:tid -> packed listing (encode)
89 byCollection avl.Tree // cid:paddedPrice:tid -> "" (floor = first key)
90 nextID int64
91 selfPath string // captured in init for read paths without a cur
92)
93
94func init(cur realm) {
95 selfPath = cur.PkgPath()
96 listings.Set(sentinel, "")
97 byCollection.Set(sentinel, "")
98}
99
100// List offers a token of a Final collection at price (ugnot). The caller
101// must own it and have approved this realm (Approve or SetApprovalForAll in
102// core). A stale listing of the same token is replaced. Returns the
103// listing's sequence id (events); the listing itself is addressed by
104// (cid, tid).
105func List(cur realm, cid, tid string, price int64) string {
106 assertNoDeposit(cur)
107 assertTradeOpen()
108 assertPrice(price)
109 seller := cur.Previous().Address()
110 if core.Info(cid).State != types.StateFinal {
111 panic("tokens of this collection are locked until it is final")
112 }
113 owner, err := core.OwnerOf(cid, tid)
114 if err != nil {
115 panic(err)
116 }
117 if owner != seller {
118 panic("only the token owner can list it")
119 }
120 viaToken, viaAll := approvals(cid, tid, owner, cur.Address())
121 if !viaToken && !viaAll {
122 panic("approve the market for this token first: core.Approve(cid, tid, " + cur.Address().String() + ")")
123 }
124 if old, ok := lookup(cid, tid); ok {
125 if live(old, cur.Address()) {
126 panic("token is already listed as #" + itoa(old.id) + "; use UpdatePrice")
127 }
128 remove(old, "stale")
129 }
130
131 nextID++
132 tn, on := core.ApprovalNonces(cid, tid, owner, cur.Address())
133 _, engBps := core.EngineFee(cid)
134 l := &listing{
135 cid: cid, tid: tid, id: nextID, seller: seller, price: price,
136 moves: core.TokenMoves(cid, tid), height: runtime.ChainHeight(),
137 feeBps: core.FeeConfig().SecondaryBps, engBps: engBps,
138 viaToken: viaToken, viaAll: viaAll, tokenNonce: tn, operatorNonce: on,
139 }
140 l.deposit = ListingDeposit
141 store(l)
142 chain.Emit("Listed", "id", itoa(l.id), "cid", cid, "tid", tid, "seller", seller.String(), "price", itoa(price),
143 "deposit", itoa(l.deposit))
144 return itoa(l.id)
145}
146
147// UpdatePrice changes the price of a live listing; Buy's expectedPrice
148// protects buyers from a change racing their purchase (RA M-10).
149func UpdatePrice(cur realm, cid, tid string, price int64) {
150 assertNoDeposit(cur)
151 assertPrice(price)
152 l := mustListing(cid, tid)
153 assertSeller(cur, l)
154 if !live(l, cur.Address()) {
155 panic("listing is stale; cancel it and list again")
156 }
157 byCollection.Remove(collectionKey(l))
158 l.price = price
159 store(l)
160 chain.Emit("PriceUpdated", "id", itoa(l.id), "cid", l.cid, "tid", l.tid, "price", itoa(price))
161}
162
163// Cancel removes the caller's listing (its storage deposit returns to the
164// caller). Never paused.
165func Cancel(cur realm, cid, tid string) {
166 assertNoDeposit(cur)
167 l := mustListing(cid, tid)
168 assertSeller(cur, l)
169 remove(l, "cancelled")
170}
171
172// CancelStale lets anyone remove a listing that can no longer be bought;
173// the freed deposit goes to the caller (gno's rule), a cleanup bounty.
174func CancelStale(cur realm, cid, tid string) {
175 assertNoDeposit(cur)
176 l := mustListing(cid, tid)
177 if live(l, cur.Address()) {
178 panic("listing is still valid")
179 }
180 remove(l, "stale")
181}
182
183// Buy pays exactly expectedPrice for the token's listing, plus the
184// listing's deposit return (see the package doc); excess attached ugnot is
185// refunded. Order: checks, remove the listing, move the token, then pay —
186// protocol fee to the treasury, royalty to the collection's sub-treasury
187// (then distributed to its payees), the engine author's fee, the rest plus
188// the deposit return to the seller. I-4: protocol + royalty + engine +
189// seller + refund == attached.
190func Buy(cur realm, cid, tid string, expectedPrice int64) {
191 paid := received(cur)
192 assertTradeOpen()
193 buyer := cur.Previous().Address()
194 l := mustListing(cid, tid)
195 if l.price != expectedPrice {
196 panic("price is " + itoa(l.price) + "ugnot, expected " + itoa(expectedPrice))
197 }
198 if paid < l.price+l.deposit {
199 panic("send " + itoa(l.price+l.deposit) + "ugnot (price " + itoa(l.price) + " + deposit return " +
200 itoa(l.deposit) + "), sent " + itoa(paid))
201 }
202 if buyer == l.seller {
203 panic("cannot buy your own listing")
204 }
205 if !live(l, cur.Address()) {
206 panic("listing is stale: the token moved or approval was revoked since it was listed")
207 }
208 remove(l, "sold")
209
210 tok := core.Token(l.cid)
211 if err := tok.RealmTeller(0, cur).TransferFrom(0, cur, l.seller, buyer, grc721.TokenID(l.tid)); err != nil {
212 panic(err)
213 }
214
215 s := settle(l)
216 pay(cur, s.treasury, s.protocol)
217 pay(cur, s.royaltyTo, s.royalty)
218 pay(cur, s.engineAuthor, s.engine)
219 pay(cur, l.seller, s.seller)
220 pay(cur, buyer, paid-l.price-l.deposit)
221 if s.royalty > 0 {
222 core.DistributeRoyalties(cross(cur), l.cid)
223 }
224 chain.Emit("Bought", "id", itoa(l.id), "cid", l.cid, "tid", l.tid,
225 "seller", l.seller.String(), "buyer", buyer.String(), "price", itoa(l.price),
226 "protocolFee", itoa(s.protocol), "royalty", itoa(s.royalty), "engineFee", itoa(s.engine),
227 "engineAuthor", s.engineAuthor.String(), "deposit", itoa(l.deposit))
228}
229
230// settlement is how a sale of l is paid now (I-4: protocol + royalty +
231// engine + seller == price + deposit).
232type settlement struct {
233 treasury, royaltyTo, engineAuthor address
234 protocol, royalty, engine, seller int64
235}
236
237func settle(l *listing) settlement {
238 fee := core.FeeConfig()
239 feeBps := fee.SecondaryBps
240 if l.feeBps < feeBps {
241 feeBps = l.feeBps
242 }
243 author, engBps := core.EngineFee(l.cid)
244 if l.engBps < engBps {
245 engBps = l.engBps
246 }
247 s := settlement{treasury: fee.Treasury, engineAuthor: author}
248 s.protocol = safe.BpsOf(l.price, feeBps)
249 s.engine = safe.BpsOf(l.price, engBps)
250 royaltyTo, royalty, err := core.Royalty(l.cid).RoyaltyInfo(grc721.TokenID(l.tid), l.price)
251 if err != nil {
252 panic(err)
253 }
254 s.royaltyTo, s.royalty = royaltyTo, royalty
255 s.seller = l.price - s.protocol - s.royalty - s.engine + l.deposit
256 return s
257}
258
259// --- reads ---------------------------------------------------------------------
260
261// Listing is the token's listing as JSON, stale ones included with
262// "live":false, or "null".
263func Listing(cid, tid string) string {
264 l, ok := lookup(cid, tid)
265 if !ok {
266 return "null"
267 }
268 w := &safe.JSONWriter{}
269 writeListingLive(w, l, live(l, selfAddress()))
270 return w.String()
271}
272
273// ListingOf is the live listing of a token as JSON, or "null".
274func ListingOf(cid, tid string) string {
275 l, ok := lookup(cid, tid)
276 if !ok || !live(l, selfAddress()) {
277 return "null"
278 }
279 w := &safe.JSONWriter{}
280 writeListingLive(w, l, true)
281 return w.String()
282}
283
284// ActiveListing is the typed read for other realms: the live listing of a
285// token, if any (id is the sequence id).
286func ActiveListing(cid, tid string) (id string, price int64, ok bool) {
287 l, found := lookup(cid, tid)
288 if !found || !live(l, selfAddress()) {
289 return "", 0, false
290 }
291 return itoa(l.id), l.price, true
292}
293
294// Quote is what Buy(cid, tid, price) costs and pays now, as JSON: {live,
295// id, seller, price, deposit, total (attach this), protocolFee, royalty,
296// royaltyTo, engineFee, engineAuthor, sellerProceeds}; "null" if unlisted.
297func Quote(cid, tid string) string {
298 l, ok := lookup(cid, tid)
299 if !ok {
300 return "null"
301 }
302 s := settle(l)
303 w := &safe.JSONWriter{}
304 w.BeginObject()
305 w.BoolField("live", live(l, selfAddress()))
306 w.StrField("id", itoa(l.id))
307 w.StrField("seller", l.seller.String())
308 w.IntField("price", l.price)
309 w.IntField("deposit", l.deposit)
310 w.IntField("total", l.price+l.deposit)
311 w.IntField("protocolFee", s.protocol)
312 w.IntField("royalty", s.royalty)
313 w.StrField("royaltyTo", s.royaltyTo.String())
314 w.IntField("engineFee", s.engine)
315 w.StrField("engineAuthor", s.engineAuthor.String())
316 w.IntField("sellerProceeds", s.seller)
317 w.EndObject()
318 return w.String()
319}
320
321// ListingsByCollection lists by ascending price. Stale listings are
322// included with "live":false so pages stay stable; frontends hide them.
323// Listings by seller: use the indexer (Listed / Cancelled events).
324func ListingsByCollection(cid string, offset, limit int64) string {
325 if limit <= 0 || limit > MaxPageSize {
326 limit = MaxPageSize
327 }
328 prefix := cid + ":"
329 self := selfAddress()
330 w := &safe.JSONWriter{}
331 w.BeginArray()
332 var skipped, written int64
333 byCollection.Iterate(prefix, prefixEnd(prefix), func(k string, _ any) bool {
334 if skipped < offset {
335 skipped++
336 return false
337 }
338 l := mustListing(cid, tidOfKey(k))
339 writeListingLive(w, l, live(l, self))
340 written++
341 return written >= limit
342 })
343 w.EndArray()
344 return w.String()
345}
346
347// Floor is the lowest live price in cid, or -1. It inspects at most
348// MaxPageSize listings from the cheapest, so spam cannot make it unbounded.
349func Floor(cid string) int64 {
350 floor := int64(-1)
351 seen := 0
352 prefix := cid + ":"
353 self := selfAddress()
354 byCollection.Iterate(prefix, prefixEnd(prefix), func(k string, _ any) bool {
355 seen++
356 l := mustListing(cid, tidOfKey(k))
357 if live(l, self) {
358 floor = l.price
359 return true
360 }
361 return seen >= MaxPageSize
362 })
363 return floor
364}
365
366func Render(path string) string {
367 return "# market/v1\n\n" + itoa(int64(listings.Size()-1)) + " open listings. " +
368 "Read them with `ListingsByCollection` or browse the gallery.\n"
369}
370
371// --- internals -------------------------------------------------------------------
372
373// live: still owned by the seller, not moved since listing, and the
374// approval it was listed under is still in place and untouched since: a
375// per-token listing dies with any later Approve of that token, an
376// approval-for-all listing with any later SetApprovalForAll of the market
377// by the seller — even one that approves again (SA-L3).
378func live(l *listing, market address) bool {
379 owner, err := core.OwnerOf(l.cid, l.tid)
380 if err != nil || owner != l.seller || core.TokenMoves(l.cid, l.tid) != l.moves {
381 return false
382 }
383 viaToken, viaAll := approvals(l.cid, l.tid, owner, market)
384 tn, on := core.ApprovalNonces(l.cid, l.tid, owner, market)
385 return (l.viaToken && viaToken && tn == l.tokenNonce) || (l.viaAll && viaAll && on == l.operatorNonce)
386}
387
388// approvals reports whether market is approved for this token, and whether
389// it is approved for all of owner's tokens.
390func approvals(cid, tid string, owner, market address) (viaToken, viaAll bool) {
391 tok := core.Token(cid)
392 a, err := tok.GetApproved(grc721.TokenID(tid))
393 return err == nil && a == market, tok.IsApprovedForAll(owner, market)
394}
395
396// store writes l and its price-index key.
397func store(l *listing) {
398 listings.Set(tokenKey(l.cid, l.tid), encode(l))
399 byCollection.Set(collectionKey(l), "")
400}
401
402// remove deletes a listing and its index key; closed listings are not kept
403// (RA L-6), the "Cancelled" event (reason sold/cancelled/stale) is the record.
404func remove(l *listing, reason string) {
405 listings.Remove(tokenKey(l.cid, l.tid))
406 byCollection.Remove(collectionKey(l))
407 chain.Emit("Cancelled", "id", itoa(l.id), "cid", l.cid, "tid", l.tid, "reason", reason)
408}
409
410// encode packs a listing as one comma-separated string (M1: an inline avl
411// value instead of a *listing object, ~1.3 KB less per listing):
412// id,seller,price,moves,height,feeBps,engBps,flags,tokenNonce,operatorNonce
413// with flags = 1 (per-token) | 2 (for-all).
414func encode(l *listing) string {
415 flags := int64(0)
416 if l.viaToken {
417 flags |= 1
418 }
419 if l.viaAll {
420 flags |= 2
421 }
422 return itoa(l.id) + "," + l.seller.String() + "," + itoa(l.price) + "," + itoa(l.moves) + "," +
423 itoa(l.height) + "," + itoa(l.feeBps) + "," + itoa(l.engBps) + "," +
424 itoa(flags) + "," + itoa(l.tokenNonce) + "," + itoa(l.operatorNonce)
425}
426
427func decode(cid, tid, v string) *listing {
428 f := strings.Split(v, ",")
429 if len(f) != 10 {
430 panic("market: corrupt listing " + cid + ":" + tid)
431 }
432 n := func(i int) int64 {
433 x, err := strconv.ParseInt(f[i], 10, 64)
434 if err != nil {
435 panic("market: corrupt listing " + cid + ":" + tid)
436 }
437 return x
438 }
439 flags := n(7)
440 return &listing{
441 cid: cid, tid: tid, id: n(0), seller: address(f[1]), price: n(2), moves: n(3), height: n(4),
442 feeBps: n(5), engBps: n(6), deposit: ListingDeposit, viaToken: flags&1 != 0, viaAll: flags&2 != 0,
443 tokenNonce: n(8), operatorNonce: n(9),
444 }
445}
446
447
448func lookup(cid, tid string) (*listing, bool) {
449 v := listings.Get(tokenKey(cid, tid))
450 if v == nil {
451 return nil, false
452 }
453 return decode(cid, tid, v.(string)), true
454}
455
456func mustListing(cid, tid string) *listing {
457 l, ok := lookup(cid, tid)
458 if !ok {
459 panic("token " + cid + ":" + tid + " is not listed")
460 }
461 return l
462}
463
464func writeListingLive(w *safe.JSONWriter, l *listing, isLive bool) {
465 w.BeginObject()
466 w.StrField("id", itoa(l.id))
467 w.StrField("cid", l.cid)
468 w.StrField("tid", l.tid)
469 w.StrField("seller", l.seller.String())
470 w.IntField("price", l.price)
471 w.IntField("deposit", l.deposit)
472 w.IntField("moves", l.moves)
473 w.IntField("height", l.height)
474 w.IntField("engineFeeBps", l.engBps)
475 w.BoolField("live", isLive)
476 w.EndObject()
477}
478
479func assertSeller(cur realm, l *listing) {
480 if cur.Previous().Address() != l.seller {
481 panic("only the seller can do this")
482 }
483}
484
485func assertTradeOpen() {
486 if core.Paused("trade") {
487 panic("paused: trade")
488 }
489}
490
491func assertPrice(price int64) {
492 if price <= 0 || price > types.MaxUnitPrice {
493 panic("price must be 1.." + itoa(types.MaxUnitPrice) + " ugnot")
494 }
495}
496
497func received(cur realm) int64 {
498 if !cur.Previous().IsUserCall() {
499 panic("payments must come directly from a wallet, not through another realm")
500 }
501 sent := unsafe.OriginSend()
502 for _, c := range sent {
503 if c.Denom != "ugnot" && c.Amount != 0 {
504 panic("only ugnot is accepted")
505 }
506 }
507 return sent.AmountOf("ugnot")
508}
509
510func assertNoDeposit(cur realm) {
511 if cur.Previous().IsUserCall() && !unsafe.OriginSend().IsZero() {
512 panic("this function does not accept coins")
513 }
514}
515
516func pay(cur realm, to address, amount int64) {
517 if amount <= 0 {
518 return
519 }
520 if to == cur.Address() {
521 panic("refusing to pay the market itself: the coins would be stranded (SA-L5)")
522 }
523 banker.NewBanker(banker.BankerTypeRealmSend, cur).
524 SendCoins(cur.Address(), to, chain.NewCoins(chain.NewCoin("ugnot", amount)))
525}
526
527// tokenKey is the listing key. cid and tid are canonical ids (core
528// accepted the token), so the key has one spelling per token.
529func tokenKey(cid, tid string) string { return cid + ":" + tid }
530
531// collectionKey orders a collection's listings by price; the tid is the
532// part after the last ':'.
533func collectionKey(l *listing) string {
534 return l.cid + ":" + safe.PadInt(l.price, priceWidth) + ":" + l.tid
535}
536
537func tidOfKey(k string) string { return k[strings.LastIndex(k, ":")+1:] }
538
539// prefixEnd is the smallest key greater than every key with this prefix
540// (prefixes here end in ':', so bump it to ';').
541func prefixEnd(prefix string) string {
542 return prefix[:len(prefix)-1] + string(rune(prefix[len(prefix)-1]+1))
543}
544
545func itoa(n int64) string { return strconv.FormatInt(n, 10) }
546
547// selfAddress is this realm's address for read paths that have no cur.
548func selfAddress() address { return chain.PackageAddress(selfPath) }