buy.gno

  1package skins
  2
  3import (
  4	"chain"
  5	"chain/banker"
  6
  7	// Only for OriginSend, in Buy. Caller identity always comes from
  8	// cur.Previous(), never from this package.
  9	"chain/runtime/unsafe"
 10
 11	"gno.land/p/nt/grc721/v0"
 12)
 13
 14// Buy buys one token of a skin design for the caller and returns its id. The
 15// exact price must be attached to the transaction (-send "<price>ugnot") and
 16// is forwarded to the treasury of the game realm before the call returns.
 17//
 18// An address owns at most one token of a design: a skin cannot be given
 19// away, so a second copy would be of no use. It must be called directly by a
 20// user (maketx call): a call relayed by another realm or by a maketx run
 21// script is refused.
 22func Buy(cur realm, skinID string) int64 {
 23	buyer := callerOf(0, cur)
 24
 25	// Paid-call guard: two checks that are only correct together.
 26	//
 27	// (a) The caller is a plain user account. Only then is the -send
 28	//     envelope guaranteed to have landed at this realm's address.
 29	if !cur.Previous().IsUserCall() {
 30		panic(errNotUserCall)
 31	}
 32	d := getDesign(skinID)
 33	if d == nil {
 34		panic(errUnknownSkin)
 35	}
 36	if !d.listed {
 37		panic(errSkinUnlisted)
 38	}
 39	if d.maxSupply > 0 && d.minted >= d.maxSupply {
 40		panic(errSoldOut)
 41	}
 42	key := ownedKey(buyer, skinID)
 43	if owned.Has(key) {
 44		panic(errAlreadyOwned)
 45	}
 46
 47	// (b) The envelope is exactly the price: one coin, the right denom, the
 48	//     right amount.
 49	sent := unsafe.OriginSend()
 50	if len(sent) != 1 || sent[0].Denom != payDenom || sent[0].Amount != d.price {
 51		panic("gnofly: wrong payment, send exactly " + itoa(d.price) + payDenom)
 52	}
 53	treasury := roles.Treasury()
 54	payment := chain.NewCoins(chain.NewCoin(payDenom, d.price))
 55	banker.NewBanker(banker.BankerTypeOriginSend, cur).SendCoins(cur.Address(), treasury, payment)
 56
 57	id := nextID
 58	nextID++
 59	tid := grc721.TokenID(itoa(id))
 60	if err := ledger.Mint(buyer, tid); err != nil {
 61		panic(err)
 62	}
 63	tokenSkin.Set(string(tid), skinID)
 64	owned.Set(key, id)
 65	d.minted++
 66
 67	chain.Emit("SkinBought",
 68		"id", itoa(id),
 69		"skin", skinID,
 70		"buyer", buyer.String(),
 71		"price", itoa(d.price),
 72		"treasury", treasury.String(),
 73	)
 74	return id
 75}
 76
 77// Burn destroys a skin token. Only its owner can. The storage deposit paid at
 78// purchase comes back; the price does not. The owner can buy the design
 79// again, while it is listed.
 80func Burn(cur realm, id int64) {
 81	caller := callerOf(0, cur)
 82	skinID := skinOf(id)
 83	if skinID == "" {
 84		panic(errNotMinted)
 85	}
 86	if ownerOf(id) != caller {
 87		panic(errNotSkinOwner)
 88	}
 89	tid := grc721.TokenID(itoa(id))
 90	if err := ledger.Burn(tid); err != nil {
 91		panic(err)
 92	}
 93	tokenSkin.Remove(string(tid))
 94	owned.Remove(ownedKey(caller, skinID))
 95	chain.Emit("SkinBurned", "id", itoa(id), "skin", skinID, "owner", caller.String())
 96}
 97
 98// ownedKey is the key of owned: the address, then the design.
 99func ownedKey(addr address, skinID string) string {
100	return addr.String() + "/" + skinID
101}
102
103// skinOf returns the design of token id, "" when there is no such token.
104func skinOf(id int64) string {
105	v := tokenSkin.Get(itoa(id))
106	if v == nil {
107		return ""
108	}
109	return v.(string)
110}
111
112// ownerOf returns who owns token id, "" for none.
113func ownerOf(id int64) address {
114	owner, err := token.OwnerOf(grc721.TokenID(itoa(id)))
115	if err != nil {
116		return ""
117	}
118	return owner
119}