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

gnomod.toml

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

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

lotto.gno

package lotto

import (
	"chain"
	"strconv"

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

const AddNumberEvent = "AddNumber"

var holdings = bptree.NewBPTree32()

// AddNumber increments the holding once per successful call, including retries.
// Only the direct admin or operator caller may register a number. Individual
// ticket identities, issuance times and past round balances are not retained.
func AddNumber(cur realm, owner address, number uint64) {
	accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
	assertValidAddress(owner)
	key := strconv.FormatUint(number, 10) + ":" + owner.String()
	count := uint64(0)
	if current := holdings.Get(key); current != nil {
		count = current.(uint64)
	}
	if count == ^uint64(0) {
		panic("number count overflow")
	}
	count++
	holdings.Set(key, count)
	chain.Emit(
		AddNumberEvent,
		"owner", owner.String(),
		"number", strconv.FormatUint(number, 10),
		"count", strconv.FormatUint(count, 10),
	)
}

func DeleteAll(cur realm) {
	accesscontrol.AssertIsAdmin(0, cur, admin.IsAdmin)
	holdings = bptree.NewBPTree32()
}

// GetNumberCount returns zero when the valid owner has no holding for number.
func GetNumberCount(number uint64, owner address) uint64 {
	assertValidAddress(owner)
	current := holdings.Get(strconv.FormatUint(number, 10) + ":" + owner.String())
	if current == nil {
		return 0
	}
	return current.(uint64)
}

// ListOwnersByNumber returns fresh values in ascending address order. A cursor
// need not be stored. Each row carries the page cursor; an empty cursor or empty
// list ends pagination. Counts are decimal strings to preserve uint64 precision.
// Pages reflect current state, not a historical snapshot.
func ListOwnersByNumber(number uint64, afterOwner string, limit int) []map[string]string {
	if afterOwner != "" {
		assertValidAddress(address(afterOwner))
	}
	assertListLimit(limit)
	numberStr := strconv.FormatUint(number, 10)
	prefix := numberStr + ":"
	start := prefix
	if afterOwner != "" {
		// Valid address strings cannot contain NUL, so this excludes the cursor
		// without visiting it or scanning preceding owners.
		start += afterOwner + "\x00"
	}
	result := make([]map[string]string, 0, limit)
	nextOwner := ""
	holdings.Iterate(start, numberStr+";", func(key string, count any) bool {
		if len(result) == limit {
			nextOwner = result[len(result)-1]["owner"]
			return true
		}
		result = append(result, map[string]string{
			"owner":     key[len(prefix):],
			"count":     strconv.FormatUint(count.(uint64), 10),
			"nextOwner": "",
		})
		return false
	})
	for _, item := range result {
		item["nextOwner"] = nextOwner
	}
	return result
}

lotto_test.gno

package lotto

import (
	"strconv"
	"testing"

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

func TestAddNumber(cur realm, t *testing.T) {
	setupLotto(cross(cur))
	for _, caller := range []address{testAdmin, testOperator} {
		testing.SetOriginCaller(caller)
		testing.SetRealm(testing.NewUserRealm(caller))
		for i := 0; i < 3; i++ {
			AddNumber(cross(cur), testOwner, 123456)
		}
	}
	uassert.Equal(t, GetNumberCount(123456, testOwner), uint64(6))
	uassert.Equal(t, holdings.Size(), 1)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AddNumber(cross(cur), testOther, 123456)
	AddNumber(cross(cur), testOwner, 654321)
	uassert.Equal(t, GetNumberCount(123456, testOwner), uint64(6))
	uassert.Equal(t, GetNumberCount(123456, testOther), uint64(1))
	uassert.Equal(t, GetNumberCount(654321, testOwner), uint64(1))
	uassert.Equal(t, GetNumberCount(654321, testOther), uint64(0))
	uassert.Equal(t, holdings.Size(), 3)
	page := ListOwnersByNumber(123456, "", 100)
	uassert.Equal(t, len(page), 2)
	uassert.Equal(t, page[0]["nextOwner"], "")
	for _, item := range page {
		uassert.Equal(t, item["count"], strconv.FormatUint(GetNumberCount(123456, address(item["owner"])), 10))
	}
}

func TestAddNumberAuthority(cur realm, t *testing.T) {
	setupLotto(cross(cur))
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AddNumber(cross(cur), testOwner, 1)
	for _, caller := range []address{testOwner, testOther} {
		testing.SetOriginCaller(caller)
		testing.SetRealm(testing.NewUserRealm(caller))
		uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
			AddNumber(cross(cur), testOwner, 1)
		})
		uassert.Equal(t, GetNumberCount(1, testOwner), uint64(1))
	}
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	admin.UnsetOperator(cross(cur), testOperator)
	testing.SetOriginCaller(testOperator)
	testing.SetRealm(testing.NewUserRealm(testOperator))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
		AddNumber(cross(cur), testOwner, 1)
	})
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	admin.SetOperator(cross(cur), testOperator)
	for _, signer := range []address{testAdmin, testOperator} {
		testing.SetOriginCaller(signer)
		testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/lotto_relay"))
		uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
			AddNumber(cross(cur), testOwner, 1)
		})
	}
	// Probe the actual helper with a foreign realm, without cross(stale) masking
	// its spoofed-realm assertion with a builtin crossing failure.
	spoofed := cur.Previous()
	uassert.PanicsWithMessage(t, cur, "spoofed realm", func() {
		accesscontrol.MustGetAdminOrOperatorCaller(0, spoofed, admin.IsAdmin, admin.IsOperator)
	})
	uassert.Equal(t, GetNumberCount(1, testOwner), uint64(1))
	uassert.Equal(t, holdings.Size(), 1)
}

func TestAddNumberValidation(cur realm, t *testing.T) {
	setupLotto(cross(cur))
	for _, number := range []uint64{0, ^uint64(0)} {
		testing.SetRealm(testing.NewUserRealm(testAdmin))
		AddNumber(cross(cur), testOwner, number)
		uassert.Equal(t, GetNumberCount(number, testOwner), uint64(1))
		uassert.Equal(t, ListOwnersByNumber(number, "", 1)[0]["owner"], testOwner.String())
	}
	for _, owner := range []address{"", "invalid", address(testOwner.String() + "x")} {
		testing.SetRealm(testing.NewUserRealm(testAdmin))
		uassert.AbortsWithMessage(t, cur, "invalid address", func() {
			AddNumber(cross(cur), owner, 1)
		})
		uassert.PanicsWithMessage(t, cur, "invalid address", func() { GetNumberCount(1, owner) })
		if owner != "" {
			uassert.PanicsWithMessage(t, cur, "invalid address", func() {
				ListOwnersByNumber(1, owner.String(), 1)
			})
		}
	}
	uassert.Equal(t, holdings.Size(), 2)
	// Overflow cannot be reached economically through repeated public calls.
	holdings.Set("1:"+testOwner.String(), ^uint64(0))
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	uassert.AbortsWithMessage(t, cur, "number count overflow", func() {
		AddNumber(cross(cur), testOwner, 1)
	})
	uassert.Equal(t, GetNumberCount(1, testOwner), ^uint64(0))
	uassert.Equal(t, ListOwnersByNumber(1, "", 1)[0]["count"], "18446744073709551615")
	uassert.Equal(t, holdings.Size(), 3)
}

func TestListOwnersByNumber(cur realm, t *testing.T) {
	setupLotto(cross(cur))
	uassert.Equal(t, len(ListOwnersByNumber(1, "", 100)), 0)

	uassert.Equal(t, GetNumberCount(1, testOwner), uint64(0))
	uassert.Equal(t, holdings.Size(), 0)
	for _, limit := range []int{-1, 0, 101} {
		uassert.PanicsWithMessage(t, cur, "limit must be between 1 and 100", func() {
			ListOwnersByNumber(1, "", limit)
		})
	}
	for _, number := range []uint64{1, 10, 100} {
		for i := 0; i < 105; i++ {
			testing.SetRealm(testing.NewUserRealm(testAdmin))
			owner := testutils.TestAddress("lottoPage" + strconv.FormatUint(number, 10) + ":" + strconv.Itoa(i))
			AddNumber(cross(cur), owner, number)
			if i%2 == 0 {
				AddNumber(cross(cur), owner, number)
			}
		}
	}
	for _, number := range []uint64{1, 10, 100} {
		for _, limit := range []int{1, 7, 100} {
			after := ""
			seen := 0
			for {
				page := ListOwnersByNumber(number, after, limit)
				for _, item := range page {
					uassert.True(t, item["owner"] > after)
					uassert.Equal(t, item["nextOwner"], page[0]["nextOwner"])
					uassert.Equal(t, item["count"], strconv.FormatUint(GetNumberCount(number, address(item["owner"])), 10))
					after = item["owner"]
					seen++
				}
				if len(page) == 0 || page[0]["nextOwner"] == "" {
					break
				}
				uassert.Equal(t, len(page), limit)
				uassert.Equal(t, page[0]["nextOwner"], after)
			}
			uassert.Equal(t, seen, 105)
			uassert.Equal(t, len(ListOwnersByNumber(number, after, limit)), 0)
		}
	}
	uassert.Equal(t, holdings.Size(), 315)
	uassert.Equal(t, len(ListOwnersByNumber(1000, "", 100)), 0)
	// A valid cursor between stored owners does not have to be stored itself.
	missing := testutils.TestAddress("lottoMissing").String()
	uassert.Equal(t, GetNumberCount(1, address(missing)), uint64(0))
	first := ListOwnersByNumber(1, "", 100)
	all := append(first, ListOwnersByNumber(1, first[0]["nextOwner"], 100)...)
	expected := []map[string]string{}
	for _, item := range all {
		if item["owner"] > missing {
			expected = append(expected, item)
		}
	}
	page := ListOwnersByNumber(1, missing, 100)
	actual := page
	if len(page) > 0 && page[0]["nextOwner"] != "" {
		actual = append(actual, ListOwnersByNumber(1, page[0]["nextOwner"], 100)...)
	}
	uassert.Equal(t, len(actual), len(expected))
	for i, item := range actual {
		uassert.Equal(t, item["owner"], expected[i]["owner"])
		uassert.Equal(t, item["count"], expected[i]["count"])
	}
	fresh := ListOwnersByNumber(1, "", 1)
	original := map[string]string{"owner": fresh[0]["owner"], "count": fresh[0]["count"]}
	fresh[0]["owner"] = testOther.String()
	fresh[0]["count"] = "999"
	fresh[0]["nextOwner"] = "changed"
	uassert.Equal(t, ListOwnersByNumber(1, "", 1)[0]["owner"], original["owner"])
	uassert.Equal(t, ListOwnersByNumber(1, "", 1)[0]["count"], original["count"])
	uassert.Equal(t, strconv.FormatUint(GetNumberCount(1, address(original["owner"])), 10), original["count"])
	uassert.Equal(t, holdings.Size(), 315)
}

func TestDeleteAll(cur realm, t *testing.T) {
	setupLotto(cross(cur))
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AddNumber(cross(cur), testOwner, 1)
	AddNumber(cross(cur), testOwner, 1)
	AddNumber(cross(cur), testOther, 1)
	AddNumber(cross(cur), testOwner, 2)

	DeleteAll(cross(cur))
	uassert.Equal(t, holdings.Size(), 0)
	for _, number := range []uint64{1, 2} {
		for _, owner := range []address{testOwner, testOther} {
			uassert.Equal(t, GetNumberCount(number, owner), uint64(0))
		}
		uassert.Equal(t, len(ListOwnersByNumber(number, "", 100)), 0)
	}
	DeleteAll(cross(cur))
	// Operators can register again, starting from one instead of the old count.
	testing.SetOriginCaller(testOperator)
	testing.SetRealm(testing.NewUserRealm(testOperator))
	AddNumber(cross(cur), testOwner, 1)
	uassert.Equal(t, GetNumberCount(1, testOwner), uint64(1))
	uassert.Equal(t, holdings.Size(), 1)
	uassert.Equal(t, len(ListOwnersByNumber(1, "", 100)), 1)
}

func TestDeleteAllAuthority(cur realm, t *testing.T) {
	setupLotto(cross(cur))
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AddNumber(cross(cur), testOwner, 1)
	for _, caller := range []address{testOwner, testOperator} {
		testing.SetOriginCaller(caller)
		testing.SetRealm(testing.NewUserRealm(caller))
		uassert.AbortsWithMessage(t, cur, "admin access required", func() {
			DeleteAll(cross(cur))
		})
		uassert.Equal(t, GetNumberCount(1, testOwner), uint64(1))
		uassert.Equal(t, holdings.Size(), 1)
	}
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/lotto_relay"))
	uassert.AbortsWithMessage(t, cur, "admin access required", func() {
		DeleteAll(cross(cur))
	})
	uassert.Equal(t, GetNumberCount(1, testOwner), uint64(1))
	uassert.Equal(t, holdings.Size(), 1)
}

render.gno

package lotto

import (
	"net/url"
	"strconv"
)

func Render(path string) string {
	output := `# AKKADIA Lotto

Look up owners and their quantities for a number.

<gno-form path="number">
  <gno-input name="number" placeholder="Enter a number" />
</gno-form>

`
	u, err := url.Parse(path)
	if err != nil {
		return output + "Invalid URL\n"
	}
	query, err := url.ParseQuery(u.RawQuery)
	if err != nil {
		return output + "Invalid query\n"
	}
	switch u.Path {
	case "":
		return output
	case "number":
		raw := query.Get("number")
		if raw == "" {
			return output + "Number is required\n"
		}
		number, err := strconv.ParseUint(raw, 10, 64)
		if err != nil {
			return output + "Invalid number\n"
		}
		afterOwner := query.Get("afterOwner")
		if afterOwner != "" && !address(afterOwner).IsValid() {
			return output + "Invalid cursor address\n"
		}
		numberStr := strconv.FormatUint(number, 10)
		page := ListOwnersByNumber(number, afterOwner, 20)
		output += "## Number " + numberStr + "\n\n"
		output += "[Home](./lotto:)\n\n"
		if afterOwner != "" {
			output += "[First page](./lotto:number?number=" + numberStr + ")\n\n"
		}
		if len(page) == 0 {
			return output + "No owners on this page.\n"
		}
		output += "| Owner | Count |\n| --- | ---: |\n"
		for _, item := range page {
			// Owners are validated addresses and counts are formatted integers.
			output += "| " + item["owner"] + " | " + item["count"] + " |\n"
		}
		if page[0]["nextOwner"] != "" {
			output += "\n[Next](./lotto:number?number=" + numberStr + "&afterOwner=" + url.QueryEscape(page[0]["nextOwner"]) + ")\n"
		}
		return output
	default:
		return output + "Page not found\n"
	}
}

render_test.gno

package lotto

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

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

func TestRenderInput(cur realm, t *testing.T) {
	setupLotto(cross(cur))
	home := Render("")
	uassert.True(t, strings.Contains(home, "# AKKADIA Lotto"))
	uassert.True(t, strings.Contains(home, `<gno-form path="number">`))
	uassert.True(t, strings.Contains(home, `name="number"`))
	for _, tc := range []struct{ path, message string }{
		{"%", "Invalid URL"},
		{"number?number=%zz", "Invalid query"},
		{"unknown", "Page not found"},
		{"number", "Number is required"},
		{"number?number=-1", "Invalid number"},
		{"number?number=1.5", "Invalid number"},
		{"number?number=18446744073709551616", "Invalid number"},
		{"number?number=" + url.QueryEscape(`<script>alert(1)</script>`), "Invalid number"},
		{"number?number=1&afterOwner=" + url.QueryEscape(`[x](javascript:alert(1))`), "Invalid cursor address"},
		{"number?number=1&afterOwner=invalid", "Invalid cursor address"},
	} {
		result := Render(tc.path)
		uassert.True(t, strings.Contains(result, tc.message))
		uassert.True(t, strings.Contains(result, `<gno-form path="number">`))
		uassert.False(t, strings.Contains(result, "<script>"))
		uassert.False(t, strings.Contains(result, "javascript:"))
	}
	for _, number := range []string{"0", "18446744073709551615"} {
		result := Render("number?number=" + number)
		uassert.True(t, strings.Contains(result, "## Number "+number+"\n"))
		uassert.True(t, strings.Contains(result, "No owners on this page."))
		uassert.False(t, strings.Contains(result, "[Next]"))
	}
	uassert.Equal(t, holdings.Size(), 0)
}

func TestRenderPagination(cur realm, t *testing.T) {
	setupLotto(cross(cur))
	for i := 0; i < 41; i++ {
		testing.SetRealm(testing.NewUserRealm(testAdmin))
		owner := testutils.TestAddress("lottoRender" + strconv.Itoa(i))
		AddNumber(cross(cur), owner, 123)
		AddNumber(cross(cur), owner, 123)
	}
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	AddNumber(cross(cur), testOther, 1234)
	route := "number?number=000123"
	afterOwner := ""
	for _, expectedCount := range []int{20, 20, 1} {
		expected := ListOwnersByNumber(123, afterOwner, 20)
		result := Render(route)
		uassert.True(t, strings.Contains(result, "## Number 123\n"))
		uassert.True(t, strings.Contains(result, "[Home](./lotto:)"))
		uassert.False(t, strings.Contains(result, testOther.String()))
		uassert.Equal(t, strings.Count(result, " | 2 |\n"), expectedCount)
		uassert.Equal(t, strings.Contains(result, "[First page]"), afterOwner != "")
		previous := -1
		for _, item := range expected {
			position := strings.Index(result, "| "+item["owner"]+" | 2 |")
			uassert.True(t, position > previous)
			previous = position
			uassert.Equal(t, GetNumberCount(123, address(item["owner"])), uint64(2))
		}
		if expected[0]["nextOwner"] != "" {
			route = "number?number=123&afterOwner=" + url.QueryEscape(expected[0]["nextOwner"])
			uassert.True(t, strings.Contains(result, "[Next](./lotto:"+route+")"))
			afterOwner = expected[0]["nextOwner"]
		} else {
			uassert.False(t, strings.Contains(result, "[Next]"))
			last := expected[len(expected)-1]["owner"]
			uassert.True(t, strings.Contains(Render("number?number=123&afterOwner="+url.QueryEscape(last)), "No owners on this page."))
		}
	}
	uassert.Equal(t, holdings.Size(), 42)
}

setup_test.gno

package lotto

import (
	"chain"
	"testing"

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

var (
	testAdmin    = testutils.TestAddress("lottoAdmin")
	testOperator = testutils.TestAddress("lottoOperator")
	testOwner    = testutils.TestAddress("lottoOwner")
	testOther    = testutils.TestAddress("lottoOther")
)

// Call with cross(cur); each test resets holdings and restores the operator.
func setupLotto(cur realm) {
	holdings = bptree.NewBPTree32()
	testing.SetOriginSend(chain.Coins{})
	originalAdmin := admin.GetAdmin()
	if originalAdmin != testAdmin {
		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))
	}
	testing.SetOriginCaller(testAdmin)
	testing.SetRealm(testing.NewUserRealm(testAdmin))
	admin.SetOperator(cross(cur), testOperator)
}

validation.gno

package lotto

func assertValidAddress(addr address) {
	if !addr.IsValid() {
		panic("invalid address")
	}
}

func assertListLimit(limit int) {
	if limit < 1 || limit > 100 {
		panic("limit must be between 1 and 100")
	}
}