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 user

import (
	"chain"
	"strconv"

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

const (
	SetListLimitEvent = "SetListLimit"
	SetFrozenEvent    = "SetFrozen"
)

var (
	listLimit int = 100 // Max items per list query
	isFrozen      = true
)

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
}

// SetFrozen controls direct user creation and deletion only.
func SetFrozen(cur realm, frozen bool) {
	accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
	oldFrozen := isFrozen
	isFrozen = frozen
	chain.Emit(
		SetFrozenEvent,
		"oldFrozen", strconv.FormatBool(oldFrozen),
		"newFrozen", strconv.FormatBool(frozen),
	)
}

gnomod.toml

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

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

render.gno

package user

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

	"gno.land/p/jeronimoalbi/pager/v0"
	"gno.land/r/akkadia/beta/admin"
)

// Render handles RESTful routing and returns Markdown responses.
func Render(iUrl string) string {
	assertRenderURLLen(iUrl)
	u, err := url.Parse(iUrl)
	if err != nil {
		return "404\n"
	}

	query := u.Query()

	switch u.Path {
	case "":
		return renderHome()
	case "users":
		return renderUsersList(iUrl)
	case "user":
		addr := address(query.Get("address"))
		return renderUser(iUrl, addr)
	default:
		return renderError("Not found")
	}
}

func renderHome() string {
	output := `# AKKADIA User

## Introduction

User realm stores address-keyed profiles for AKKADIA.

- **created_at**: recorded when the user is created
- **properties**: admin-managed key/value attributes

## Stats

`
	output += "* **Total Users**: " + strconv.Itoa(GetTotalUserSize()) + "\n"
	output += `
## Quick Links

* [Browse Users](./user:users)

## User Lookup

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

func renderUsersList(iUrl string) string {
	output := "# Users\n\n"
	output += "[← Home](./user:)\n\n"

	totalUsers := GetTotalUserSize()
	if totalUsers == 0 {
		output += "*No users registered yet.*\n"
		return output
	}

	pages, err := pager.New(iUrl, totalUsers, pager.WithPageSize(20))
	if err != nil {
		return renderError("Invalid page")
	}

	currentPage := pages.Page()
	addrStrs := ListUsers(currentPage, pages.PageSize())
	for _, addrStr := range addrStrs {
		nickname := ""
		listed := ListUsersByAddresses(address(addrStr))
		if len(listed) > 0 {
			nickname = listed[0]["nickname"]
		}
		if nickname != "" {
			output += "* [" + escapeMarkdown(nickname) + " (" + addrStr + ")](./user:user?address=" + addrStr + "&page=" + strconv.Itoa(currentPage) + ")\n"
		} else {
			output += "* [" + addrStr + "](./user:user?address=" + addrStr + "&page=" + strconv.Itoa(currentPage) + ")\n"
		}
	}

	if pages.HasPages() {
		output += "\n" + pager.Picker(pages)
	}

	return output
}

func renderUser(iUrl string, addr address) string {
	if !addr.IsValid() {
		return renderError("Invalid address")
	}

	u, _ := url.Parse(iUrl)
	page := normalizeRenderPage(u.Query().Get("page"))

	addrStr := addr.String()
	if !HasUser(addr) {
		return renderError("User not found")
	}

	users := ListUsersByAddresses(addr)

	output := "# User Detail\n\n"
	if page != "" {
		output += "[← Back to List](./user:users?page=" + page + ")\n\n"
	} else {
		output += "[← Home](./user:)\n\n"
	}
	output += "* **Address**: " + addrStr + " [[View on Explorer](" + admin.GetExplorerURL() + "/m/explorer/player?address=" + addrStr + ")]\n\n"

	if len(users) > 0 {
		output += "## Properties\n\n"
		for k, v := range users[0] {
			if k == "address" {
				continue
			}
			output += "* **" + escapeMarkdown(k) + "**: " + escapeMarkdown(v) + "\n"
		}
	}

	return output
}

func normalizeRenderPage(rawPage string) string {
	if rawPage == "" {
		return ""
	}
	page, err := strconv.Atoi(rawPage)
	if err != nil || page < 1 {
		return ""
	}
	return strconv.Itoa(page)
}

func renderError(message string) string {
	output := "# Error\n\n"
	output += "> " + message + "\n\n"
	output += "[← Back to Home](./user:)\n"
	return output
}

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

render_test.gno

package user

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

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

func TestRenderEscapesMarkdownSensitiveUserValues(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)

	nickname := "N [x](y) **b**"
	intro := "**bold** [link](https://example.invalid)\n# heading"

	createUserForTest(cross(cur), regularUser)
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AdminUpdateUser(cross(cur), regularUser, "nickname,introduction", url.PathEscape(nickname)+","+url.PathEscape(intro))

	detail := Render("user?address=" + regularUser.String())
	uassert.True(t, strings.Contains(detail, `N \[x\]\(y\) \*\*b\*\*`), "nickname should be escaped")
	uassert.True(t, strings.Contains(detail, `\*\*bold\*\* \[link\]\(https://example\.invalid\)\n\# heading`), "property value should be escaped")
	uassert.False(t, strings.Contains(detail, "[link](https://example.invalid)"), "property link syntax should not remain raw")
	uassert.False(t, strings.Contains(detail, "\n# heading"), "property newline heading should not remain raw")

	list := Render("users")
	uassert.True(t, strings.Contains(list, `N \[x\]\(y\) \*\*b\*\*`), "list nickname should be escaped")
	uassert.False(t, strings.Contains(list, "[profile](profile-page)"), "list nickname link syntax should not remain raw")
}

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

	invalid := Render("user?address=invalid-address")
	uassert.True(t, strings.Contains(invalid, "Invalid address"), "render output should contain expected error")

	missing := Render("user?address=" + regularUser.String())
	uassert.True(t, strings.Contains(missing, "User not found"), "missing user should render not found")

	unknown := Render("nickname?nickname=alice")
	uassert.True(t, strings.Contains(unknown, "Not found"), "removed nickname route should 404")
}

func TestRenderUserSanitizesPageLink(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	createUserForTest(cross(cur), regularUser)

	valid := Render("user?address=" + regularUser.String() + "&page=02")
	uassert.True(t, strings.Contains(valid, "[← Back to List](./user:users?page=2)"), "valid page should be normalized")

	injected := Render("user?address=" + regularUser.String() + "&page=1%29%5D%28https%3A%2F%2Fexample.invalid%29")
	uassert.False(t, strings.Contains(injected, "example.invalid"), "invalid page should not be reflected")
	uassert.False(t, strings.Contains(injected, "users?page="), "invalid page should not render a page back link")
	uassert.True(t, strings.Contains(injected, "[← Home](./user:)"), "invalid page should fall back to home link")
}

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

func TestRenderHomeUsesRelativeBrowseUsersLink(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)

	output := Render("")

	uassert.True(t, strings.Contains(output, "* [Browse Users](./user:users)"), "should use package-relative users link")
	uassert.False(t, strings.Contains(output, "* [Browse Users](users)"), "should not use path-relative users link")
	uassert.False(t, strings.Contains(output, "* [Browse Users](/r/akkadia/user:users)"), "should not use absolute users link")
}

user.gno

package user

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

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

const (
	CreateUserEvent = "CreateUser"
	UpdateUserEvent = "UpdateUser"
	DeleteUserEvent = "DeleteUser"

	createdAtKey = "created_at"
)

// users is address string -> map[string]string.
// The zero value is an empty BPTree with fanout 32.
var users bptree.BPTree

func HasUser(addr address) bool {
	assertIsValidAddress(addr)
	return users.Has(addr.String())
}

func CreateUser(cur realm) {
	addr := accesscontrol.MustGetUserCaller(0, cur)
	if isFrozen {
		panic("user self-service is frozen")
	}
	addrStr := addr.String()
	if users.Has(addrStr) {
		panic("user already exists: " + addrStr)
	}
	users.Set(addrStr, map[string]string{
		createdAtKey: strconv.FormatInt(time.Now().Unix(), 10),
	})
	chain.Emit(CreateUserEvent, "address", addrStr)
}

// AdminCreateUser is idempotent so an operator can safely retry registration.
func AdminCreateUser(cur realm, addr address) {
	accesscontrol.AssertIsAdminOrOperator(0, cur, admin.IsAdmin, admin.IsOperator)
	assertIsValidAddress(addr)
	addrStr := addr.String()
	if users.Has(addrStr) {
		return
	}
	users.Set(addrStr, map[string]string{
		createdAtKey: strconv.FormatInt(time.Now().Unix(), 10),
	})
	chain.Emit(CreateUserEvent, "address", addrStr)
}

func DeleteUser(cur realm) {
	addr := accesscontrol.MustGetUserCaller(0, cur)
	if isFrozen {
		panic("user self-service is frozen")
	}
	deleteUser(addr)
}

func AdminDeleteUser(cur realm, addr address) {
	accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
	assertIsValidAddress(addr)
	deleteUser(addr)
}

// DeleteAll removes registrations while preserving freeze and list settings.
func DeleteAll(cur realm) {
	accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
	users = bptree.BPTree{}
}

func AdminUpdateUser(cur realm, addr address, propKeys, propValues string) {
	accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
	assertIsValidAddress(addr)
	addrStr := addr.String()
	current := users.Get(addrStr)
	if current == nil {
		panic("user not found: " + addrStr)
	}
	props := copyStringMap(current.(map[string]string))
	updates := parsePropertiesCSV(propKeys, propValues)
	for key, value := range updates {
		props[key] = value
	}
	users.Set(addrStr, props)
	chain.Emit(UpdateUserEvent, "address", addrStr)
}

func GetTotalUserSize() int {
	return users.Size()
}

func ListUsers(page, count int) []string {
	assertListPageCount(page, count)
	result := []string{}
	offset := (page - 1) * count
	users.IterateByOffset(offset, count, func(key string, _ any) bool {
		result = append(result, key)
		return false
	})
	return result
}

func ListUsersByAddresses(addrs ...address) []map[string]string {
	assertListLimit("addrs", len(addrs))
	result := []map[string]string{}
	for _, addr := range addrs {
		assertIsValidAddress(addr)
		addrStr := addr.String()
		current := users.Get(addrStr)
		if current == nil {
			continue
		}
		props := copyStringMap(current.(map[string]string))
		props["address"] = addrStr
		result = append(result, props)
	}
	return result
}

func deleteUser(addr address) {
	addrStr := addr.String()
	if _, removed := users.Remove(addrStr); !removed {
		panic("user not found: " + addrStr)
	}
	chain.Emit(DeleteUserEvent, "address", addrStr)
}

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

// parsePropertiesCSV accepts comma-separated keys and comma-separated values.
// Each value must be URL-encoded so commas and other separators can be carried
// safely; this parser URL-decodes values before returning the map.
func parsePropertiesCSV(keys, values string) map[string]string {
	if keys == "" {
		panic("properties keys must be not empty")
	}

	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("properties key must be not empty")
		}
		if _, found := result[key]; found {
			panic("properties key duplicated: " + key)
		}

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

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

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

	return result
}

func assertIsValidAddress(addr address) {
	if !addr.IsValid() {
		panic("invalid address: " + addr.String())
	}
}

func assertListLimit(field string, count int) {
	if count > listLimit {
		panic(field + " exceeds listLimit (max: " + strconv.Itoa(listLimit) + ")")
	}
}

func assertListPageCount(page int, count int) {
	if page < 1 {
		panic("page must be at least 1")
	}
	if count < 1 {
		panic("count must be at least 1")
	}
	assertListLimit("count", count)
}

user_test.gno

package user

import (
	"testing"
	"time"

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

var (
	testAdmin   = testutils.TestAddress("testAdmin")
	regularUser = testutils.TestAddress("regularUser")
	badUser     = testutils.TestAddress("badUser")
	anotherUser = testutils.TestAddress("anotherUser")
	setupDone   = false
)

func setupUserTests(cur realm, t *testing.T) {
	t.Helper()
	users = bptree.BPTree{}
	listLimit = 100
	isFrozen = true

	if setupDone {
		return
	}
	originalAdmin := admin.GetAdmin()
	testing.SetOriginCaller(originalAdmin)
	testing.SetRealm(testing.NewUserRealm(originalAdmin))
	admin.TransferAdmin(cross(cur), testAdmin)

	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	admin.AcceptAdmin(cross(cur))
	setupDone = true
}

func createUserForTest(cur realm, addr address) {
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AdminCreateUser(cross(cur), addr)
}

func TestParsePropertiesCSV(cur realm, t *testing.T) {
	props := parsePropertiesCSV("nickname,introduction", "Alice,hello%2C%20world")
	uassert.Equal(t, "Alice", props["nickname"])
	uassert.Equal(t, "hello, world", props["introduction"])

	props = parsePropertiesCSV("nickname,introduction", "Alice,")
	uassert.Equal(t, "", props["introduction"])

	uassert.PanicsWithMessage(t, cur, "properties keys must be not empty", func() {
		parsePropertiesCSV("", "")
	})
	uassert.PanicsWithMessage(t, cur, "properties key duplicated: nickname", func() {
		parsePropertiesCSV("nickname,nickname", "Alice,Bob")
	})
	uassert.PanicsWithMessage(t, cur, "properties keys and values count mismatch", func() {
		parsePropertiesCSV("nickname,introduction", "Alice")
	})
	uassert.PanicsWithMessage(t, cur, "properties value URL decode failed: introduction", func() {
		parsePropertiesCSV("nickname,introduction", "Alice,%zz")
	})
}

func TestCreateUser(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	SetFrozen(cross(cur), false)
	testing.SetOriginCaller(regularUser)
	testing.SetRealm(testing.NewUserRealm(regularUser))
	CreateUser(cross(cur))
	uassert.True(t, HasUser(regularUser))
	uassert.False(t, HasUser(testAdmin))
	uassert.Equal(t, 1, GetTotalUserSize())
	createdAt := ListUsersByAddresses(regularUser)[0][createdAtKey]
	uassert.True(t, createdAt != "")
	uassert.AbortsWithMessage(t, cur, "user already exists: "+regularUser.String(), func() {
		CreateUser(cross(cur))
	})
	uassert.Equal(t, createdAt, ListUsersByAddresses(regularUser)[0][createdAtKey])
	// Operator delivery after self-registration remains a safe no-op.
	createUserForTest(cross(cur), regularUser)
	uassert.Equal(t, 1, GetTotalUserSize())
	uassert.Equal(t, createdAt, ListUsersByAddresses(regularUser)[0][createdAtKey])
}

func TestCreateUserRejectsCodeRealm(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	SetFrozen(cross(cur), false)
	testing.SetOriginCaller(regularUser)
	testing.SetRealm(testing.NewCodeRealm("gno.land/r/akkadia/beta/user_relay"))
	uassert.AbortsWithMessage(t, cur, "contract calls not allowed: function must be called directly by user", func() {
		CreateUser(cross(cur))
	})
	uassert.Equal(t, 0, GetTotalUserSize())
}

func TestAdminCreateUser(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)

	createUserForTest(cross(cur), regularUser)
	uassert.True(t, HasUser(regularUser))
	uassert.Equal(t, 1, GetTotalUserSize())
	usersByAddr := ListUsersByAddresses(regularUser)
	uassert.Equal(t, 1, len(usersByAddr))
	uassert.Equal(t, regularUser.String(), usersByAddr[0]["address"])
	uassert.True(t, usersByAddr[0][createdAtKey] != "")

	createdAt := usersByAddr[0][createdAtKey]
	ctx := testing.GetContext()
	ctx.Time = ctx.Time.Add(time.Hour)
	testing.SetContext(ctx)
	createUserForTest(cross(cur), regularUser)
	uassert.Equal(t, 1, GetTotalUserSize())
	uassert.Equal(t, createdAt, ListUsersByAddresses(regularUser)[0][createdAtKey])
}

func TestAdminCreateUserOperator(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	admin.SetOperator(cross(cur), anotherUser)
	testing.SetOriginCaller(anotherUser)
	testing.SetRealm(testing.NewUserRealm(anotherUser))
	AdminCreateUser(cross(cur), regularUser)
	uassert.True(t, HasUser(regularUser))
	uassert.False(t, HasUser(anotherUser))
	uassert.Equal(t, 1, GetTotalUserSize())
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	admin.UnsetOperator(cross(cur), anotherUser)
}

func TestAdminCreateUserRejectsUnauthorizedAndInvalidAddress(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	createUserForTest(cross(cur), regularUser)
	testing.SetOriginCaller(regularUser)
	testing.SetRealm(testing.NewUserRealm(regularUser))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
		AdminCreateUser(cross(cur), anotherUser)
	})
	// Authorization must run even when the target already exists.
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
		AdminCreateUser(cross(cur), regularUser)
	})
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewCodeRealm("gno.land/r/akkadia/beta/user_relay"))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
		AdminCreateUser(cross(cur), anotherUser)
	})
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	uassert.AbortsWithMessage(t, cur, "invalid address: "+address("").String(), func() {
		AdminCreateUser(cross(cur), address(""))
	})
	uassert.True(t, HasUser(regularUser))
	uassert.False(t, HasUser(anotherUser))
	uassert.Equal(t, 1, GetTotalUserSize())
}

func TestDeleteUser(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	SetFrozen(cross(cur), false)
	createUserForTest(cross(cur), regularUser)

	testing.SetOriginCaller(regularUser)
	testing.SetRealm(testing.NewUserRealm(regularUser))
	DeleteUser(cross(cur))
	uassert.False(t, HasUser(regularUser))
	uassert.Equal(t, 0, GetTotalUserSize())

	uassert.AbortsWithMessage(t, cur, "user not found: "+regularUser.String(), func() {
		DeleteUser(cross(cur))
	})
}

func TestAdminDeleteUser(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	createUserForTest(cross(cur), regularUser)

	testing.SetOriginCaller(regularUser)
	testing.SetRealm(testing.NewUserRealm(regularUser))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		AdminDeleteUser(cross(cur), regularUser)
	})

	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AdminDeleteUser(cross(cur), regularUser)
	uassert.False(t, HasUser(regularUser))

	uassert.AbortsWithMessage(t, cur, "user not found: "+regularUser.String(), func() {
		AdminDeleteUser(cross(cur), regularUser)
	})
}

func TestAdminUpdateUser(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	createUserForTest(cross(cur), regularUser)
	createdAt := ListUsersByAddresses(regularUser)[0][createdAtKey]

	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AdminUpdateUser(cross(cur), regularUser, "nickname,introduction", "Alice,hello%2C%20world")
	listed := ListUsersByAddresses(regularUser)[0]
	uassert.Equal(t, "Alice", listed["nickname"])
	uassert.Equal(t, "hello, world", listed["introduction"])
	uassert.Equal(t, createdAt, listed[createdAtKey])

	AdminUpdateUser(cross(cur), regularUser, createdAtKey, "1")
	uassert.Equal(t, "1", ListUsersByAddresses(regularUser)[0][createdAtKey])
	uassert.Equal(t, "Alice", ListUsersByAddresses(regularUser)[0]["nickname"])
}

func TestAdminUpdateUserRejectsMissingAndUnauthorized(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)

	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	uassert.AbortsWithMessage(t, cur, "user not found: "+regularUser.String(), func() {
		AdminUpdateUser(cross(cur), regularUser, "nickname", "Alice")
	})

	createUserForTest(cross(cur), regularUser)
	testing.SetOriginCaller(regularUser)
	testing.SetRealm(testing.NewUserRealm(regularUser))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		AdminUpdateUser(cross(cur), regularUser, "nickname", "Alice")
	})

	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewCodeRealm("gno.land/r/akkadia/beta/user_admin_relay"))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		AdminUpdateUser(cross(cur), regularUser, "nickname", "Alice")
	})
}

func TestListUsersAddressOrder(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	createUserForTest(cross(cur), regularUser)
	createUserForTest(cross(cur), anotherUser)

	listed := ListUsers(1, 10)
	uassert.Equal(t, 2, len(listed))
	if regularUser.String() < anotherUser.String() {
		uassert.Equal(t, regularUser.String(), listed[0])
		uassert.Equal(t, anotherUser.String(), listed[1])
	} else {
		uassert.Equal(t, anotherUser.String(), listed[0])
		uassert.Equal(t, regularUser.String(), listed[1])
	}

	firstPage := ListUsers(1, 1)
	uassert.Equal(t, 1, len(firstPage))
	uassert.Equal(t, listed[0], firstPage[0])
	secondPage := ListUsers(2, 1)
	uassert.Equal(t, listed[1], secondPage[0])
}

func TestListUsersByAddresses(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	createUserForTest(cross(cur), regularUser)
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AdminUpdateUser(cross(cur), regularUser, "nickname", "Alice")

	listed := ListUsersByAddresses(regularUser, badUser)
	uassert.Equal(t, 1, len(listed))
	uassert.Equal(t, "Alice", listed[0]["nickname"])
	listed[0]["nickname"] = "mutated"
	again := ListUsersByAddresses(regularUser)
	uassert.Equal(t, "Alice", again[0]["nickname"])
}

func TestListInputValidation(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	uassert.PanicsWithMessage(t, cur, "page must be at least 1", func() {
		ListUsers(0, 1)
	})
	uassert.PanicsWithMessage(t, cur, "count must be at least 1", func() {
		ListUsers(1, 0)
	})
	uassert.PanicsWithMessage(t, cur, "count exceeds listLimit (max: 100)", func() {
		ListUsers(1, 101)
	})
	uassert.PanicsWithMessage(t, cur, "invalid address: "+address("").String(), func() {
		HasUser(address(""))
	})
	uassert.Equal(t, 100, GetListLimit())
}

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

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

	SetListLimit(cross(cur), 1)
	uassert.PanicsWithMessage(t, cur, "addrs exceeds listLimit (max: 1)", func() {
		ListUsersByAddresses(regularUser, badUser)
	})
	uassert.PanicsWithMessage(t, cur, "count exceeds listLimit (max: 1)", func() {
		ListUsers(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(regularUser)
	testing.SetRealm(testing.NewUserRealm(regularUser))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		SetListLimit(cross(cur), 50)
	})

	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewCodeRealm("gno.land/r/akkadia/beta/user_admin_relay"))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		SetListLimit(cross(cur), 50)
	})
}

func TestSelfServiceFrozen(cur realm, t *testing.T) {
	uassert.True(t, isFrozen)
	setupUserTests(cross(cur), t)
	createUserForTest(cross(cur), regularUser)
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AdminUpdateUser(cross(cur), regularUser, "nickname", "Alice")
	before := ListUsersByAddresses(regularUser)

	testing.SetOriginCaller(anotherUser)
	testing.SetRealm(testing.NewUserRealm(anotherUser))
	uassert.AbortsWithMessage(t, cur, "user self-service is frozen", func() {
		CreateUser(cross(cur))
	})
	uassert.False(t, HasUser(anotherUser))
	testing.SetOriginCaller(regularUser)
	testing.SetRealm(testing.NewUserRealm(regularUser))
	uassert.AbortsWithMessage(t, cur, "user self-service is frozen", func() {
		DeleteUser(cross(cur))
	})
	uassert.Equal(t, before[0][createdAtKey], ListUsersByAddresses(regularUser)[0][createdAtKey])
	uassert.Equal(t, "Alice", ListUsersByAddresses(regularUser)[0]["nickname"])
	uassert.Equal(t, 1, GetTotalUserSize())

	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	SetFrozen(cross(cur), false)
	testing.SetOriginCaller(anotherUser)
	testing.SetRealm(testing.NewUserRealm(anotherUser))
	CreateUser(cross(cur))
	uassert.True(t, HasUser(anotherUser))
	DeleteUser(cross(cur))
	uassert.False(t, HasUser(anotherUser))

	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	SetFrozen(cross(cur), true)
	testing.SetOriginCaller(anotherUser)
	testing.SetRealm(testing.NewUserRealm(anotherUser))
	uassert.AbortsWithMessage(t, cur, "user self-service is frozen", func() {
		CreateUser(cross(cur))
	})
	testing.SetOriginCaller(regularUser)
	testing.SetRealm(testing.NewUserRealm(regularUser))
	uassert.AbortsWithMessage(t, cur, "user self-service is frozen", func() {
		DeleteUser(cross(cur))
	})
	uassert.Equal(t, before[0][createdAtKey], ListUsersByAddresses(regularUser)[0][createdAtKey])
	uassert.Equal(t, "Alice", ListUsersByAddresses(regularUser)[0]["nickname"])
	uassert.Equal(t, 1, GetTotalUserSize())
}

func TestSetFrozenRejectsUnauthorized(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	admin.SetOperator(cross(cur), anotherUser)

	for _, frozen := range []bool{true, false} {
		testing.SetOriginCaller(testAdmin)
		testing.SetRealm(testing.NewUserRealm(testAdmin))
		SetFrozen(cross(cur), frozen)
		for _, caller := range []address{regularUser, anotherUser} {
			testing.SetOriginCaller(caller)
			testing.SetRealm(testing.NewUserRealm(caller))
			uassert.AbortsWithMessage(t, cur, "admin access required", func() {
				SetFrozen(cross(cur), !frozen)
			})
			uassert.Equal(t, frozen, isFrozen)
		}
		testing.SetOriginCaller(testAdmin)
		testing.SetRealm(testing.NewCodeRealm("gno.land/r/akkadia/beta/user_admin_relay"))
		uassert.AbortsWithMessage(t, cur, "admin access required", func() {
			SetFrozen(cross(cur), !frozen)
		})
		uassert.Equal(t, frozen, isFrozen)
	}
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	admin.UnsetOperator(cross(cur), anotherUser)
	SetFrozen(cross(cur), true)
}

func TestDeleteAll(cur realm, t *testing.T) {
	for _, frozen := range []bool{true, false} {
		setupUserTests(cross(cur), t)
		createUserForTest(cross(cur), regularUser)
		createUserForTest(cross(cur), anotherUser)
		testing.SetOriginCaller(testAdmin)
		testing.SetRealm(testing.NewUserRealm(testAdmin))
		AdminUpdateUser(cross(cur), regularUser, "nickname", "Alice")
		SetListLimit(cross(cur), 7)
		SetFrozen(cross(cur), frozen)

		DeleteAll(cross(cur))
		uassert.Equal(t, 0, GetTotalUserSize())
		uassert.False(t, HasUser(regularUser))
		uassert.False(t, HasUser(anotherUser))
		uassert.Equal(t, 0, len(ListUsers(1, 7)))
		uassert.Equal(t, 0, len(ListUsersByAddresses(regularUser, anotherUser)))
		uassert.Equal(t, 7, GetListLimit())
		uassert.Equal(t, frozen, isFrozen)
		// Empty resets are safe, and re-registration must not restore old properties.
		DeleteAll(cross(cur))
		AdminCreateUser(cross(cur), regularUser)
		uassert.Equal(t, 1, GetTotalUserSize())
		uassert.True(t, HasUser(regularUser))
		props := ListUsersByAddresses(regularUser)[0]
		uassert.Equal(t, "", props["nickname"])
		uassert.True(t, props[createdAtKey] != "")
	}
}

func TestDeleteAllAuthority(cur realm, t *testing.T) {
	setupUserTests(cross(cur), t)
	createUserForTest(cross(cur), regularUser)
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AdminUpdateUser(cross(cur), regularUser, "nickname", "Alice")
	admin.SetOperator(cross(cur), anotherUser)
	for _, caller := range []address{regularUser, anotherUser} {
		testing.SetOriginCaller(caller)
		testing.SetRealm(testing.NewUserRealm(caller))
		uassert.AbortsWithMessage(t, cur, "admin access required", func() {
			DeleteAll(cross(cur))
		})
		uassert.Equal(t, 1, GetTotalUserSize())
		uassert.Equal(t, "Alice", ListUsersByAddresses(regularUser)[0]["nickname"])
	}
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewCodeRealm("gno.land/r/akkadia/beta/user_admin_relay"))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		DeleteAll(cross(cur))
	})
	uassert.Equal(t, 1, GetTotalUserSize())
	uassert.Equal(t, "Alice", ListUsersByAddresses(regularUser)[0]["nickname"])
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	admin.UnsetOperator(cross(cur), anotherUser)
}

validation.gno

package user

import "unicode/utf8"

const renderURLMaxRunes = 1024

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