Playground
craft.gno
package craft
import (
"chain"
"chain/banker"
"chain/runtime/unsafe"
"strconv"
"gno.land/p/akkadia/beta/accesscontrol"
"gno.land/p/nt/bptree/v0"
"gno.land/r/akkadia/beta/admin"
"gno.land/r/akkadia/beta/equipment"
"gno.land/r/akkadia/beta/item"
)
const (
SetRecipeEvent = "SetRecipe"
DeleteRecipeEvent = "DeleteRecipe"
DeleteRecipesEvent = "DeleteRecipes"
SetListLimitEvent = "SetListLimit"
SetCraftFeeEvent = "SetCraftFee"
CraftEvent = "Craft"
)
var (
recipes = bptree.NewBPTree32()
listLimit = defaultRecipeListLimit
craftFee = defaultCraftFee
)
func init() { resetCraftState() }
func resetCraftState() {
recipes = bptree.NewBPTree32()
listLimit = defaultRecipeListLimit
craftFee = defaultCraftFee
}
// SetRecipe stores the item definition ID produced by a canonical recipe.
func SetRecipe(cur realm, recipe string, itemID uint32) {
accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
assertCraftNoCoins()
canonicalRecipe, _ := mustParseRecipe(recipe)
setRecipe(canonicalRecipe, itemID)
}
// SetRecipes stores up to 100 canonical recipe and item ID pairs in one transaction.
func SetRecipes(cur realm, recipesCSV, itemIDsCSV string) {
accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
assertCraftNoCoins()
canonicalRecipes, itemIDs := mustParseRecipeCSV(recipesCSV, itemIDsCSV)
for i, recipe := range canonicalRecipes {
setRecipe(recipe, itemIDs[i])
}
}
func setRecipe(canonicalRecipe string, itemID uint32) {
recipes.Set(canonicalRecipe, itemID)
chain.Emit(
SetRecipeEvent,
"recipe", canonicalRecipe,
"itemId", strconv.FormatUint(uint64(itemID), 10),
)
}
func DeleteRecipe(cur realm, recipe string) {
accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
assertCraftNoCoins()
canonicalRecipe := mustCanonicalRecipe(recipe)
deleteRecipe(canonicalRecipe)
chain.Emit(DeleteRecipeEvent, "recipe", canonicalRecipe)
}
func DeleteRecipes(cur realm, recipesCSV string) {
accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
assertCraftNoCoins()
canonicalRecipes := mustParseRecipeKeyCSV(recipesCSV)
for _, recipe := range canonicalRecipes {
if !recipes.Has(recipe) {
panic("recipe not found: " + recipe)
}
}
for _, recipe := range canonicalRecipes {
deleteRecipe(recipe)
}
chain.Emit(DeleteRecipesEvent, "count", strconv.Itoa(len(canonicalRecipes)))
}
func deleteRecipe(canonicalRecipe string) {
if _, removed := recipes.Remove(canonicalRecipe); !removed {
panic("recipe not found: " + canonicalRecipe)
}
}
func HasRecipe(recipe string) bool {
canonical, _, errMsg := parseRecipe(recipe)
if errMsg != "" {
return false
}
return recipes.Has(canonical)
}
func GetRecipe(recipe string) uint32 {
return mustGetRecipeItemID(mustCanonicalRecipe(recipe))
}
func GetRecipeCount() int {
return recipes.Size()
}
func ListRecipes(page, count int) []map[string]string {
assertRecipeListPageCount(page, count)
result := []map[string]string{}
recipes.IterateByOffset((page-1)*count, count, func(recipe string, value any) bool {
result = append(result, map[string]string{
"recipe": recipe,
"itemId": strconv.FormatUint(uint64(value.(uint32)), 10),
})
return false
})
return result
}
func SetListLimit(cur realm, limit int) {
accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
assertCraftNoCoins()
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 SetCraftFee(cur realm, fee int64) {
accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
assertCraftNoCoins()
if fee < 0 {
panic("fee must be non-negative")
}
oldFee := craftFee
craftFee = fee
chain.Emit(
SetCraftFeeEvent,
"oldFee", strconv.FormatInt(oldFee, 10),
"newFee", strconv.FormatInt(fee, 10),
)
}
func GetCraftFee() int64 {
return craftFee
}
// Craft burns a canonical recipe and mints the next GRC721 equipment token.
func Craft(cur realm, recipe string) uint64 {
caller := accesscontrol.MustGetUserCaller(0, cur)
canonicalRecipe, ingredients := mustParseRecipe(recipe)
itemID := mustGetRecipeItemID(canonicalRecipe)
assertExactUgnotPayment(craftFee)
for _, ingredient := range ingredients {
item.BurnFromRealm(cross(cur), caller, ingredient.TokenID, ingredient.Amount)
}
tokenID := equipment.MintFromRealm(cross(cur), caller, itemID, "", "")
if craftFee > 0 {
bnk := banker.NewBanker(banker.BankerTypeRealmSend, cur)
bnk.SendCoins(cur.Address(), admin.GetFeeCollector(), chain.Coins{{"ugnot", craftFee}})
}
chain.Emit(
CraftEvent,
"owner", caller.String(),
"recipe", canonicalRecipe,
"equipmentTokenId", strconv.FormatUint(tokenID, 10),
"itemId", strconv.FormatUint(uint64(itemID), 10),
"fee", strconv.FormatInt(craftFee, 10),
)
return tokenID
}
func mustCanonicalRecipe(recipe string) string {
canonical, _ := mustParseRecipe(recipe)
return canonical
}
func mustGetRecipeItemID(recipe string) uint32 {
value := recipes.Get(recipe)
if value == nil {
panic("recipe not found: " + recipe)
}
return value.(uint32)
}
func assertCraftNoCoins() {
if len(unsafe.OriginSend()) != 0 {
panic("attached coins not allowed")
}
}
func assertExactUgnotPayment(expected int64) {
coins := unsafe.OriginSend()
if expected == 0 {
if len(coins) != 0 {
panic("exact payment required: expected no coins, got " + coins.String())
}
return
}
if len(coins) != 1 || coins[0].Denom != "ugnot" || coins[0].Amount != expected {
panic("exact payment required: expected " + strconv.FormatInt(expected, 10) + "ugnot, got " + coins.String())
}
}
craft_test.gno
package craft
import (
"chain"
"testing"
"gno.land/p/nt/uassert/v0"
"gno.land/r/akkadia/beta/equipment"
"gno.land/r/akkadia/beta/item"
)
func TestSetRecipeCreatesAndUpdatesRecipe(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), "0001|minecraft:iron_ingot:01", 100)
uassert.True(t, HasRecipe("0001|minecraft:iron_ingot:1"))
uassert.True(t, HasRecipe("0001|minecraft:iron_ingot:01"))
uassert.True(t, HasRecipe("0001|0:minecraft:iron_ingot:1"))
uassert.Equal(t, uint32(100), GetRecipe("0001|minecraft:iron_ingot:01"))
uassert.Equal(t, 1, GetRecipeCount())
SetRecipe(cross(cur), "0001|0:minecraft:iron_ingot:1", 101)
uassert.Equal(t, uint32(101), GetRecipe("0001|minecraft:iron_ingot:1"))
uassert.Equal(t, 1, GetRecipeCount())
SetRecipe(cross(cur), "000A|craft-hex-a:1|craft-hex-b:2", 102)
uassert.True(t, HasRecipe("000a|craft-hex-a:1|craft-hex-b:2"))
uassert.Equal(t, uint32(102), GetRecipe("000A|craft-hex-a:1|craft-hex-b:2"))
uassert.Equal(t, 2, GetRecipeCount())
}
func TestSetRecipeRequiresDirectAdminWithoutCoins(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
recipe := "0001|craft-security-item:1"
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "admin access required", func() {
SetRecipe(cross(cur), recipe, 200)
})
uassert.False(t, HasRecipe(recipe))
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/craft_admin_relay"))
uassert.AbortsWithMessage(t, cur, "admin access required", func() {
SetRecipe(cross(cur), recipe, 200)
})
uassert.False(t, HasRecipe(recipe))
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
uassert.AbortsWithMessage(t, cur, "attached coins not allowed", func() {
SetRecipe(cross(cur), recipe, 200)
})
testing.SetOriginSend(chain.Coins{})
uassert.False(t, HasRecipe(recipe))
}
func TestSetRecipesStoresMultipleRecipes(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipes(
cross(cur),
"0001|craft-batch-iron:1,0002|craft-batch-gold:2",
"300,301",
)
uassert.Equal(t, uint32(300), GetRecipe("0001|craft-batch-iron:1"))
uassert.Equal(t, uint32(301), GetRecipe("0002|craft-batch-gold:2"))
}
func TestSetRecipesStoresOccupancyBatch(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipes(
cross(cur),
"0013|test-iron:1|test-iron:2|test-stick:2,"+
"0003|test-wood:2|test-stone:1,"+
"0001|test-herb:3,"+
"0007|test-copper:1|test-leather:2|test-cloth:1",
"1101000,1101001,1101002,1101003",
)
uassert.Equal(t, 4, GetRecipeCount())
uassert.Equal(t, uint32(1101000), GetRecipe("0013|test-iron:1|test-iron:2|test-stick:2"))
uassert.Equal(t, uint32(1101001), GetRecipe("0003|test-wood:2|test-stone:1"))
uassert.Equal(t, uint32(1101002), GetRecipe("0001|test-herb:3"))
uassert.Equal(t, uint32(1101003), GetRecipe("0007|test-copper:1|test-leather:2|test-cloth:1"))
uassert.True(t, HasRecipe("0013|0:test-iron:1|1:test-iron:2|4:test-stick:2"))
uassert.Equal(t, 4, len(ListRecipes(1, 20)))
}
func TestSetRecipesAllowsLastDuplicateToWin(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
recipe := "0001|craft-batch-duplicate:1"
SetRecipes(cross(cur), recipe+","+recipe, "310,311")
uassert.Equal(t, uint32(311), GetRecipe(recipe))
}
func TestSetRecipesRequiresDirectAdmin(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
recipe := "0001|craft-batch-security:1"
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "admin access required", func() {
SetRecipes(cross(cur), recipe, "320")
})
uassert.False(t, HasRecipe(recipe))
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/craft_batch_relay"))
uassert.AbortsWithMessage(t, cur, "admin access required", func() {
SetRecipes(cross(cur), recipe, "320")
})
uassert.False(t, HasRecipe(recipe))
}
func TestSetRecipesRejectsCountMismatchAndRollsBack(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
firstRecipe := "0001|craft-mismatch-a:1"
secondRecipe := "0001|craft-mismatch-b:1"
uassert.AbortsWithMessage(t, cur, "recipes and item ids count mismatch", func() {
SetRecipes(cross(cur), firstRecipe+","+secondRecipe, "400")
})
uassert.False(t, HasRecipe(firstRecipe))
uassert.False(t, HasRecipe(secondRecipe))
}
func TestSetRecipesRejectsInvalidItemID(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
recipe := "0001|craft-invalid-id:1"
uassert.AbortsWithMessage(t, cur, "invalid item id: invalid", func() {
SetRecipes(cross(cur), recipe, "invalid")
})
uassert.False(t, HasRecipe(recipe))
}
func TestSetRecipesRejectsEmptyTokensAndTrailingComma(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
recipe := "0001|craft-empty-token:1"
uassert.AbortsWithMessage(t, cur, "empty recipe not allowed", func() {
SetRecipes(cross(cur), recipe+",", "410,411")
})
uassert.False(t, HasRecipe(recipe))
uassert.AbortsWithMessage(t, cur, "empty item id not allowed", func() {
SetRecipes(cross(cur), recipe+",0001|craft-empty-id:1", "412,")
})
uassert.False(t, HasRecipe(recipe))
}
func TestSetRecipesRejectsBatchAboveLimit(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
recipe := "0001|craft-batch-limit:1"
recipesCSV := recipe
itemIDsCSV := "500"
for i := 1; i < 101; i++ {
recipesCSV += "," + recipe
itemIDsCSV += ",500"
}
uassert.AbortsWithMessage(t, cur, "recipes exceeds 100", func() {
SetRecipes(cross(cur), recipesCSV, itemIDsCSV)
})
uassert.False(t, HasRecipe(recipe))
}
func TestDeleteRecipeRemovesRecipe(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
recipe := "0001|craft-delete-item:1"
SetRecipe(cross(cur), recipe, 600)
DeleteRecipe(cross(cur), "0001|craft-delete-item:01")
uassert.False(t, HasRecipe(recipe))
uassert.Equal(t, 0, GetRecipeCount())
}
func TestDeleteRecipesRemovesBatchAndRequiresAdmin(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
firstRecipe := "0001|craft-delete-a:1"
secondRecipe := "0002|craft-delete-b:1"
SetRecipe(cross(cur), firstRecipe, 601)
SetRecipe(cross(cur), secondRecipe, 602)
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "admin access required", func() {
DeleteRecipes(cross(cur), firstRecipe)
})
uassert.True(t, HasRecipe(firstRecipe))
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
DeleteRecipes(cross(cur), firstRecipe+","+secondRecipe)
uassert.False(t, HasRecipe(firstRecipe))
uassert.False(t, HasRecipe(secondRecipe))
}
func TestDeleteRecipesRejectsMissingAndRollsBack(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
firstRecipe := "0001|craft-delete-missing-a:1"
secondRecipe := "0002|craft-delete-missing-b:1"
SetRecipe(cross(cur), firstRecipe, 603)
SetRecipe(cross(cur), secondRecipe, 604)
uassert.AbortsWithMessage(t, cur, "recipe not found: 0001|0:craft-delete-missing-c:1", func() {
DeleteRecipes(cross(cur), firstRecipe+",0001|craft-delete-missing-c:1")
})
uassert.True(t, HasRecipe(firstRecipe))
uassert.True(t, HasRecipe(secondRecipe))
}
func TestDeleteRecipeRejectsMissingRecipe(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
uassert.AbortsWithMessage(t, cur, "recipe not found: 0001|0:craft-missing-delete:1", func() {
DeleteRecipe(cross(cur), "0001|craft-missing-delete:1")
})
}
func TestListRecipesPagesAndCopiesRows(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), "0001|craft-list-a:1", 701)
SetRecipe(cross(cur), "0002|craft-list-b:1", 702)
SetRecipe(cross(cur), "0004|craft-list-c:1", 703)
uassert.Equal(t, 3, GetRecipeCount())
page1 := ListRecipes(1, 2)
uassert.Equal(t, 2, len(page1))
page1[0]["itemId"] = "hacked"
uassert.Equal(t, "701", ListRecipes(1, 2)[0]["itemId"])
page2 := ListRecipes(2, 2)
uassert.Equal(t, 1, len(page2))
uassert.Equal(t, 0, len(ListRecipes(3, 2)))
uassert.PanicsWithMessage(t, cur, "page must be at least 1", func() {
ListRecipes(0, 1)
})
uassert.PanicsWithMessage(t, cur, "count must be at least 1", func() {
ListRecipes(1, 0)
})
uassert.PanicsWithMessage(t, cur, "count exceeds listLimit (max: 100)", func() {
ListRecipes(1, 101)
})
}
func TestSetListLimit(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetListLimit(cross(cur), 1)
uassert.Equal(t, 1, GetListLimit())
uassert.PanicsWithMessage(t, cur, "count exceeds listLimit (max: 1)", func() {
ListRecipes(1, 2)
})
uassert.AbortsWithMessage(t, cur, "limit must be at least 1", func() {
SetListLimit(cross(cur), 0)
})
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "admin access required", func() {
SetListLimit(cross(cur), 50)
})
}
func TestMustParseRecipeCanonicalizesSlotsAndCountsIngredients(cur realm, t *testing.T) {
canonical, ingredients := mustParseRecipe("0013|minecraft:iron_ingot:01|minecraft:iron_ingot:2|minecraft:stick:3")
uassert.Equal(t, "0013|0:minecraft:iron_ingot:1|1:minecraft:iron_ingot:2|4:minecraft:stick:3", canonical)
uassert.Equal(t, 3, len(ingredients))
uassert.Equal(t, uint(0), ingredients[0].Slot)
uassert.Equal(t, "minecraft:iron_ingot", ingredients[0].TokenID)
uassert.Equal(t, int64(1), ingredients[0].Amount)
uassert.Equal(t, uint(4), ingredients[2].Slot)
uassert.Equal(t, "minecraft:stick", ingredients[2].TokenID)
uassert.Equal(t, int64(3), ingredients[2].Amount)
roundTrip, _ := mustParseRecipe(canonical)
uassert.Equal(t, canonical, roundTrip)
hexCanonical, hexIngredients := mustParseRecipe("000A|craft-hex-a:1|craft-hex-b:2")
uassert.Equal(t, "000a|1:craft-hex-a:1|3:craft-hex-b:2", hexCanonical)
uassert.Equal(t, uint(1), hexIngredients[0].Slot)
uassert.Equal(t, uint(3), hexIngredients[1].Slot)
}
func TestMustParseRecipeRejectsInvalidRecipes(cur realm, t *testing.T) {
tests := []struct {
recipe, panicMsg string
}{
{"", "invalid recipe"},
{"0000|item:1", "invalid recipe occupancy"},
{"0001|item", "invalid recipe ingredient"},
{"0001|item:0", "ingredient amount must be positive"},
{"0003|item:1", "occupied slots and ingredients count mismatch"},
{"0001|1:item:1", "ingredient slot mismatch"},
{"0013|4:stick:1|0:iron:1|1:iron:1", "ingredient slot mismatch"},
{"0001|%zz:1", "invalid item token id"},
}
for _, tc := range tests {
recipe, panicMsg := tc.recipe, tc.panicMsg
uassert.PanicsWithMessage(t, cur, panicMsg, func() {
mustParseRecipe(recipe)
})
}
}
func TestHasRecipeReturnsFalseForInvalidAndMissingRecipes(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
uassert.False(t, HasRecipe(""))
uassert.False(t, HasRecipe("not-a-recipe"))
uassert.False(t, HasRecipe("0001|craft-missing-query:1"))
uassert.PanicsWithMessage(t, cur, "recipe not found: 0001|0:craft-missing-query:1", func() {
GetRecipe("0001|craft-missing-query:1")
})
}
func TestCraftBurnsItemsAndMintsEquipment(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
recipe := "0013|craft-success-iron:1|craft-success-iron:2|craft-success-stick:2"
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), recipe, 1101000)
mintCraftItem(cross(cur), "craft-success-iron", 3)
mintCraftItem(cross(cur), "craft-success-stick", 2)
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
before := equipment.GetLatestTokenID()
collectorBefore := ugnotBalanceForTest(craftTest.FeeCollector)
realmBefore := ugnotBalanceForTest(craftTest.PkgAddr)
payCraftFee(defaultCraftFeeCoins())
tokenID := Craft(cross(cur), "0013|craft-success-iron:01|craft-success-iron:2|craft-success-stick:2")
uassert.Equal(t, before+1, tokenID)
uassert.Equal(t, int64(0), item.BalanceOf(craftTest.Owner, "craft-success-iron"))
uassert.Equal(t, int64(0), item.BalanceOf(craftTest.Owner, "craft-success-stick"))
uassert.Equal(t, craftTest.Owner, equipment.OwnerOf(tokenID))
uassert.Equal(t, "1101000", equipment.GetMetadata(tokenID)["definitionId"])
uassert.Equal(t, defaultCraftFee, ugnotBalanceForTest(craftTest.FeeCollector)-collectorBefore)
uassert.Equal(t, realmBefore, ugnotBalanceForTest(craftTest.PkgAddr))
}
func TestCraftAllocatesSequentialEquipmentTokenIDs(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
recipe := "0001|craft-skip-id:1"
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), recipe, 1101003)
mintCraftItem(cross(cur), "craft-skip-id", 2)
before := equipment.GetLatestTokenID()
equipment.Mint(cross(cur), craftTest.Other, 1101998, "", "")
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
payCraftFee(defaultCraftFeeCoins())
tokenID := Craft(cross(cur), recipe)
uassert.Equal(t, before+2, tokenID)
uassert.Equal(t, craftTest.Other, equipment.OwnerOf(before+1))
uassert.Equal(t, craftTest.Owner, equipment.OwnerOf(tokenID))
}
func TestCraftRequiresEquipmentMinterRealm(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
recipe := "0001|craft-mint-rollback:2"
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), recipe, 1101001)
mintCraftItem(cross(cur), "craft-mint-rollback", 2)
equipment.UnsetMinterRealm(cross(cur), "gno.land/r/akkadia/beta/craft")
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "minter realm required", func() {
payCraftFee(defaultCraftFeeCoins())
Craft(cross(cur), recipe)
})
}
func TestCraftRequiresItemMinterRealm(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
recipe := "0001|craft-item-minter:1"
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), recipe, 1101005)
mintCraftItem(cross(cur), "craft-item-minter", 1)
item.UnsetMinterRealm(cross(cur), "gno.land/r/akkadia/beta/craft")
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "minter realm required", func() {
payCraftFee(defaultCraftFeeCoins())
Craft(cross(cur), recipe)
})
uassert.Equal(t, int64(1), item.BalanceOf(craftTest.Owner, "craft-item-minter"))
}
func TestCraftRejectsUnknownRecipeAndInsufficientItems(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
recipe := "0001|craft-fail-item:2"
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "recipe not found: 0001|0:craft-fail-item:2", func() {
Craft(cross(cur), recipe)
})
uassert.AbortsWithMessage(t, cur, "invalid recipe", func() {
Craft(cross(cur), "bad")
})
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), recipe, 1101004)
mintCraftItem(cross(cur), "craft-fail-item", 1)
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "item burn amount exceeds supply", func() {
payCraftFee(defaultCraftFeeCoins())
Craft(cross(cur), recipe)
})
uassert.Equal(t, int64(1), item.BalanceOf(craftTest.Owner, "craft-fail-item"))
}
func TestCraftRequiresDirectUserAndExactFee(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
recipe := "0001|craft-craft-security:1"
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), recipe, 1101002)
before := equipment.GetLatestTokenID()
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/craft_craft_relay"))
uassert.AbortsWithMessage(t, cur, "contract calls not allowed: function must be called directly by user", func() {
Craft(cross(cur), recipe)
})
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "exact payment required: expected 1000000ugnot, got ", func() {
Craft(cross(cur), recipe)
})
uassert.AbortsWithMessage(t, cur, "exact payment required: expected 1000000ugnot, got 1ugnot", func() {
payCraftFee(chain.Coins{{"ugnot", 1}})
Craft(cross(cur), recipe)
})
testing.SetOriginSend(chain.Coins{})
uassert.Equal(t, before, equipment.GetLatestTokenID())
}
func TestCraftRejectsInexactPayment(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
recipe := "0001|craft-inexact-fee:1"
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), recipe, 1101006)
mintCraftItem(cross(cur), "craft-inexact-fee", 3)
before := equipment.GetLatestTokenID()
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "exact payment required: expected 1000000ugnot, got 999999ugnot", func() {
payCraftFee(chain.Coins{{"ugnot", 999_999}})
Craft(cross(cur), recipe)
})
uassert.AbortsWithMessage(t, cur, "exact payment required: expected 1000000ugnot, got 1000001ugnot", func() {
payCraftFee(chain.Coins{{"ugnot", 1_000_001}})
Craft(cross(cur), recipe)
})
uassert.AbortsWithMessage(t, cur, "exact payment required: expected 1000000ugnot, got 1000000ugnot,1foo", func() {
payCraftFee(chain.Coins{{"ugnot", defaultCraftFee}, {"foo", 1}})
Craft(cross(cur), recipe)
})
uassert.Equal(t, before, equipment.GetLatestTokenID())
uassert.Equal(t, int64(3), item.BalanceOf(craftTest.Owner, "craft-inexact-fee"))
}
func TestSetCraftFeeUpdatesFeeAndAllowsFreeCraft(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
uassert.Equal(t, defaultCraftFee, GetCraftFee())
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetCraftFee(cross(cur), 2_000_000)
uassert.Equal(t, int64(2_000_000), GetCraftFee())
SetCraftFee(cross(cur), 0)
uassert.Equal(t, int64(0), GetCraftFee())
recipe := "0001|craft-free-fee:1"
SetRecipe(cross(cur), recipe, 1101007)
mintCraftItem(cross(cur), "craft-free-fee", 1)
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "exact payment required: expected no coins, got 1ugnot", func() {
payCraftFee(chain.Coins{{"ugnot", 1}})
Craft(cross(cur), recipe)
})
collectorBefore := ugnotBalanceForTest(craftTest.FeeCollector)
payCraftFee(chain.Coins{})
tokenID := Craft(cross(cur), recipe)
uassert.Equal(t, craftTest.Owner, equipment.OwnerOf(tokenID))
uassert.Equal(t, collectorBefore, ugnotBalanceForTest(craftTest.FeeCollector))
}
func TestSetCraftFeeRequiresDirectAdminWithoutCoins(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
uassert.Equal(t, defaultCraftFee, GetCraftFee())
testing.SetOriginCaller(craftTest.Owner)
testing.SetRealm(testing.NewUserRealm(craftTest.Owner))
uassert.AbortsWithMessage(t, cur, "admin access required", func() {
SetCraftFee(cross(cur), 50)
})
uassert.Equal(t, defaultCraftFee, GetCraftFee())
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/craft_fee_relay"))
uassert.AbortsWithMessage(t, cur, "admin access required", func() {
SetCraftFee(cross(cur), 50)
})
uassert.Equal(t, defaultCraftFee, GetCraftFee())
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
uassert.AbortsWithMessage(t, cur, "attached coins not allowed", func() {
SetCraftFee(cross(cur), 50)
})
testing.SetOriginSend(chain.Coins{})
uassert.Equal(t, defaultCraftFee, GetCraftFee())
uassert.AbortsWithMessage(t, cur, "fee must be non-negative", func() {
SetCraftFee(cross(cur), -1)
})
uassert.Equal(t, defaultCraftFee, GetCraftFee())
}
gnomod.toml
module = "gno.land/r/akkadia/beta/craft" gno = "0.9" [addpkg] creator = "g1ftls0ctrrj0y96sr9dq906j7gdqhg9exgcvaey" height = 747764 max_deposit = "100000000ugnot"
render.gno
package craft
import (
"net/url"
"strconv"
"strings"
)
func Render(iURL string) string {
u, err := url.Parse(iURL)
if err != nil {
return renderRecipeError("Invalid URL")
}
switch u.Path {
case "":
return renderRecipeHome()
case "recipe":
return renderRecipeResult(u.Query().Get("recipe"))
case "recipes":
return renderRecipeList(u.Query().Get("page"))
default:
return renderRecipeError("Not found")
}
}
func renderRecipeHome() string {
return `# AKKADIA Recipe
Ingredients are bound to occupied occupancy bits from slot 0 upward.
Current craft fee is ` + strconv.FormatInt(GetCraftFee(), 10) + `ugnot.
Enter a recipe to find its item ID.
<gno-form path="recipe">
<gno-input name="recipe" placeholder="0013|iron:1|iron:2|stick:3" />
</gno-form>
* [Browse Recipes](./craft:recipes)
`
}
func renderRecipeList(rawPage string) string {
page := 1
if rawPage != "" {
parsed, err := strconv.Atoi(rawPage)
if err != nil || parsed < 1 {
return renderRecipeError("Invalid page")
}
page = parsed
}
count := 20
if count > listLimit {
count = listLimit
}
output := `# Recipes
[← Back](./craft:)
`
total := GetRecipeCount()
if total == 0 {
return output + `*No recipes stored yet.*
`
}
rows := ListRecipes(page, count)
if len(rows) == 0 {
return renderRecipeError("Invalid page")
}
for _, row := range rows {
output += "* " + formatRecipeCode(row["recipe"]) + " → " + row["itemId"] + "\n"
}
return output
}
func renderRecipeResult(recipe string) string {
if recipe == "" {
return renderRecipeError("Recipe is required")
}
canonical, _, errMsg := parseRecipe(recipe)
if errMsg != "" {
return renderRecipeError("Invalid recipe")
}
if !recipes.Has(canonical) {
return renderRecipeError("Recipe not found")
}
return `# Recipe Result
* **Recipe**: ` + formatRecipeCode(canonical) + `
* **Item ID**: ` + strconv.FormatUint(uint64(mustGetRecipeItemID(canonical)), 10) + `
[← Back](./craft:)
`
}
func renderRecipeError(message string) string {
return `# Error
> ` + message + `
[← Back](./craft:)
`
}
// Recipes use | and - as syntax. A code span keeps those characters
// literal so gnoweb does not show backslash escapes.
func formatRecipeCode(recipe string) string {
recipe = strings.ReplaceAll(recipe, "\n", " ")
fence := "`"
for strings.Contains(recipe, fence) {
fence += "`"
}
return fence + recipe + fence
}
render_test.gno
package craft
import (
"strings"
"testing"
"gno.land/p/nt/uassert/v0"
)
func TestRenderRecipeLookup(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), "0001|craft-render-item:01", 1200)
output := Render("recipe?recipe=0001%7Ccraft-render-item%3A1")
uassert.True(t, strings.Contains(output, "Item ID**: 1200"), "should render the mapped item ID")
uassert.True(t, strings.Contains(output, "`0001|0:craft-render-item:1`"), "should render the canonical recipe as a code span")
uassert.False(t, strings.Contains(output, `\|`), "recipe code span should keep pipes literal")
}
func TestRenderRecipeErrors(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
empty := Render("recipe")
uassert.True(t, strings.Contains(empty, "Recipe is required"), "should require a recipe")
invalid := Render("recipe?recipe=bad")
uassert.True(t, strings.Contains(invalid, "Invalid recipe"), "should reject an invalid recipe")
missing := Render("recipe?recipe=0001%7Ccraft-missing-item%3A1")
uassert.True(t, strings.Contains(missing, "Recipe not found"), "should report a missing recipe")
unknown := Render("unknown")
uassert.True(t, strings.Contains(unknown, "Not found"), "should reject an unknown route")
}
func TestRenderRecipeHomeAndList(cur realm, t *testing.T) {
setupCraftTest(cross(cur), t)
home := Render("")
uassert.True(t, strings.Contains(home, `<gno-form path="recipe">`), "should render the recipe lookup form")
uassert.True(t, strings.Contains(home, `name="recipe"`), "should render the recipe input")
uassert.True(t, strings.Contains(home, `./craft:recipes`), "should link to the recipe list")
uassert.True(t, strings.Contains(home, "1000000ugnot"), "should render the default craft fee")
emptyList := Render("recipes")
uassert.True(t, strings.Contains(emptyList, "No recipes stored yet"), "should render an empty list")
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
SetRecipe(cross(cur), "0001|craft-list-render:1", 1300)
listed := Render("recipes")
uassert.True(t, strings.Contains(listed, "1300"), "should render stored item IDs")
uassert.True(t, strings.Contains(listed, "`0001|0:craft-list-render:1`"), "should render listed recipes as a code span")
uassert.False(t, strings.Contains(listed, `\|`), "listed recipe code span should keep pipes literal")
}
setup_test.gno
package craft
import (
"chain"
"chain/banker"
"testing"
"gno.land/p/nt/testutils/v0"
"gno.land/r/akkadia/beta/admin"
"gno.land/r/akkadia/beta/equipment"
"gno.land/r/akkadia/beta/item"
)
var craftTest = struct {
Admin, Owner, Other, FeeCollector, PkgAddr address
SetupDone bool
}{
Admin: testutils.TestAddress("craftAdmin"),
Owner: testutils.TestAddress("craftOwner"),
Other: testutils.TestAddress("craftOther"),
FeeCollector: testutils.TestAddress("craftFeeCollector"),
PkgAddr: chain.PackageAddress("gno.land/r/akkadia/beta/craft"),
}
func setupCraftTest(cur realm, t *testing.T) {
t.Helper()
resetCraftState()
testing.SetOriginSend(chain.Coins{})
if !craftTest.SetupDone {
originalAdmin := admin.GetAdmin()
testing.SetOriginCaller(originalAdmin)
testing.SetRealm(testing.NewUserRealm(originalAdmin))
admin.TransferAdmin(cross(cur), craftTest.Admin)
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
admin.AcceptAdmin(cross(cur))
admin.SetFeeCollector(cross(cur), craftTest.FeeCollector)
craftTest.SetupDone = true
}
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
item.SetMinterRealm(cross(cur), "gno.land/r/akkadia/beta/craft")
equipment.SetMinterRealm(cross(cur), "gno.land/r/akkadia/beta/craft")
}
func mintCraftItem(cur realm, tokenID string, amount int64) {
testing.SetOriginCaller(craftTest.Admin)
testing.SetRealm(testing.NewUserRealm(craftTest.Admin))
item.SafeMint(cross(cur), craftTest.Owner, tokenID, amount)
}
func defaultCraftFeeCoins() chain.Coins {
return chain.Coins{{"ugnot", defaultCraftFee}}
}
func payCraftFee(coins chain.Coins) {
if len(coins) > 0 {
testing.IssueCoins(craftTest.PkgAddr, coins)
}
testing.SetOriginSend(coins)
}
func ugnotBalanceForTest(addr address) int64 {
return banker.NewReadonlyBanker().GetCoins(addr).AmountOf("ugnot")
}
validation.gno
package craft
import (
"net/url"
"strconv"
)
const (
recipeBatchLimit = 100
maxRecipeIngredients = 16
defaultRecipeListLimit = 100
defaultCraftFee int64 = 1_000_000
)
type craftIngredient struct {
Slot uint
TokenID string
Amount int64
}
func mustParseRecipeCSV(recipesCSV, itemIDsCSV string) ([]string, []uint32) {
if recipesCSV == "" {
panic("recipes is required")
}
if itemIDsCSV == "" {
panic("item ids is required")
}
canonicalRecipes := []string{}
itemIDs := []uint32{}
recipeStart, recipeEnd := 0, 0
itemIDStart, itemIDEnd := 0, 0
for {
for recipeEnd < len(recipesCSV) && recipesCSV[recipeEnd] != ',' {
recipeEnd++
}
for itemIDEnd < len(itemIDsCSV) && itemIDsCSV[itemIDEnd] != ',' {
itemIDEnd++
}
recipeToken := recipesCSV[recipeStart:recipeEnd]
itemIDText := itemIDsCSV[itemIDStart:itemIDEnd]
if recipeToken == "" {
panic("empty recipe not allowed")
}
if itemIDText == "" {
panic("empty item id not allowed")
}
canonicalRecipe, _ := mustParseRecipe(recipeToken)
itemIDValue, err := strconv.ParseUint(itemIDText, 10, 32)
if err != nil {
panic("invalid item id: " + itemIDText)
}
canonicalRecipes = append(canonicalRecipes, canonicalRecipe)
itemIDs = append(itemIDs, uint32(itemIDValue))
if len(canonicalRecipes) > recipeBatchLimit {
panic("recipes exceeds 100")
}
recipeDone := recipeEnd >= len(recipesCSV)
itemIDDone := itemIDEnd >= len(itemIDsCSV)
if recipeDone != itemIDDone {
panic("recipes and item ids count mismatch")
}
if recipeDone {
return canonicalRecipes, itemIDs
}
recipeEnd++
itemIDEnd++
recipeStart = recipeEnd
itemIDStart = itemIDEnd
}
}
func mustParseRecipeKeyCSV(recipesCSV string) []string {
if recipesCSV == "" {
panic("recipes is required")
}
canonicalRecipes := []string{}
recipeStart, recipeEnd := 0, 0
for {
for recipeEnd < len(recipesCSV) && recipesCSV[recipeEnd] != ',' {
recipeEnd++
}
recipeToken := recipesCSV[recipeStart:recipeEnd]
if recipeToken == "" {
panic("empty recipe not allowed")
}
canonicalRecipe, _ := mustParseRecipe(recipeToken)
canonicalRecipes = append(canonicalRecipes, canonicalRecipe)
if len(canonicalRecipes) > recipeBatchLimit {
panic("recipes exceeds 100")
}
if recipeEnd >= len(recipesCSV) {
return canonicalRecipes
}
recipeEnd++
recipeStart = recipeEnd
}
}
func mustParseRecipe(recipe string) (string, []craftIngredient) {
canonical, ingredients, errMsg := parseRecipe(recipe)
if errMsg != "" {
panic(errMsg)
}
return canonical, ingredients
}
// A valid recipe is "<4-hex occupancy>|<ingredient>|...". Occupancy bits
// choose slots 0-15 in order; each ingredient is "tokenId:amount" or
// "slot:tokenId:amount". Example: "0013|iron:1|iron:2|stick:2" (bits 0,1,4)
// canonicalizes to "0013|0:iron:1|1:iron:2|4:stick:2".
func parseRecipe(recipe string) (string, []craftIngredient, string) {
if len(recipe) < 7 || recipe[4] != '|' {
return "", nil, "invalid recipe"
}
occupancyValue, err := strconv.ParseUint(recipe[:4], 16, 16)
if err != nil || occupancyValue == 0 {
return "", nil, "invalid recipe occupancy"
}
occupancy := uint16(occupancyValue)
slots := occupiedSlots(occupancy)
ingredients := []craftIngredient{}
entryStart, entryEnd := 5, 5
for {
for entryEnd < len(recipe) && recipe[entryEnd] != '|' {
entryEnd++
}
if len(ingredients) == len(slots) {
return "", nil, "occupied slots and ingredients count mismatch"
}
ingredient, errMsg := parseRecipeIngredient(
recipe[entryStart:entryEnd],
slots[len(ingredients)],
)
if errMsg != "" {
return "", nil, errMsg
}
ingredients = append(ingredients, ingredient)
if len(ingredients) > maxRecipeIngredients {
return "", nil, "recipe ingredients exceeds 16"
}
if entryEnd >= len(recipe) {
break
}
entryEnd++
entryStart = entryEnd
}
if len(ingredients) != len(slots) {
return "", nil, "occupied slots and ingredients count mismatch"
}
canonicalRecipe := formatOccupancy(occupancy)
for _, ingredient := range ingredients {
canonicalRecipe += "|" +
strconv.FormatUint(uint64(ingredient.Slot), 10) + ":" +
url.PathEscape(ingredient.TokenID) + ":" +
strconv.FormatInt(ingredient.Amount, 10)
}
return canonicalRecipe, ingredients, ""
}
func parseRecipeIngredient(entry string, expectedSlot uint) (craftIngredient, string) {
amountSeparator := len(entry) - 1
for amountSeparator > 0 && entry[amountSeparator] != ':' {
amountSeparator--
}
if amountSeparator == 0 || entry[amountSeparator] != ':' {
return craftIngredient{}, "invalid recipe ingredient"
}
tokenField := entry[:amountSeparator]
amountText := entry[amountSeparator+1:]
encodedTokenID := tokenField
slotPrefixEnd := 0
for slotPrefixEnd < len(tokenField) && tokenField[slotPrefixEnd] != ':' {
slotPrefixEnd++
}
if slotPrefixEnd < len(tokenField) && tokenField[slotPrefixEnd] == ':' {
slotValue, err := strconv.ParseUint(tokenField[:slotPrefixEnd], 10, 8)
if err == nil {
if uint(slotValue) != expectedSlot {
return craftIngredient{}, "ingredient slot mismatch"
}
encodedTokenID = tokenField[slotPrefixEnd+1:]
}
}
tokenID, err := url.PathUnescape(encodedTokenID)
if err != nil || tokenID == "" {
return craftIngredient{}, "invalid item token id"
}
amount, err := strconv.ParseInt(amountText, 10, 64)
if err != nil {
return craftIngredient{}, "invalid ingredient amount: " + amountText
}
if amount <= 0 {
return craftIngredient{}, "ingredient amount must be positive"
}
return craftIngredient{
Slot: expectedSlot,
TokenID: tokenID,
Amount: amount,
}, ""
}
func occupiedSlots(occupancy uint16) []uint {
slots := []uint{}
for slot := uint(0); slot < 16; slot++ {
if occupancy&(uint16(1)<<slot) != 0 {
slots = append(slots, slot)
}
}
return slots
}
func formatOccupancy(occupancy uint16) string {
value := strconv.FormatUint(uint64(occupancy), 16)
return "0000"[:4-len(value)] + value
}
func assertRecipeListPageCount(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) + ")")
}
}