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 equipment

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)
}

equipment.gno

package equipment

import (
	"chain/runtime/unsafe"
	"net/url"
	"strconv"
	"time"

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

const (
	definitionIDKey            = "definitionId"
	tokenIDKey                 = "tokenId"
	createdAtKey               = "created_at"
	maxEquipmentTokenID uint64 = 18446744073709551615
)

var (
	equipmentToken    = grc721.NewBasicNFT("Akkadia Equipment", "AEQP")
	equipmentMetadata *bptree.BPTree
	ownerTokenIDs     *bptree.BPTree
	latestTokenID     uint64
)

func init() { resetEquipmentState() }

func resetEquipmentState() {
	equipmentToken = grc721.NewBasicNFT("Akkadia Equipment", "AEQP")
	equipmentMetadata = bptree.NewBPTree32()
	ownerTokenIDs = bptree.NewBPTree32()
	minterRealms = bptree.NewBPTree32()
	listLimit = 100
	latestTokenID = 0
}

func Mint(cur realm, recipient address, definitionID uint32, attrKeys, attrValues string) uint64 {
	accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
	assertEquipmentNoCoins()
	return mintEquipment(cross(cur), recipient, definitionID, attrKeys, attrValues)
}

func MintFromRealm(cur realm, recipient address, definitionID uint32, attrKeys, attrValues string) uint64 {
	mustGetMinterRealmCaller(0, cur)
	if unsafe.OriginCaller() != recipient {
		panic("equipment recipient must be origin caller")
	}
	return mintEquipment(cross(cur), recipient, definitionID, attrKeys, attrValues)
}

func GetMetadata(tokenID uint64) map[string]string {
	return copyStringMap(mustGetEquipmentMetadata(tokenID))
}

func SetMetadata(cur realm, tokenID uint64, attrKeys, attrValues string) {
	accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
	assertEquipmentNoCoins()
	setEquipmentMetadata(tokenID, attrKeys, attrValues)
}

func SetMetadataFromRealm(cur realm, tokenID uint64, attrKeys, attrValues string) {
	mustGetMinterRealmCaller(0, cur)
	if unsafe.OriginCaller() != OwnerOf(tokenID) {
		panic("equipment owner must be origin caller")
	}
	setEquipmentMetadata(tokenID, attrKeys, attrValues)
}

func GetOwnedCount(owner address) int {
	if !owner.IsValid() {
		panic("invalid equipment 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 equipment owner")
	}
	assertEquipmentListPageCount(page, count)
	ids, found := getOwnerTokenIDs(owner)
	if !found {
		return []map[string]string{}
	}
	result := []map[string]string{}
	ids.IterateByOffset((page-1)*count, count, func(key string, _ any) bool {
		tokenID := parseUint64Key(key)
		row := GetMetadata(tokenID)
		row[tokenIDKey] = strconv.FormatUint(tokenID, 10)
		result = append(result, row)
		return false
	})
	return result
}

func Name() string   { return equipmentToken.Name() }
func Symbol() string { return equipmentToken.Symbol() }

func OwnerOf(tokenID uint64) address {
	owner, err := equipmentToken.OwnerOf(equipmentTokenID(tokenID))
	if err != nil {
		panic("equipment owner query failed: " + err.Error())
	}
	return owner
}

func Has(tokenID uint64) bool {
	_, err := equipmentToken.OwnerOf(equipmentTokenID(tokenID))
	return err == nil
}

func GetLatestTokenID() uint64 {
	return latestTokenID
}

func BalanceOf(owner address) int64 {
	if !owner.IsValid() {
		panic("invalid equipment owner")
	}
	balance, err := equipmentToken.BalanceOf(owner)
	if err != nil {
		panic("equipment balance query failed: " + err.Error())
	}
	return balance
}

func GetApproved(tokenID uint64) address {
	approved, err := equipmentToken.GetApproved(equipmentTokenID(tokenID))
	if err != nil {
		panic("equipment approval query failed: " + err.Error())
	}
	return approved
}

func IsApprovedForAll(owner, operator address) bool {
	return equipmentToken.IsApprovedForAll(owner, operator)
}

func Approve(cur realm, operator address, tokenID uint64) {
	caller := accesscontrol.MustGetUserCaller(0, cur)
	assertEquipmentNoCoins()
	if err := equipmentToken.Approve(caller, operator, equipmentTokenID(tokenID)); err != nil {
		panic("equipment approval failed: " + err.Error())
	}
}

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

func TransferFrom(cur realm, from, to address, tokenID uint64) {
	caller := accesscontrol.MustGetUserCaller(0, cur)
	assertEquipmentNoCoins()
	if err := equipmentToken.TransferFrom(caller, from, to, equipmentTokenID(tokenID)); err != nil {
		panic("equipment transfer failed: " + err.Error())
	}
	if from != to {
		removeOwnerTokenID(from, tokenID)
		addOwnerTokenID(to, tokenID)
	}
}

func Burn(cur realm, tokenID uint64) {
	caller := accesscontrol.MustGetUserCaller(0, cur)
	assertEquipmentNoCoins()
	owner := OwnerOf(tokenID)
	approved, err := equipmentToken.GetApproved(equipmentTokenID(tokenID))
	if caller != owner && !equipmentToken.IsApprovedForAll(owner, caller) && (err != nil || approved != caller) {
		panic("equipment owner or approved operator required")
	}
	burnEquipment(tokenID, owner)
}

func BurnFromRealm(cur realm, tokenID uint64) {
	mustGetMinterRealmCaller(0, cur)
	owner := OwnerOf(tokenID)
	if unsafe.OriginCaller() != owner {
		panic("equipment owner must be origin caller")
	}
	burnEquipment(tokenID, owner)
}

func mintEquipment(cur realm, recipient address, definitionID uint32, attrKeys, attrValues string) uint64 {
	if !recipient.IsValid() || recipient == cur.Address() {
		panic("invalid equipment recipient")
	}
	attrs := parseEquipmentAttributes(attrKeys, attrValues)
	tokenID := allocateTokenID()
	if err := equipmentToken.Mint(recipient, equipmentTokenID(tokenID)); err != nil {
		panic("equipment mint failed: " + err.Error())
	}
	attrs[definitionIDKey] = strconv.FormatUint(uint64(definitionID), 10)
	attrs[createdAtKey] = strconv.FormatInt(time.Now().Unix(), 10)
	equipmentMetadata.Set(uint64Key(tokenID), attrs)
	addOwnerTokenID(recipient, tokenID)
	return tokenID
}

func allocateTokenID() uint64 {
	if latestTokenID == maxEquipmentTokenID {
		panic("equipment token id exhausted")
	}
	latestTokenID++
	return latestTokenID
}

func mustGetEquipmentMetadata(tokenID uint64) map[string]string {
	value := equipmentMetadata.Get(uint64Key(tokenID))
	if value == nil {
		panic("equipment metadata not found: " + strconv.FormatUint(tokenID, 10))
	}
	return value.(map[string]string)
}

func setEquipmentMetadata(tokenID uint64, attrKeys, attrValues string) {
	current := mustGetEquipmentMetadata(tokenID)
	attrs := parseEquipmentAttributes(attrKeys, attrValues)
	attrs[definitionIDKey] = current[definitionIDKey]
	attrs[createdAtKey] = current[createdAtKey]
	equipmentMetadata.Set(uint64Key(tokenID), attrs)
}

func parseEquipmentAttributes(attrKeys, attrValues string) map[string]string {
	attrs := parseAttributesCSV(attrKeys, attrValues)
	if _, found := attrs[definitionIDKey]; found {
		panic("reserved key: " + definitionIDKey)
	}
	if _, found := attrs[tokenIDKey]; found {
		panic("reserved key: " + tokenIDKey)
	}
	if _, found := attrs[createdAtKey]; found {
		panic("reserved key: " + createdAtKey)
	}
	return attrs
}

func burnEquipment(tokenID uint64, owner address) {
	if err := equipmentToken.Burn(equipmentTokenID(tokenID)); err != nil {
		panic("equipment burn failed: " + err.Error())
	}
	if _, removed := equipmentMetadata.Remove(uint64Key(tokenID)); !removed {
		panic("equipment metadata not found: " + strconv.FormatUint(tokenID, 10))
	}
	removeOwnerTokenID(owner, 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 assertEquipmentNoCoins() {
	if len(unsafe.OriginSend()) != 0 {
		panic("attached coins not allowed")
	}
}

func assertEquipmentListPageCount(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 uint64) {
	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(uint64Key(tokenID), true)
}

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

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

func equipmentTokenID(tokenID uint64) grc721.TokenID {
	return grc721.TokenID(strconv.FormatUint(tokenID, 10))
}

func uint64Key(id uint64) string {
	s := strconv.FormatUint(id, 10)
	if len(s) >= 20 {
		return s
	}
	return "00000000000000000000"[len(s):] + s
}

func parseUint64Key(key string) uint64 {
	id, err := strconv.ParseUint(key, 10, 64)
	if err != nil {
		panic("invalid uint64 key: " + key)
	}
	return id
}

func copyStringMap(source map[string]string) map[string]string {
	result := map[string]string{}
	for key, value := range source {
		result[key] = value
	}
	return result
}

// parseAttributesCSV accepts comma-separated keys and URL-encoded values.
// Empty keys and values produce an empty attribute map so mint can store
// definitionId and created_at alone.
func parseAttributesCSV(keys, values string) map[string]string {
	if keys == "" && values == "" {
		return map[string]string{}
	}

	result := map[string]string{}
	keyStart, valStart := 0, 0
	keyIdx, valIdx := 0, 0
	for {
		for keyIdx < len(keys) && keys[keyIdx] != ',' {
			keyIdx++
		}
		for valIdx < len(values) && values[valIdx] != ',' {
			valIdx++
		}

		key := keys[keyStart:keyIdx]
		if key == "" {
			panic("attributes key must be not empty")
		}
		if _, found := result[key]; found {
			panic("attributes key duplicated: " + key)
		}

		value, err := url.PathUnescape(values[valStart:valIdx])
		if err != nil {
			panic("attributes value URL decode failed: " + key)
		}
		result[key] = value

		keyEnd := keyIdx >= len(keys)
		valEnd := valIdx >= len(values)
		if keyEnd != valEnd {
			panic("attributes keys and values count mismatch")
		}
		if keyEnd {
			break
		}

		keyIdx++
		valIdx++
		keyStart = keyIdx
		valStart = valIdx
	}

	return result
}

equipment_test.gno

package equipment

import (
	"chain"
	"testing"

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

var equipmentTest = struct {
	Admin, Operator, Owner, Other address
	SetupDone                     bool
}{
	Admin:    testutils.TestAddress("equipmentAdmin"),
	Operator: testutils.TestAddress("equipmentOperator"),
	Owner:    testutils.TestAddress("equipmentOwner"),
	Other:    testutils.TestAddress("equipmentOther"),
}

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

func TestMintAllocatesSequentialTokenIDs(cur realm, t *testing.T) {
	setupEquipmentTest(cross(cur), t)
	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	uassert.Equal(t, uint64(0), GetLatestTokenID())
	first := Mint(cross(cur), equipmentTest.Owner, 0, "", "")
	second := Mint(cross(cur), equipmentTest.Other, 0, "", "")
	uassert.Equal(t, uint64(1), first)
	uassert.Equal(t, uint64(2), second)
	uassert.Equal(t, uint64(2), GetLatestTokenID())
	uassert.Equal(t, equipmentTest.Owner, OwnerOf(1))
	uassert.Equal(t, equipmentTest.Other, OwnerOf(2))
	uassert.True(t, Has(1))
	uassert.True(t, Has(2))
	uassert.False(t, Has(3))

	latestTokenID = maxEquipmentTokenID
	uassert.AbortsWithMessage(t, cur, "equipment token id exhausted", func() {
		Mint(cross(cur), equipmentTest.Owner, 0, "", "")
	})
}

func TestEquipmentTransferAndBurn(cur realm, t *testing.T) {
	setupEquipmentTest(cross(cur), t)
	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Owner, 0, "", "")
	testing.SetOriginCaller(equipmentTest.Owner)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
	TransferFrom(cross(cur), equipmentTest.Owner, equipmentTest.Other, 1)
	testing.SetOriginCaller(equipmentTest.Other)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Other))
	Burn(cross(cur), 1)
	uassert.PanicsWithMessage(t, cur, "equipment metadata not found: 1", func() {
		GetMetadata(1)
	})
	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement", "3")
	uassert.Equal(t, uint64(2), GetLatestTokenID())
	uassert.Equal(t, equipmentTest.Owner, OwnerOf(2))
	meta := GetMetadata(2)
	uassert.Equal(t, "1101000", meta["definitionId"])
	uassert.Equal(t, "3", meta["enhancement"])
	uassert.True(t, meta[createdAtKey] != "")
}

func TestEquipmentApprovalAllowsTransferAndBurn(cur realm, t *testing.T) {
	setupEquipmentTest(cross(cur), t)
	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Owner, 0, "", "")
	Mint(cross(cur), equipmentTest.Owner, 0, "", "")
	testing.SetOriginCaller(equipmentTest.Owner)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
	Approve(cross(cur), equipmentTest.Other, 1)
	SetApprovalForAll(cross(cur), equipmentTest.Other, true)
	testing.SetOriginCaller(equipmentTest.Other)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Other))
	TransferFrom(cross(cur), equipmentTest.Owner, equipmentTest.Admin, 1)
	Burn(cross(cur), 2)
	uassert.Equal(t, equipmentTest.Admin, OwnerOf(1))
	uassert.Equal(t, int64(0), BalanceOf(equipmentTest.Owner))
}

func TestMintSecurity(cur realm, t *testing.T) {
	setupEquipmentTest(cross(cur), t)
	testing.SetOriginCaller(equipmentTest.Owner)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
		Mint(cross(cur), equipmentTest.Owner, 0, "", "")
	})
	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/equipment_relay"))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
		Mint(cross(cur), equipmentTest.Owner, 0, "", "")
	})
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
	uassert.AbortsWithMessage(t, cur, "attached coins not allowed", func() {
		Mint(cross(cur), equipmentTest.Owner, 0, "", "")
	})
}

func TestEquipmentMetadata(cur realm, t *testing.T) {
	setupEquipmentTest(cross(cur), t)
	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement,note", "3,a%2Cb")
	meta := GetMetadata(1)
	uassert.Equal(t, "1101000", meta["definitionId"])
	uassert.Equal(t, "3", meta["enhancement"])
	uassert.Equal(t, "a,b", meta["note"])
	uassert.True(t, meta[createdAtKey] != "")
	uassert.Equal(t, 4, len(meta))
	meta["definitionId"] = "hacked"
	uassert.Equal(t, "1101000", GetMetadata(1)["definitionId"])

	cases := []struct {
		keys, values, panicMsg string
	}{
		{"definitionId", "1", "reserved key: definitionId"},
		{"tokenId", "1", "reserved key: tokenId"},
		{"created_at", "1", "reserved key: created_at"},
		{"a,a", "1,2", "attributes key duplicated: a"},
		{"a,b", "1", "attributes keys and values count mismatch"},
		{",a", "1,2", "attributes key must be not empty"},
	}
	for _, tc := range cases {
		keys, values, panicMsg := tc.keys, tc.values, tc.panicMsg
		uassert.AbortsWithMessage(t, cur, panicMsg, func() {
			Mint(cross(cur), equipmentTest.Owner, 1, keys, values)
		})
	}
	uassert.Equal(t, int64(1), BalanceOf(equipmentTest.Owner))
	uassert.PanicsWithMessage(t, cur, "equipment metadata not found: 2", func() {
		GetMetadata(2)
	})
}

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

	Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement", "3")
	Mint(cross(cur), equipmentTest.Owner, 1101001, "", "")
	Mint(cross(cur), equipmentTest.Owner, 1101002, "", "")
	uassert.Equal(t, 3, GetOwnedCount(equipmentTest.Owner))
	uassert.Equal(t, int64(3), BalanceOf(equipmentTest.Owner))
	page1 := ListByOwner(equipmentTest.Owner, 1, 2)
	uassert.Equal(t, 2, len(page1))
	uassert.Equal(t, "1", page1[0]["tokenId"])
	uassert.Equal(t, "1101000", page1[0]["definitionId"])
	uassert.Equal(t, "3", page1[0]["enhancement"])
	uassert.Equal(t, "2", page1[1]["tokenId"])
	page2 := ListByOwner(equipmentTest.Owner, 2, 2)
	uassert.Equal(t, 1, len(page2))
	uassert.Equal(t, "3", page2[0]["tokenId"])
	uassert.Equal(t, 0, len(ListByOwner(equipmentTest.Owner, 3, 2)))
	page1[0]["definitionId"] = "hacked"
	uassert.Equal(t, "1101000", ListByOwner(equipmentTest.Owner, 1, 1)[0]["definitionId"])

	testing.SetOriginCaller(equipmentTest.Owner)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
	TransferFrom(cross(cur), equipmentTest.Owner, equipmentTest.Other, 1)
	uassert.Equal(t, 2, GetOwnedCount(equipmentTest.Owner))
	uassert.Equal(t, 1, GetOwnedCount(equipmentTest.Other))
	uassert.Equal(t, "1", ListByOwner(equipmentTest.Other, 1, 10)[0]["tokenId"])
	testing.SetOriginCaller(equipmentTest.Other)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Other))
	Burn(cross(cur), 1)
	uassert.Equal(t, 0, GetOwnedCount(equipmentTest.Other))
	uassert.Equal(t, 2, GetOwnedCount(equipmentTest.Owner))

	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Admin, 1101999, "enhancement", "9")
	uassert.Equal(t, uint64(4), GetLatestTokenID())
	uassert.Equal(t, 1, GetOwnedCount(equipmentTest.Admin))
	uassert.Equal(t, "4", ListByOwner(equipmentTest.Admin, 1, 1)[0]["tokenId"])
	uassert.Equal(t, "1101999", ListByOwner(equipmentTest.Admin, 1, 1)[0]["definitionId"])
	Mint(cross(cur), equipmentTest.Other, 1, "", "")
	uassert.Equal(t, uint64(5), GetLatestTokenID())
	uassert.Equal(t, 1, GetOwnedCount(equipmentTest.Other))
}

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

	testing.SetOriginCaller(equipmentTest.Admin)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.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(equipmentTest.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(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		SetListLimit(cross(cur), 50)
	})

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

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

func TestSetMinterRealm(cur realm, t *testing.T) {
	setupEquipmentTest(cross(cur), t)
	minterPath := "gno.land/r/example/equipment_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(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		SetMinterRealm(cross(cur), minterPath)
	})

	testing.SetOriginCaller(equipmentTest.Admin)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.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/equipment")
	})
	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/equipment_admin_relay"))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		SetMinterRealm(cross(cur), minterPath)
	})
}

func TestMintFromRealm(cur realm, t *testing.T) {
	setupEquipmentTest(cross(cur), t)
	minter := testing.NewCodeRealm("gno.land/r/example/equipment_minter")
	unregistered := testing.NewCodeRealm("gno.land/r/example/equipment_minter_other")

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

	testing.SetRealm(unregistered)
	uassert.AbortsWithMessage(t, cur, "minter realm required", func() {
		MintFromRealm(cross(cur), equipmentTest.Owner, 0, "", "")
	})

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

	testing.SetOriginCaller(equipmentTest.Owner)
	testing.SetRealm(minter)
	MintFromRealm(cross(cur), equipmentTest.Owner, 1101000, "enhancement", "3")
	uassert.Equal(t, uint64(1), GetLatestTokenID())
	uassert.Equal(t, equipmentTest.Owner, OwnerOf(1))
	uassert.Equal(t, "1101000", GetMetadata(1)["definitionId"])
	uassert.Equal(t, "3", GetMetadata(1)["enhancement"])
	uassert.True(t, GetMetadata(1)[createdAtKey] != "")
	uassert.Equal(t, 1, GetOwnedCount(equipmentTest.Owner))

	uassert.AbortsWithMessage(t, cur, "equipment recipient must be origin caller", func() {
		MintFromRealm(cross(cur), equipmentTest.Other, 0, "", "")
	})
	uassert.Equal(t, int64(1), BalanceOf(equipmentTest.Owner))

	testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
	MintFromRealm(cross(cur), equipmentTest.Owner, 1101001, "", "")
	testing.SetOriginSend(chain.Coins{})
	uassert.Equal(t, uint64(2), GetLatestTokenID())
	uassert.Equal(t, equipmentTest.Owner, OwnerOf(2))
}

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

	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Owner, 0, "", "")
	Mint(cross(cur), equipmentTest.Other, 0, "", "")

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

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

	testing.SetRealm(minter)
	uassert.AbortsWithMessage(t, cur, "equipment owner must be origin caller", func() {
		BurnFromRealm(cross(cur), 2)
	})
	uassert.Equal(t, equipmentTest.Other, OwnerOf(2))

	BurnFromRealm(cross(cur), 1)
	uassert.Equal(t, int64(0), BalanceOf(equipmentTest.Owner))
	uassert.PanicsWithMessage(t, cur, "equipment metadata not found: 1", func() {
		GetMetadata(1)
	})

	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Owner, 1101000, "", "")

	testing.SetOriginCaller(equipmentTest.Owner)
	testing.SetRealm(minter)
	uassert.AbortsWithMessage(t, cur, "reserved key: definitionId", func() {
		MintFromRealm(cross(cur), equipmentTest.Owner, 1, "definitionId", "1")
	})
	uassert.Equal(t, equipmentTest.Owner, OwnerOf(3))
	uassert.Equal(t, 1, GetOwnedCount(equipmentTest.Owner))
	uassert.PanicsWithMessage(t, cur, "equipment metadata not found: 4", func() {
		GetMetadata(4)
	})

	testing.SetOriginCaller(equipmentTest.Admin)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Admin))
	UnsetMinterRealm(cross(cur), "gno.land/r/example/equipment_minter")
	testing.SetOriginCaller(equipmentTest.Owner)
	testing.SetRealm(minter)
	uassert.AbortsWithMessage(t, cur, "minter realm required", func() {
		BurnFromRealm(cross(cur), 3)
	})
	uassert.Equal(t, equipmentTest.Owner, OwnerOf(3))
}

func TestSetMetadata(cur realm, t *testing.T) {
	setupEquipmentTest(cross(cur), t)
	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement,note", "3,a%2Cb")
	createdAt := GetMetadata(1)[createdAtKey]
	uassert.True(t, createdAt != "")
	SetMetadata(cross(cur), 1, "enhancement", "4")
	meta := GetMetadata(1)
	uassert.Equal(t, "1101000", meta["definitionId"])
	uassert.Equal(t, "4", meta["enhancement"])
	uassert.Equal(t, createdAt, meta[createdAtKey])
	uassert.Equal(t, 3, len(meta))
	uassert.Equal(t, "4", ListByOwner(equipmentTest.Owner, 1, 1)[0]["enhancement"])
	meta["enhancement"] = "hacked"
	uassert.Equal(t, "4", GetMetadata(1)["enhancement"])

	uassert.AbortsWithMessage(t, cur, "reserved key: definitionId", func() {
		SetMetadata(cross(cur), 1, "definitionId", "9")
	})
	uassert.AbortsWithMessage(t, cur, "reserved key: created_at", func() {
		SetMetadata(cross(cur), 1, "created_at", "1")
	})
	uassert.AbortsWithMessage(t, cur, "equipment metadata not found: 2", func() {
		SetMetadata(cross(cur), 2, "enhancement", "1")
	})
	uassert.Equal(t, "1101000", GetMetadata(1)["definitionId"])

	testing.SetOriginCaller(equipmentTest.Owner)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Owner))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
		SetMetadata(cross(cur), 1, "enhancement", "5")
	})

	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/equipment_relay"))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
		SetMetadata(cross(cur), 1, "enhancement", "5")
	})
}

func TestSetMetadataFromRealm(cur realm, t *testing.T) {
	setupEquipmentTest(cross(cur), t)
	minterPath := "gno.land/r/example/equipment_minter"
	minter := testing.NewCodeRealm(minterPath)

	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement", "3")
	Mint(cross(cur), equipmentTest.Other, 1101001, "enhancement", "1")

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

	testing.SetRealm(minter)
	uassert.AbortsWithMessage(t, cur, "minter realm required", func() {
		SetMetadataFromRealm(cross(cur), 1, "enhancement", "4")
	})

	testing.SetOriginCaller(equipmentTest.Admin)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Admin))
	SetMinterRealm(cross(cur), minterPath)

	testing.SetOriginCaller(equipmentTest.Owner)
	testing.SetRealm(minter)
	uassert.AbortsWithMessage(t, cur, "equipment owner must be origin caller", func() {
		SetMetadataFromRealm(cross(cur), 2, "enhancement", "9")
	})
	uassert.Equal(t, "1", GetMetadata(2)["enhancement"])

	createdAt := GetMetadata(1)[createdAtKey]
	SetMetadataFromRealm(cross(cur), 1, "enhancement", "4")
	uassert.Equal(t, "1101000", GetMetadata(1)["definitionId"])
	uassert.Equal(t, "4", GetMetadata(1)["enhancement"])
	uassert.Equal(t, createdAt, GetMetadata(1)[createdAtKey])

	testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
	SetMetadataFromRealm(cross(cur), 1, "enhancement", "5")
	testing.SetOriginSend(chain.Coins{})
	uassert.Equal(t, "5", GetMetadata(1)["enhancement"])
}

gnomod.toml

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

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

render.gno

package equipment

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 renderEquipmentError("Invalid URL")
	}

	switch u.Path {
	case "":
		return renderEquipmentHome()
	case "owner":
		return renderEquipmentOwner(iURL, address(u.Query().Get("address")))
	default:
		return renderEquipmentError("Not found")
	}
}

func renderEquipmentHome() string {
	return `# AKKADIA Equipment

Look up equipment held by an address.

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

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

	output := `# Equipment Holdings

[← Home](./equipment:)

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

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

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

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

func formatEquipmentHolding(row map[string]string) string {
	line := "* **" + escapeEquipmentMarkdown(row[tokenIDKey]) + "**: definitionId " + escapeEquipmentMarkdown(row[definitionIDKey])
	for key, value := range row {
		if key == tokenIDKey || key == definitionIDKey || key == createdAtKey {
			continue
		}
		line += " · " + escapeEquipmentMarkdown(key) + " " + escapeEquipmentMarkdown(value)
	}
	return line + "\n"
}

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

> ` + escapeEquipmentMarkdown(message) + `

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

func escapeEquipmentMarkdown(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 equipment

import (
	"net/url"
	"strings"
	"testing"

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

func TestRenderHomeAndOwner(cur realm, t *testing.T) {
	setupEquipmentTest(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=" + equipmentTest.Owner.String())
	uassert.True(t, strings.Contains(empty, equipmentTest.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 equipment held"), "should render an empty holding list")

	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Owner, 1101000, "enhancement", "3")
	Mint(cross(cur), equipmentTest.Owner, 1101001, "note", url.PathEscape("**x**"))

	listed := Render("owner?address=" + equipmentTest.Owner.String())
	uassert.True(t, strings.Contains(listed, "Total**: 2"), "should render the owned token count")
	uassert.True(t, strings.Contains(listed, "**1**"), "should render the first token id")
	uassert.True(t, strings.Contains(listed, "definitionId 1101000"), "should render the definition id")
	uassert.True(t, strings.Contains(listed, "enhancement 3"), "should render extra attributes")
	uassert.True(t, strings.Contains(listed, `\*\*x\*\*`), "should escape attribute markdown")
	uassert.False(t, strings.Contains(listed, "**x**"), "raw markdown attributes should not remain")
}

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

	testing.SetOriginCaller(equipmentTest.Operator)
	testing.SetRealm(testing.NewUserRealm(equipmentTest.Operator))
	Mint(cross(cur), equipmentTest.Owner, 1101000, "", "")
	Mint(cross(cur), equipmentTest.Owner, 1101001, "", "")

	page1 := Render("owner?address=" + equipmentTest.Owner.String())
	uassert.True(t, strings.Contains(page1, "Total**: 2"), "should render total holdings")
	uassert.True(t, strings.Contains(page1, "**1**"), "page 1 should include the first token")
	uassert.False(t, strings.Contains(page1, "**2**"), "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=" + equipmentTest.Owner.String() + "&page=2")
	uassert.True(t, strings.Contains(page2, "**2**"), "page 2 should include the second token")
	uassert.False(t, strings.Contains(page2, "**1**"), "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=" + equipmentTest.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) {
	setupEquipmentTest(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 equipment

import "unicode/utf8"

const renderURLMaxRunes = 1024

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