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