Skip to content Search Apps Documentation Source Content Run Reset Eval Playground File Folder Download Copy Actions State String Boolean Number Struct Map Slice Pointer Function Closure Reference Nil Package Type Interface Unknown

Community realm. Read the code first. Community realm, deployed by its author. Read the code before you interact or send coins.

Playground

config.gno

package item

import (
	"chain"
	"strconv"
	"strings"

	"gno.land/p/akkadia/beta/accesscontrol"
	"gno.land/p/nt/bptree/v0"
	"gno.land/r/akkadia/beta/admin"
)

const (
	SetListLimitEvent     = "SetListLimit"
	SetMinterRealmEvent   = "SetMinterRealm"
	UnsetMinterRealmEvent = "UnsetMinterRealm"
)

var (
	listLimit    int = 100 // Max items per ListByOwner page
	minterRealms *bptree.BPTree
)

func SetListLimit(cur realm, limit int) {
	accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
	if limit < 1 {
		panic("limit must be at least 1")
	}

	oldLimit := listLimit
	listLimit = limit

	chain.Emit(
		SetListLimitEvent,
		"oldLimit", strconv.Itoa(oldLimit),
		"newLimit", strconv.Itoa(limit),
	)
}

func GetListLimit() int {
	return listLimit
}

func SetMinterRealm(cur realm, pkgPath string) {
	accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
	addr := minterRealmAddress(pkgPath)
	minterRealms.Set(addr.String(), true)
	chain.Emit(
		SetMinterRealmEvent,
		"pkgPath", pkgPath,
		"address", addr.String(),
	)
}

func UnsetMinterRealm(cur realm, pkgPath string) {
	accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
	addr := minterRealmAddress(pkgPath)
	if !minterRealms.Has(addr.String()) {
		panic("package path is not a minter realm")
	}
	minterRealms.Remove(addr.String())
	chain.Emit(
		UnsetMinterRealmEvent,
		"pkgPath", pkgPath,
		"address", addr.String(),
	)
}

func IsMinterRealm(addr address) bool {
	return minterRealms.Has(addr.String())
}

func minterRealmAddress(pkgPath string) address {
	if pkgPath == "" {
		panic("package path is required")
	}
	if !strings.HasPrefix(pkgPath, "gno.land/r/") || pkgPath == "gno.land/r/" {
		panic("invalid package path")
	}
	return chain.PackageAddress(pkgPath)
}

gnomod.toml

module = "gno.land/r/akkadia/beta/item"
gno = "0.9"

[addpkg]
  creator = "g1ftls0ctrrj0y96sr9dq906j7gdqhg9exgcvaey"
  height = 747754
  max_deposit = "100000000ugnot"

item.gno

package item

import (
	"chain/runtime/unsafe"
	"strconv"

	"gno.land/p/akkadia/beta/accesscontrol"
	"gno.land/p/akkadia/beta/grc1155"
	"gno.land/p/nt/bptree/v0"
	"gno.land/r/akkadia/beta/admin"
)

const (
	maxInt64 = int64(9223372036854775807)
)

var (
	itemToken     = grc1155.NewBasicGRC1155Token("")
	itemSupplies  *bptree.BPTree
	ownerTokenIDs *bptree.BPTree
)

func init() { resetItemState() }

func resetItemState() {
	itemToken = grc1155.NewBasicGRC1155Token("")
	itemSupplies = bptree.NewBPTree32()
	ownerTokenIDs = bptree.NewBPTree32()
	minterRealms = bptree.NewBPTree32()
	listLimit = 100
}

func SafeMint(cur realm, recipient address, tokenID string, amount int64) {
	executor := accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
	assertItemNoCoins()
	mintItem(cross(cur), executor, recipient, tokenID, amount)
}

func SafeMintFromRealm(cur realm, recipient address, tokenID string, amount int64) {
	executor := mustGetMinterRealmCaller(0, cur)
	if unsafe.OriginCaller() != recipient {
		panic("item recipient must be origin caller")
	}
	mintItem(cross(cur), executor, recipient, tokenID, amount)
}

func Uri() string { return itemToken.Uri() }
func IsApprovedForAll(owner, operator address) bool {
	return itemToken.IsApprovedForAll(owner, operator)
}

func SetApprovalForAll(cur realm, operator address, approved bool) {
	caller := accesscontrol.MustGetUserCaller(0, cur)
	assertItemNoCoins()
	if err := itemToken.SetApprovalForAll(caller, operator, approved); err != nil {
		panic("item operator approval failed: " + err.Error())
	}
}

func SafeTransferFrom(cur realm, from, to address, tokenID string, amount int64) {
	caller := accesscontrol.MustGetUserCaller(0, cur)
	assertItemNoCoins()
	assertItemTokenID(tokenID)
	assertItemAmount(amount, "transfer")
	if err := itemToken.SafeTransferFrom(caller, from, to, grc1155.TokenID(tokenID), amount); err != nil {
		panic("item transfer failed: " + err.Error())
	}
	if from != to {
		addOwnerTokenID(to, tokenID)
		if BalanceOf(from, tokenID) == 0 {
			removeOwnerTokenID(from, tokenID)
		}
	}
}

func BalanceOf(owner address, tokenID string) int64 {
	if !owner.IsValid() {
		panic("invalid item owner")
	}
	assertItemTokenID(tokenID)
	balance, err := itemToken.BalanceOf(owner, grc1155.TokenID(tokenID))
	if err != nil {
		panic("item balance query failed: " + err.Error())
	}
	return balance
}

func TotalSupply(tokenID string) int64 {
	assertItemTokenID(tokenID)
	value := itemSupplies.Get(tokenID)
	if value == nil {
		return 0
	}
	return value.(int64)
}

func GetOwnedCount(owner address) int {
	if !owner.IsValid() {
		panic("invalid item owner")
	}
	ids, found := getOwnerTokenIDs(owner)
	if !found {
		return 0
	}
	return ids.Size()
}

func ListByOwner(owner address, page, count int) []map[string]string {
	if !owner.IsValid() {
		panic("invalid item owner")
	}
	assertItemListPageCount(page, count)
	ids, found := getOwnerTokenIDs(owner)
	if !found {
		return []map[string]string{}
	}
	result := []map[string]string{}
	ids.IterateByOffset((page-1)*count, count, func(tokenID string, _ any) bool {
		result = append(result, map[string]string{
			"tokenId": tokenID,
			"amount":  strconv.FormatInt(BalanceOf(owner, tokenID), 10),
		})
		return false
	})
	return result
}

func Burn(cur realm, from address, tokenID string, amount int64) {
	caller := accesscontrol.MustGetUserCaller(0, cur)
	assertItemNoCoins()
	assertItemTokenID(tokenID)
	if caller != from && !itemToken.IsApprovedForAll(from, caller) {
		panic("item owner or approved operator required")
	}
	assertItemAmount(amount, "burn")
	burnItem(cross(cur), caller, from, tokenID, amount)
}

func BurnFromRealm(cur realm, from address, tokenID string, amount int64) {
	caller := mustGetMinterRealmCaller(0, cur)
	if unsafe.OriginCaller() != from {
		panic("item owner must be origin caller")
	}
	assertItemTokenID(tokenID)
	assertItemAmount(amount, "burn")
	burnItem(cross(cur), caller, from, tokenID, amount)
}

func mintItem(cur realm, executor, recipient address, tokenID string, amount int64) {
	assertItemTokenID(tokenID)
	if !recipient.IsValid() || recipient == cur.Address() {
		panic("invalid item recipient")
	}
	if amount <= 0 {
		panic("item amount must be positive")
	}
	supply := TotalSupply(tokenID)
	if supply > maxInt64-amount {
		panic("item amount overflow")
	}
	if err := itemToken.SafeMint(executor, recipient, grc1155.TokenID(tokenID), amount); err != nil {
		panic("item mint failed: " + err.Error())
	}
	itemSupplies.Set(tokenID, supply+amount)
	addOwnerTokenID(recipient, tokenID)
}

func burnItem(cur realm, operator, from address, tokenID string, amount int64) {
	supply := TotalSupply(tokenID)
	if supply < amount {
		panic("item burn amount exceeds supply")
	}
	if err := itemToken.Burn(operator, from, grc1155.TokenID(tokenID), amount); err != nil {
		panic("item burn failed: " + err.Error())
	}
	itemSupplies.Set(tokenID, supply-amount)
	if BalanceOf(from, tokenID) == 0 {
		removeOwnerTokenID(from, tokenID)
	}
}

func mustGetMinterRealmCaller(_ int, rlm realm) address {
	accesscontrol.AssertCurrentRealm(0, rlm)
	prev := rlm.Previous()
	if prev.IsUserCall() {
		panic("user calls not allowed: function must be called by a realm")
	}
	caller := prev.Address()
	if !IsMinterRealm(caller) {
		panic("minter realm required")
	}
	return caller
}

func assertItemNoCoins() {
	if len(unsafe.OriginSend()) != 0 {
		panic("attached coins not allowed")
	}
}

func assertItemTokenID(tokenID string) {
	if tokenID == "" {
		panic("token id is required")
	}
}

func assertItemAmount(amount int64, action string) {
	if amount <= 0 {
		panic("item " + action + " amount must be positive")
	}
}

func assertItemListPageCount(page, count int) {
	if page < 1 {
		panic("page must be at least 1")
	}
	if count < 1 {
		panic("count must be at least 1")
	}
	if count > listLimit {
		panic("count exceeds listLimit (max: " + strconv.Itoa(listLimit) + ")")
	}
}

func addOwnerTokenID(owner address, tokenID string) {
	value := ownerTokenIDs.Get(owner.String())
	var ids *bptree.BPTree
	if value != nil {
		ids = value.(*bptree.BPTree)
	} else {
		ids = bptree.NewBPTree32()
		ownerTokenIDs.Set(owner.String(), ids)
	}
	ids.Set(tokenID, true)
}

func removeOwnerTokenID(owner address, tokenID string) {
	ids, found := getOwnerTokenIDs(owner)
	if !found {
		return
	}
	ids.Remove(tokenID)
}

func getOwnerTokenIDs(owner address) (*bptree.BPTree, bool) {
	value := ownerTokenIDs.Get(owner.String())
	if value == nil {
		return nil, false
	}
	return value.(*bptree.BPTree), true
}

item_test.gno

package item

import (
	"chain"
	"testing"

	"gno.land/p/nt/testutils/v0"
	"gno.land/p/nt/uassert/v0"
	"gno.land/r/akkadia/beta/admin"
)

var itemTest = struct {
	Admin, Operator, Owner, Other address
	SetupDone                     bool
}{
	Admin:    testutils.TestAddress("itemAdmin"),
	Operator: testutils.TestAddress("itemOperator"),
	Owner:    testutils.TestAddress("itemOwner"),
	Other:    testutils.TestAddress("itemOther"),
}

func setupItemTest(cur realm, t *testing.T) {
	t.Helper()
	resetItemState()
	testing.SetOriginSend(chain.Coins{})
	if itemTest.SetupDone {
		return
	}
	originalAdmin := admin.GetAdmin()
	testing.SetOriginCaller(originalAdmin)
	testing.SetRealm(testing.NewUserRealm(originalAdmin))
	admin.TransferAdmin(cross(cur), itemTest.Admin)
	testing.SetOriginCaller(itemTest.Admin)
	testing.SetRealm(testing.NewUserRealm(itemTest.Admin))
	admin.AcceptAdmin(cross(cur))
	admin.SetOperator(cross(cur), itemTest.Operator)
	itemTest.SetupDone = true
}

func TestSafeMintTracksSupply(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)
	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	SafeMint(cross(cur), itemTest.Owner, "42", 5)
	uassert.Equal(t, int64(5), BalanceOf(itemTest.Owner, "42"))
	uassert.Equal(t, int64(5), TotalSupply("42"))
	SafeMint(cross(cur), itemTest.Owner, "42", 1)
	SafeMint(cross(cur), itemTest.Other, "42", 2)
	uassert.Equal(t, int64(6), BalanceOf(itemTest.Owner, "42"))
	uassert.Equal(t, int64(2), BalanceOf(itemTest.Other, "42"))
	uassert.Equal(t, int64(8), TotalSupply("42"))
}

func TestItemTokenIDAcceptsOpaqueStrings(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)
	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	SafeMint(cross(cur), itemTest.Owner, "0", 1)
	SafeMint(cross(cur), itemTest.Owner, "4294967295", 2)
	SafeMint(cross(cur), itemTest.Owner, "sword", 3)
	uassert.Equal(t, int64(1), BalanceOf(itemTest.Owner, "0"))
	uassert.Equal(t, int64(2), TotalSupply("4294967295"))
	uassert.Equal(t, int64(3), TotalSupply("sword"))
	uassert.AbortsWithMessage(t, cur, "token id is required", func() {
		SafeMint(cross(cur), itemTest.Owner, "", 1)
	})
}

func TestItemTransferAndBurnUpdateSupply(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)
	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	SafeMint(cross(cur), itemTest.Owner, "42", 5)
	testing.SetOriginCaller(itemTest.Owner)
	testing.SetRealm(testing.NewUserRealm(itemTest.Owner))
	SafeTransferFrom(cross(cur), itemTest.Owner, itemTest.Other, "42", 2)
	Burn(cross(cur), itemTest.Owner, "42", 1)
	uassert.Equal(t, int64(2), BalanceOf(itemTest.Owner, "42"))
	uassert.Equal(t, int64(2), BalanceOf(itemTest.Other, "42"))
	uassert.Equal(t, int64(4), TotalSupply("42"))
}

func TestItemApprovalAllowsTransferAndBurn(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)
	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	SafeMint(cross(cur), itemTest.Owner, "42", 5)
	testing.SetOriginCaller(itemTest.Owner)
	testing.SetRealm(testing.NewUserRealm(itemTest.Owner))
	SetApprovalForAll(cross(cur), itemTest.Other, true)
	testing.SetOriginCaller(itemTest.Other)
	testing.SetRealm(testing.NewUserRealm(itemTest.Other))
	SafeTransferFrom(cross(cur), itemTest.Owner, itemTest.Admin, "42", 2)
	Burn(cross(cur), itemTest.Owner, "42", 1)
	uassert.Equal(t, int64(2), BalanceOf(itemTest.Owner, "42"))
	uassert.Equal(t, int64(2), BalanceOf(itemTest.Admin, "42"))
	uassert.Equal(t, int64(4), TotalSupply("42"))
}

func TestSafeMintSecurity(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)
	testing.SetOriginCaller(itemTest.Owner)
	testing.SetRealm(testing.NewUserRealm(itemTest.Owner))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
		SafeMint(cross(cur), itemTest.Owner, "1", 1)
	})
	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/item_relay"))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
		SafeMint(cross(cur), itemTest.Owner, "1", 1)
	})
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
	uassert.AbortsWithMessage(t, cur, "attached coins not allowed", func() {
		SafeMint(cross(cur), itemTest.Owner, "1", 1)
	})
}

func TestItemOwnedList(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)
	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	uassert.Equal(t, 0, GetOwnedCount(itemTest.Owner))
	uassert.Equal(t, 0, len(ListByOwner(itemTest.Owner, 1, 10)))
	uassert.PanicsWithMessage(t, cur, "invalid item owner", func() {
		GetOwnedCount(address(""))
	})
	uassert.PanicsWithMessage(t, cur, "page must be at least 1", func() {
		ListByOwner(itemTest.Owner, 0, 1)
	})
	uassert.PanicsWithMessage(t, cur, "count must be at least 1", func() {
		ListByOwner(itemTest.Owner, 1, 0)
	})
	uassert.PanicsWithMessage(t, cur, "count exceeds listLimit (max: 100)", func() {
		ListByOwner(itemTest.Owner, 1, 101)
	})
	uassert.Equal(t, 100, GetListLimit())

	SafeMint(cross(cur), itemTest.Owner, "10", 5)
	SafeMint(cross(cur), itemTest.Owner, "20", 3)
	SafeMint(cross(cur), itemTest.Owner, "30", 1)
	uassert.Equal(t, 3, GetOwnedCount(itemTest.Owner))
	page1 := ListByOwner(itemTest.Owner, 1, 2)
	uassert.Equal(t, 2, len(page1))
	uassert.Equal(t, "10", page1[0]["tokenId"])
	uassert.Equal(t, "5", page1[0]["amount"])
	uassert.Equal(t, "20", page1[1]["tokenId"])
	page2 := ListByOwner(itemTest.Owner, 2, 2)
	uassert.Equal(t, 1, len(page2))
	uassert.Equal(t, "30", page2[0]["tokenId"])
	uassert.Equal(t, 0, len(ListByOwner(itemTest.Owner, 3, 2)))
	page1[0]["amount"] = "hacked"
	uassert.Equal(t, "5", ListByOwner(itemTest.Owner, 1, 1)[0]["amount"])

	testing.SetOriginCaller(itemTest.Owner)
	testing.SetRealm(testing.NewUserRealm(itemTest.Owner))
	SafeTransferFrom(cross(cur), itemTest.Owner, itemTest.Other, "10", 2)
	uassert.Equal(t, 3, GetOwnedCount(itemTest.Owner))
	uassert.Equal(t, 1, GetOwnedCount(itemTest.Other))
	uassert.Equal(t, "3", ListByOwner(itemTest.Owner, 1, 10)[0]["amount"])
	uassert.Equal(t, "2", ListByOwner(itemTest.Other, 1, 10)[0]["amount"])
	SafeTransferFrom(cross(cur), itemTest.Owner, itemTest.Other, "10", 3)
	uassert.Equal(t, 2, GetOwnedCount(itemTest.Owner))
	uassert.Equal(t, 1, GetOwnedCount(itemTest.Other))
	Burn(cross(cur), itemTest.Owner, "20", 3)
	uassert.Equal(t, 1, GetOwnedCount(itemTest.Owner))
	uassert.Equal(t, "30", ListByOwner(itemTest.Owner, 1, 10)[0]["tokenId"])

	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	SafeMint(cross(cur), itemTest.Owner, "30", 2)
	uassert.Equal(t, 1, GetOwnedCount(itemTest.Owner))
	uassert.Equal(t, "3", ListByOwner(itemTest.Owner, 1, 10)[0]["amount"])
}

func TestSetListLimit(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)

	testing.SetOriginCaller(itemTest.Admin)
	testing.SetRealm(testing.NewUserRealm(itemTest.Admin))
	SetListLimit(cross(cur), 50)
	uassert.Equal(t, 50, GetListLimit())

	SetListLimit(cross(cur), 1)
	uassert.PanicsWithMessage(t, cur, "count exceeds listLimit (max: 1)", func() {
		ListByOwner(itemTest.Owner, 1, 2)
	})

	uassert.AbortsWithMessage(t, cur, "limit must be at least 1", func() {
		SetListLimit(cross(cur), 0)
	})
	uassert.AbortsWithMessage(t, cur, "limit must be at least 1", func() {
		SetListLimit(cross(cur), -1)
	})

	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		SetListLimit(cross(cur), 50)
	})

	testing.SetOriginCaller(itemTest.Owner)
	testing.SetRealm(testing.NewUserRealm(itemTest.Owner))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		SetListLimit(cross(cur), 50)
	})

	testing.SetOriginCaller(itemTest.Admin)
	testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/item_admin_relay"))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		SetListLimit(cross(cur), 50)
	})
}

func TestSetMinterRealm(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)
	minterPath := "gno.land/r/example/item_minter"
	minter := testing.NewCodeRealm(minterPath)
	minterAddr := minter.Address()

	uassert.Equal(t, minterAddr.String(), chain.PackageAddress(minterPath).String())
	uassert.Equal(t, false, IsMinterRealm(minterAddr))

	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		SetMinterRealm(cross(cur), minterPath)
	})

	testing.SetOriginCaller(itemTest.Admin)
	testing.SetRealm(testing.NewUserRealm(itemTest.Admin))
	uassert.AbortsWithMessage(t, cur, "package path is required", func() {
		SetMinterRealm(cross(cur), "")
	})
	uassert.AbortsWithMessage(t, cur, "invalid package path", func() {
		SetMinterRealm(cross(cur), "gno.land/p/akkadia/beta/item")
	})
	SetMinterRealm(cross(cur), minterPath)
	uassert.Equal(t, true, IsMinterRealm(minterAddr))
	SetMinterRealm(cross(cur), minterPath)
	uassert.Equal(t, true, IsMinterRealm(minterAddr))

	UnsetMinterRealm(cross(cur), minterPath)
	uassert.Equal(t, false, IsMinterRealm(minterAddr))
	uassert.AbortsWithMessage(t, cur, "package path is not a minter realm", func() {
		UnsetMinterRealm(cross(cur), minterPath)
	})
	uassert.AbortsWithMessage(t, cur, "package path is required", func() {
		UnsetMinterRealm(cross(cur), "")
	})

	testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/item_admin_relay"))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		SetMinterRealm(cross(cur), minterPath)
	})
}

func TestSafeMintFromRealm(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)
	minter := testing.NewCodeRealm("gno.land/r/example/item_minter")
	unregistered := testing.NewCodeRealm("gno.land/r/example/item_minter_other")

	testing.SetOriginCaller(itemTest.Owner)
	testing.SetRealm(testing.NewUserRealm(itemTest.Owner))
	uassert.AbortsWithMessage(t, cur, "user calls not allowed: function must be called by a realm", func() {
		SafeMintFromRealm(cross(cur), itemTest.Owner, "1", 1)
	})

	testing.SetRealm(unregistered)
	uassert.AbortsWithMessage(t, cur, "minter realm required", func() {
		SafeMintFromRealm(cross(cur), itemTest.Owner, "1", 1)
	})

	testing.SetOriginCaller(itemTest.Admin)
	testing.SetRealm(testing.NewUserRealm(itemTest.Admin))
	SetMinterRealm(cross(cur), "gno.land/r/example/item_minter")

	testing.SetOriginCaller(itemTest.Owner)
	testing.SetRealm(minter)
	SafeMintFromRealm(cross(cur), itemTest.Owner, "7", 3)
	uassert.Equal(t, int64(3), BalanceOf(itemTest.Owner, "7"))
	uassert.Equal(t, int64(3), TotalSupply("7"))
	uassert.Equal(t, 1, GetOwnedCount(itemTest.Owner))

	uassert.AbortsWithMessage(t, cur, "item recipient must be origin caller", func() {
		SafeMintFromRealm(cross(cur), itemTest.Other, "8", 1)
	})
	uassert.Equal(t, int64(0), TotalSupply("8"))

	testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
	SafeMintFromRealm(cross(cur), itemTest.Owner, "9", 1)
	testing.SetOriginSend(chain.Coins{})
	uassert.Equal(t, int64(1), BalanceOf(itemTest.Owner, "9"))
}

func TestBurnFromRealm(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)
	minter := testing.NewCodeRealm("gno.land/r/example/item_minter")

	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	SafeMint(cross(cur), itemTest.Owner, "42", 5)

	testing.SetOriginCaller(itemTest.Admin)
	testing.SetRealm(testing.NewUserRealm(itemTest.Admin))
	SetMinterRealm(cross(cur), "gno.land/r/example/item_minter")

	testing.SetOriginCaller(itemTest.Owner)
	testing.SetRealm(testing.NewUserRealm(itemTest.Owner))
	uassert.AbortsWithMessage(t, cur, "user calls not allowed: function must be called by a realm", func() {
		BurnFromRealm(cross(cur), itemTest.Owner, "42", 1)
	})

	testing.SetRealm(minter)
	uassert.AbortsWithMessage(t, cur, "item owner must be origin caller", func() {
		BurnFromRealm(cross(cur), itemTest.Other, "42", 1)
	})
	uassert.Equal(t, int64(5), BalanceOf(itemTest.Owner, "42"))

	BurnFromRealm(cross(cur), itemTest.Owner, "42", 2)
	uassert.Equal(t, int64(3), BalanceOf(itemTest.Owner, "42"))
	uassert.Equal(t, int64(3), TotalSupply("42"))

	uassert.AbortsWithMessage(t, cur, "item amount must be positive", func() {
		SafeMintFromRealm(cross(cur), itemTest.Owner, "99", 0)
	})
	uassert.Equal(t, int64(3), BalanceOf(itemTest.Owner, "42"))
	uassert.Equal(t, int64(3), TotalSupply("42"))
	uassert.Equal(t, int64(0), TotalSupply("99"))
	uassert.Equal(t, 1, GetOwnedCount(itemTest.Owner))

	testing.SetOriginCaller(itemTest.Admin)
	testing.SetRealm(testing.NewUserRealm(itemTest.Admin))
	UnsetMinterRealm(cross(cur), "gno.land/r/example/item_minter")
	testing.SetOriginCaller(itemTest.Owner)
	testing.SetRealm(minter)
	uassert.AbortsWithMessage(t, cur, "minter realm required", func() {
		BurnFromRealm(cross(cur), itemTest.Owner, "42", 1)
	})
	uassert.Equal(t, int64(3), BalanceOf(itemTest.Owner, "42"))
}

render.gno

package item

import (
	"net/url"
	"strconv"
	"strings"

	"gno.land/p/jeronimoalbi/pager/v0"
)

func Render(iURL string) string {
	assertRenderURLLen(iURL)
	u, err := url.Parse(iURL)
	if err != nil {
		return renderItemError("Invalid URL")
	}

	switch u.Path {
	case "":
		return renderItemHome()
	case "owner":
		return renderItemOwner(iURL, address(u.Query().Get("address")))
	default:
		return renderItemError("Not found")
	}
}

func renderItemHome() string {
	return `# AKKADIA Item

Look up fungible items held by an address.

<gno-form path="owner">
  <gno-input name="address" placeholder="Enter the address" />
</gno-form>
`
}

func renderItemOwner(iURL string, owner address) string {
	if !owner.IsValid() {
		return renderItemError("Invalid address")
	}

	output := `# Item Holdings

[← Home](./item:)

* **Address**: ` + owner.String() + `
`

	total := GetOwnedCount(owner)
	output += "* **Total**: " + strconv.Itoa(total) + "\n\n"
	if total == 0 {
		return output + `*No items held.*
`
	}

	pageSize := 20
	if pageSize > listLimit {
		pageSize = listLimit
	}
	pages, err := pager.New(iURL, total, pager.WithPageSize(pageSize))
	if err != nil {
		return renderItemError("Invalid page")
	}

	rows := ListByOwner(owner, pages.Page(), pages.PageSize())
	for _, row := range rows {
		output += "* **" + escapeItemMarkdown(row["tokenId"]) + "**: " + escapeItemMarkdown(row["amount"]) + "\n"
	}
	if pages.HasPages() {
		output += "\n" + pager.Picker(pages)
	}
	return output
}

func renderItemError(message string) string {
	return `# Error

> ` + escapeItemMarkdown(message) + `

[← Home](./item:)
`
}

func escapeItemMarkdown(value string) string {
	value = strings.ReplaceAll(value, "\\", "\\\\")
	value = strings.ReplaceAll(value, "\n", "\\n")
	value = strings.ReplaceAll(value, "`", "\\`")
	value = strings.ReplaceAll(value, "*", "\\*")
	value = strings.ReplaceAll(value, "_", "\\_")
	value = strings.ReplaceAll(value, "{", "\\{")
	value = strings.ReplaceAll(value, "}", "\\}")
	value = strings.ReplaceAll(value, "[", "\\[")
	value = strings.ReplaceAll(value, "]", "\\]")
	value = strings.ReplaceAll(value, "(", "\\(")
	value = strings.ReplaceAll(value, ")", "\\)")
	value = strings.ReplaceAll(value, "#", "\\#")
	value = strings.ReplaceAll(value, "+", "\\+")
	value = strings.ReplaceAll(value, "-", "\\-")
	value = strings.ReplaceAll(value, ".", "\\.")
	value = strings.ReplaceAll(value, "!", "\\!")
	value = strings.ReplaceAll(value, "|", "\\|")
	value = strings.ReplaceAll(value, ">", "\\>")
	return value
}

render_test.gno

package item

import (
	"strings"
	"testing"

	"gno.land/p/nt/uassert/v0"
)

func TestRenderHomeAndOwner(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)

	home := Render("")
	uassert.True(t, strings.Contains(home, `<gno-form path="owner">`), "should render the owner lookup form")
	uassert.True(t, strings.Contains(home, `name="address"`), "should render the address input")

	empty := Render("owner?address=" + itemTest.Owner.String())
	uassert.True(t, strings.Contains(empty, itemTest.Owner.String()), "should render the owner address")
	uassert.True(t, strings.Contains(empty, "Total**: 0"), "should render an empty total")
	uassert.True(t, strings.Contains(empty, "No items held"), "should render an empty holding list")

	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	SafeMint(cross(cur), itemTest.Owner, "test-iron", 3)
	SafeMint(cross(cur), itemTest.Owner, "**x**", 2)

	listed := Render("owner?address=" + itemTest.Owner.String())
	uassert.True(t, strings.Contains(listed, "Total**: 2"), "should render the owned token count")
	uassert.True(t, strings.Contains(listed, "test\\-iron"), "should escape item token ids")
	uassert.True(t, strings.Contains(listed, "**: 3"), "should render item amounts")
	uassert.True(t, strings.Contains(listed, `\*\*x\*\*`), "escaped markdown token id should be visible")
	uassert.False(t, strings.Contains(listed, "**x**"), "raw markdown token id should not remain")
}

func TestRenderOwnerPagesWhenCountExceedsLimit(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)
	testing.SetOriginCaller(itemTest.Admin)
	testing.SetRealm(testing.NewUserRealm(itemTest.Admin))
	SetListLimit(cross(cur), 1)

	testing.SetOriginCaller(itemTest.Operator)
	testing.SetRealm(testing.NewUserRealm(itemTest.Operator))
	SafeMint(cross(cur), itemTest.Owner, "10", 1)
	SafeMint(cross(cur), itemTest.Owner, "20", 1)

	page1 := Render("owner?address=" + itemTest.Owner.String())
	uassert.True(t, strings.Contains(page1, "Total**: 2"), "should render total holdings")
	uassert.True(t, strings.Contains(page1, "**10**"), "page 1 should include the first token")
	uassert.False(t, strings.Contains(page1, "**20**"), "page 1 should not include the second token")
	uassert.True(t, strings.Contains(page1, "page 1 of 2"), "should render a page picker")
	uassert.True(t, strings.Contains(page1, "page=2"), "should link to the next page")

	page2 := Render("owner?address=" + itemTest.Owner.String() + "&page=2")
	uassert.True(t, strings.Contains(page2, "**20**"), "page 2 should include the second token")
	uassert.False(t, strings.Contains(page2, "**10**"), "page 2 should not include the first token")
	uassert.True(t, strings.Contains(page2, "page 2 of 2"), "should render the last page picker")

	invalidPage := Render("owner?address=" + itemTest.Owner.String() + "&page=3")
	uassert.True(t, strings.Contains(invalidPage, "Invalid page"), "should reject a page past the last page")
}

func TestRenderErrors(cur realm, t *testing.T) {
	setupItemTest(cross(cur), t)

	invalid := Render("owner?address=invalid-address")
	uassert.True(t, strings.Contains(invalid, "Invalid address"), "should reject an invalid address")

	unknown := Render("unknown")
	uassert.True(t, strings.Contains(unknown, "Not found"), "should reject an unknown route")
}

func TestRenderRejectsOversizedURL(cur realm, t *testing.T) {
	uassert.PanicsWithMessage(t, cur, "url exceeds max runes", func() {
		Render(strings.Repeat("a", renderURLMaxRunes+1))
	})
	Render(strings.Repeat("a", renderURLMaxRunes))
}

validation.gno

package item

import "unicode/utf8"

const renderURLMaxRunes = 1024

func assertRenderURLLen(value string) {
	if utf8.RuneCountInString(value) > renderURLMaxRunes {
		panic("url exceeds max runes")
	}
}