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

abt.gno

package abt

import (
	"chain"
	"chain/runtime/unsafe"
	"strconv"

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

const FrozenChangedEvent = "FrozenChanged"

var (
	// Even a Token can create mutable tellers; keep all capabilities private.
	token  *grc20.Token
	ledger *grc20.PrivateLedger
	frozen = true
)

func init(cur realm) {
	token, ledger = grc20.NewToken("Akkadia Beta Token", "abt", 6, 0, cur)
}

// Mint remains available while frozen. Each successful call issues new tokens.
func Mint(cur realm, to address, amount int64) {
	accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
	assertNoCoins(0, cur)
	if !to.IsValid() {
		panic("invalid abt recipient")
	}
	if amount <= 0 {
		panic("abt amount must be positive")
	}
	if err := ledger.Mint(to, amount); err != nil {
		panic("abt mint failed: " + err.Error())
	}
}

// SetFrozen preserves existing allowances, which become usable after unfreezing.
func SetFrozen(cur realm, value bool) {
	caller := accesscontrol.MustGetAdminCaller(0, cur, admin.IsAdmin)
	assertNoCoins(0, cur)
	if frozen == value {
		return
	}
	previous := frozen
	frozen = value
	chain.Emit(FrozenChangedEvent,
		"executor", caller.String(),
		"previous", strconv.FormatBool(previous),
		"frozen", strconv.FormatBool(frozen),
	)
}

func Transfer(cur realm, to address, amount int64) {
	assertCanTransfer(0, cur)
	if err := ledger.CallerTeller().Transfer(0, cur, to, amount); err != nil {
		panic("abt transfer failed: " + err.Error())
	}
}

// Approve also rejects allowance revocation while frozen.
func Approve(cur realm, spender address, amount int64) {
	assertCanTransfer(0, cur)
	if err := ledger.CallerTeller().Approve(0, cur, spender, amount); err != nil {
		panic("abt approval failed: " + err.Error())
	}
}

func TransferFrom(cur realm, from, to address, amount int64) {
	assertCanTransfer(0, cur)
	// The library spends allowance before rejecting self-transfers. Reject
	// here so even a caller that revives the abort cannot consume allowance.
	if from == to {
		panic("abt transfer failed: cannot send transfer to self")
	}
	if err := ledger.CallerTeller().TransferFrom(0, cur, from, to, amount); err != nil {
		panic("abt transfer failed: " + err.Error())
	}
}

func IsFrozen() bool                         { return frozen }
func GetName() string                        { return token.GetName() }
func GetSymbol() string                      { return token.GetSymbol() }
func GetDecimals() int                       { return token.GetDecimals() }
func TotalSupply() int64                     { return token.TotalSupply() }
func BalanceOf(owner address) int64          { return token.BalanceOf(owner) }
func Allowance(owner, spender address) int64 { return token.Allowance(owner, spender) }

func assertCanTransfer(_ int, rlm realm) {
	accesscontrol.AssertCurrentRealm(0, rlm)
	assertNoCoins(0, rlm)
	if frozen {
		panic("abt is frozen")
	}
}

func assertNoCoins(_ int, rlm realm) {
	// OriginSend belongs to the origin call, not a subsequent realm relay.
	if rlm.Previous().IsUser() && len(unsafe.OriginSend()) != 0 {
		panic("attached coins not allowed")
	}
}

abt_test.gno

package abt

import (
	"math"
	"testing"

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

func TestInitialState(t *testing.T) {
	uassert.Equal(t, "Akkadia Beta Token", GetName())
	uassert.Equal(t, "abt", GetSymbol())
	uassert.Equal(t, 6, GetDecimals())
	uassert.Equal(t, "gno.land/r/akkadia/beta/abt.abt.0000000", token.ID())
	uassert.True(t, IsFrozen())
	uassert.Equal(t, int64(0), TotalSupply())
	uassert.Equal(t, int64(0), BalanceOf(abtTest.Owner))
	uassert.Equal(t, int64(0), Allowance(abtTest.Owner, abtTest.Other))
}

func TestMintWhileFrozen(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	for _, caller := range []address{abtTest.Admin, abtTest.Operator} {
		testing.SetOriginCaller(caller)
		testing.SetRealm(testing.NewUserRealm(caller))
		Mint(cross(cur), abtTest.Owner, 100)
		Mint(cross(cur), abtTest.Other, 10)
	}
	uassert.True(t, IsFrozen())
	uassert.Equal(t, int64(220), TotalSupply())
	uassert.Equal(t, int64(200), BalanceOf(abtTest.Owner))
	uassert.Equal(t, int64(20), BalanceOf(abtTest.Other))
	uassert.Equal(t, int64(0), Allowance(abtTest.Owner, abtTest.Other))
}

func TestMintInvalidInput(cur realm, t *testing.T) {
	cases := []struct {
		name     string
		to       address
		amount   int64
		panicMsg string
	}{
		{"empty address", address(""), 1, "invalid abt recipient"},
		{"invalid address", address("invalid"), 1, "invalid abt recipient"},
		{"zero", abtTest.Owner, 0, "abt amount must be positive"},
		{"negative", abtTest.Owner, -1, "abt amount must be positive"},
		{"minimum int64", abtTest.Owner, math.MinInt64, "abt amount must be positive"},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(cur realm, t *testing.T) {
			setupABT(cross(cur), t)
			testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
			Mint(cross(cur), abtTest.Owner, 7)
			uassert.AbortsWithMessage(t, cur, tc.panicMsg, func() {
				Mint(cross(cur), tc.to, tc.amount)
			})
			uassert.Equal(t, int64(7), TotalSupply())
			uassert.Equal(t, int64(7), BalanceOf(abtTest.Owner))
			uassert.Equal(t, int64(0), BalanceOf(abtTest.Other))
		})
	}
}

func TestMintOverflow(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	Mint(cross(cur), abtTest.Owner, math.MaxInt64)
	for _, to := range []address{abtTest.Owner, abtTest.Other} {
		uassert.AbortsWithMessage(t, cur, "abt mint failed: mint overflow", func() {
			Mint(cross(cur), to, 1)
		})
	}
	uassert.Equal(t, int64(math.MaxInt64), TotalSupply())
	uassert.Equal(t, int64(math.MaxInt64), BalanceOf(abtTest.Owner))
	uassert.Equal(t, int64(0), BalanceOf(abtTest.Other))
}

func TestFreezeLifecycle(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	Mint(cross(cur), abtTest.Owner, 100)
	SetFrozen(cross(cur), true)
	SetFrozen(cross(cur), false)
	SetFrozen(cross(cur), false)
	Mint(cross(cur), abtTest.Owner, 5)
	testing.SetOriginCaller(abtTest.Owner)
	testing.SetRealm(testing.NewUserRealm(abtTest.Owner))
	Transfer(cross(cur), abtTest.Other, 10)
	Approve(cross(cur), abtTest.Other, 40)
	testing.SetOriginCaller(abtTest.Other)
	testing.SetRealm(testing.NewUserRealm(abtTest.Other))
	TransferFrom(cross(cur), abtTest.Owner, abtTest.Admin, 15)
	uassert.Equal(t, int64(80), BalanceOf(abtTest.Owner))
	uassert.Equal(t, int64(10), BalanceOf(abtTest.Other))
	uassert.Equal(t, int64(15), BalanceOf(abtTest.Admin))
	uassert.Equal(t, int64(25), Allowance(abtTest.Owner, abtTest.Other))
	testing.SetOriginCaller(abtTest.Admin)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	SetFrozen(cross(cur), true)
	testing.SetOriginCaller(abtTest.Owner)
	testing.SetRealm(testing.NewUserRealm(abtTest.Owner))
	uassert.AbortsWithMessage(t, cur, "abt is frozen", func() { Approve(cross(cur), abtTest.Other, 0) })
	uassert.AbortsWithMessage(t, cur, "abt is frozen", func() { Transfer(cross(cur), abtTest.Other, 1) })
	testing.SetOriginCaller(abtTest.Other)
	testing.SetRealm(testing.NewUserRealm(abtTest.Other))
	uassert.AbortsWithMessage(t, cur, "abt is frozen", func() {
		TransferFrom(cross(cur), abtTest.Owner, abtTest.Admin, 25)
	})
	uassert.Equal(t, int64(25), Allowance(abtTest.Owner, abtTest.Other))
	uassert.Equal(t, int64(80), BalanceOf(abtTest.Owner))
	uassert.Equal(t, int64(105), TotalSupply())
	testing.SetOriginCaller(abtTest.Admin)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	SetFrozen(cross(cur), false)
	testing.SetOriginCaller(abtTest.Other)
	testing.SetRealm(testing.NewUserRealm(abtTest.Other))
	TransferFrom(cross(cur), abtTest.Owner, abtTest.Admin, 25)
	uassert.Equal(t, int64(0), Allowance(abtTest.Owner, abtTest.Other))
	uassert.Equal(t, int64(55), BalanceOf(abtTest.Owner))
	uassert.Equal(t, int64(40), BalanceOf(abtTest.Admin))
	uassert.Equal(t, int64(105), TotalSupply())
	testing.SetOriginCaller(abtTest.Owner)
	testing.SetRealm(testing.NewUserRealm(abtTest.Owner))
	Approve(cross(cur), abtTest.Other, 5)
	Approve(cross(cur), abtTest.Other, 7)
	uassert.Equal(t, int64(7), Allowance(abtTest.Owner, abtTest.Other))
	Approve(cross(cur), abtTest.Other, 0)
	uassert.Equal(t, int64(0), Allowance(abtTest.Owner, abtTest.Other))
}

func TestMintRoleChanges(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	admin.UnsetOperator(cross(cur), abtTest.Operator)
	testing.SetOriginCaller(abtTest.Operator)
	testing.SetRealm(testing.NewUserRealm(abtTest.Operator))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() { Mint(cross(cur), abtTest.Owner, 1) })
	testing.SetOriginCaller(abtTest.Admin)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	admin.TransferAdmin(cross(cur), abtTest.Other)
	testing.SetOriginCaller(abtTest.Other)
	testing.SetRealm(testing.NewUserRealm(abtTest.Other))
	admin.AcceptAdmin(cross(cur))
	Mint(cross(cur), abtTest.Owner, 3)
	SetFrozen(cross(cur), false)
	testing.SetOriginCaller(abtTest.Admin)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() { Mint(cross(cur), abtTest.Owner, 1) })
	uassert.AbortsWithMessage(t, cur, "admin access required", func() { SetFrozen(cross(cur), true) })
	uassert.Equal(t, int64(3), TotalSupply())
	uassert.False(t, IsFrozen())
}

external_test.gno

package abt_test

import (
	"chain"
	"chain/runtime"
	"testing"

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

func TestExternalWrapperLifecycle(cur realm, t *testing.T) {
	caller := testutils.TestAddress("abtExternalAdmin")
	owner := testutils.TestAddress("abtExternalOwner")
	other := testutils.TestAddress("abtExternalOther")
	testing.SetOriginCaller(admin.GetAdmin())
	testing.SetRealm(testing.NewUserRealm(admin.GetAdmin()))
	admin.TransferAdmin(cross(cur), caller)
	testing.SetOriginCaller(caller)
	testing.SetRealm(testing.NewUserRealm(caller))
	admin.AcceptAdmin(cross(cur))
	testing.SetOriginSend(chain.Coins{})
	testing.SetRealm(runtime.NewRealm(caller, "gno.land/e/"+caller.String()+"/run"))
	abt.SetFrozen(cross(cur), true)
	supplyBefore := abt.TotalSupply()
	abt.Mint(cross(cur), owner, 20)
	uassert.Equal(t, "Akkadia Beta Token", abt.GetName())
	uassert.Equal(t, "abt", abt.GetSymbol())
	uassert.Equal(t, 6, abt.GetDecimals())
	uassert.Equal(t, supplyBefore+20, abt.TotalSupply())
	uassert.True(t, abt.IsFrozen())
	abt.SetFrozen(cross(cur), false)
	testing.SetOriginCaller(owner)
	testing.SetRealm(testing.NewUserRealm(owner))
	abt.Transfer(cross(cur), other, 2)
	abt.Approve(cross(cur), other, 5)
	testing.SetOriginCaller(other)
	testing.SetRealm(testing.NewUserRealm(other))
	abt.TransferFrom(cross(cur), owner, other, 3)
	uassert.Equal(t, int64(15), abt.BalanceOf(owner))
	uassert.Equal(t, int64(5), abt.BalanceOf(other))
	uassert.Equal(t, int64(2), abt.Allowance(owner, other))
	uassert.Equal(t, "15", abt.Render("balance/"+owner.String()))
	// A later failing transfer must preserve allowance even if its abort is caught.
	uassert.AbortsWithMessage(t, cur, "abt transfer failed: cannot send transfer to self", func() {
		abt.TransferFrom(cross(cur), owner, owner, 1)
	})
	uassert.Equal(t, int64(2), abt.Allowance(owner, other))
	testing.SetOriginCaller(caller)
	testing.SetRealm(testing.NewUserRealm(caller))
	abt.SetFrozen(cross(cur), true)
	testing.SetOriginCaller(other)
	testing.SetRealm(testing.NewUserRealm(other))
	uassert.AbortsWithMessage(t, cur, "abt is frozen", func() { abt.TransferFrom(cross(cur), owner, other, 2) })
	uassert.Equal(t, int64(2), abt.Allowance(owner, other))
	uassert.Equal(t, supplyBefore+20, abt.TotalSupply())
}

gnomod.toml

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

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

render.gno

package abt

import (
	"strconv"
	"strings"
)

func Render(path string) string {
	if path == "" {
		return token.RenderHome() + "* **Frozen**: " + strconv.FormatBool(frozen) + "\n"
	}
	if strings.HasPrefix(path, "balance/") {
		owner := address(strings.TrimPrefix(path, "balance/"))
		if owner.IsValid() {
			return strconv.FormatInt(BalanceOf(owner), 10)
		}
	}
	return "404"
}

render_test.gno

package abt

import (
	"strings"
	"testing"

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

func TestRender(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	Mint(cross(cur), abtTest.Owner, 123)
	for _, text := range []string{"Akkadia Beta Token", "$abt", "**Decimals**: 6", "**Total supply**: 123", "**Frozen**: true"} {
		uassert.True(t, strings.Contains(Render(""), text))
	}
	uassert.Equal(t, "123", Render("balance/"+abtTest.Owner.String()))
	uassert.Equal(t, "0", Render("balance/"+abtTest.Other.String()))
	for _, path := range []string{"unknown", "balance/", "balance/invalid", "balance/" + abtTest.Owner.String() + "/extra", "balance/<script>"} {
		uassert.Equal(t, "404", Render(path))
	}
	uassert.Equal(t, int64(123), TotalSupply())
	uassert.Equal(t, int64(123), BalanceOf(abtTest.Owner))
	uassert.Equal(t, int64(0), Allowance(abtTest.Owner, abtTest.Other))
	uassert.True(t, IsFrozen())
	SetFrozen(cross(cur), false)
	uassert.True(t, strings.Contains(Render(""), "**Frozen**: false"))
}

security_test.gno

package abt

import (
	"chain"
	"chain/runtime"
	"testing"

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

func TestUnauthorizedMintAndFreeze(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	testing.SetOriginCaller(abtTest.Owner)
	testing.SetRealm(testing.NewUserRealm(abtTest.Owner))
	uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() { Mint(cross(cur), abtTest.Owner, 1) })
	for _, caller := range []address{abtTest.Owner, abtTest.Operator} {
		testing.SetOriginCaller(caller)
		testing.SetRealm(testing.NewUserRealm(caller))
		for _, value := range []bool{true, false} {
			uassert.AbortsWithMessage(t, cur, "admin access required", func() { SetFrozen(cross(cur), value) })
		}
	}
	for _, signer := range []address{abtTest.Admin, abtTest.Operator} {
		testing.SetOriginCaller(signer)
		testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/abt_relay"))
		uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() { Mint(cross(cur), abtTest.Owner, 1) })
		uassert.AbortsWithMessage(t, cur, "admin access required", func() { SetFrozen(cross(cur), false) })
	}
	uassert.True(t, IsFrozen())
	uassert.Equal(t, int64(0), TotalSupply())
	uassert.Equal(t, int64(0), BalanceOf(abtTest.Owner))
}

func TestFrozenRejectsAllCallers(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	for _, caller := range []address{abtTest.Admin, abtTest.Operator, abtTest.Owner} {
		testing.SetOriginCaller(abtTest.Admin)
		testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
		Mint(cross(cur), caller, 10)
		testing.SetOriginCaller(caller)
		testing.SetRealm(testing.NewUserRealm(caller))
		uassert.AbortsWithMessage(t, cur, "abt is frozen", func() { Transfer(cross(cur), abtTest.Other, 1) })
		uassert.AbortsWithMessage(t, cur, "abt is frozen", func() { Approve(cross(cur), abtTest.Other, 1) })
		uassert.AbortsWithMessage(t, cur, "abt is frozen", func() { Approve(cross(cur), abtTest.Other, 0) })
		uassert.AbortsWithMessage(t, cur, "abt is frozen", func() { TransferFrom(cross(cur), caller, abtTest.Other, 1) })
		uassert.Equal(t, int64(10), BalanceOf(caller))
		uassert.Equal(t, int64(0), Allowance(caller, abtTest.Other))
	}
	uassert.Equal(t, int64(30), TotalSupply())
	uassert.Equal(t, int64(0), BalanceOf(abtTest.Other))
}

func TestAttachedCoinsRejected(cur realm, t *testing.T) {
	cases := []struct {
		name string
		call func(_ int, rlm realm)
	}{
		{"mint", func(_ int, rlm realm) { Mint(cross(rlm), abtTest.Owner, 1) }},
		{"freeze", func(_ int, rlm realm) { SetFrozen(cross(rlm), true) }},
		{"freeze no-op", func(_ int, rlm realm) { SetFrozen(cross(rlm), false) }},
		{"transfer", func(_ int, rlm realm) { Transfer(cross(rlm), abtTest.Other, 1) }},
		{"approve", func(_ int, rlm realm) { Approve(cross(rlm), abtTest.Other, 1) }},
		{"transferFrom", func(_ int, rlm realm) { TransferFrom(cross(rlm), abtTest.Owner, abtTest.Other, 1) }},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(cur realm, t *testing.T) {
			setupABT(cross(cur), t)
			testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
			Mint(cross(cur), abtTest.Admin, 10)
			SetFrozen(cross(cur), false)
			for _, caller := range []runtime.Realm{
				testing.NewUserRealm(abtTest.Admin),
				runtime.NewRealm(abtTest.Admin, "gno.land/e/"+abtTest.Admin.String()+"/run"),
			} {
				testing.SetRealm(caller)
				testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
				uassert.AbortsWithMessage(t, cur, "attached coins not allowed", func() { tc.call(0, cur) })
				uassert.False(t, IsFrozen())
				uassert.Equal(t, int64(10), TotalSupply())
				uassert.Equal(t, int64(10), BalanceOf(abtTest.Admin))
				uassert.Equal(t, int64(0), BalanceOf(abtTest.Other))
				uassert.Equal(t, int64(0), Allowance(abtTest.Admin, abtTest.Other))
			}
		})
	}
}

func TestRelayUsesOwnBalanceAndAllowance(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	relay := testing.NewCodeRealm("gno.land/r/example/abt_relay")
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	Mint(cross(cur), abtTest.Owner, 100)
	Mint(cross(cur), relay.Address(), 20)
	SetFrozen(cross(cur), false)
	testing.SetOriginCaller(abtTest.Owner)
	testing.SetRealm(testing.NewUserRealm(abtTest.Owner))
	Approve(cross(cur), relay.Address(), 7)
	Approve(cross(cur), abtTest.Owner, 30)
	// These coins belong to the relay's origin call, not to ABT.
	testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
	testing.SetRealm(relay)
	Transfer(cross(cur), abtTest.Other, 5)
	Approve(cross(cur), abtTest.Other, 3)
	TransferFrom(cross(cur), abtTest.Owner, abtTest.Other, 7)
	uassert.AbortsWithMessage(t, cur, "abt transfer failed: insufficient allowance", func() {
		TransferFrom(cross(cur), abtTest.Owner, abtTest.Other, 1)
	})
	uassert.Equal(t, int64(93), BalanceOf(abtTest.Owner))
	uassert.Equal(t, int64(15), BalanceOf(relay.Address()))
	uassert.Equal(t, int64(12), BalanceOf(abtTest.Other))
	uassert.Equal(t, int64(3), Allowance(relay.Address(), abtTest.Other))
	uassert.Equal(t, int64(0), Allowance(abtTest.Owner, abtTest.Other))
	uassert.Equal(t, int64(0), Allowance(abtTest.Owner, relay.Address()))
	uassert.Equal(t, int64(30), Allowance(abtTest.Owner, abtTest.Owner))
	uassert.Equal(t, int64(120), TotalSupply())
	testing.SetOriginSend(chain.Coins{})
	testing.SetOriginCaller(abtTest.Admin)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	SetFrozen(cross(cur), true)
	testing.SetRealm(relay)
	uassert.AbortsWithMessage(t, cur, "abt is frozen", func() { Transfer(cross(cur), abtTest.Other, 1) })
	uassert.AbortsWithMessage(t, cur, "abt is frozen", func() { Approve(cross(cur), abtTest.Other, 0) })
	uassert.AbortsWithMessage(t, cur, "abt is frozen", func() { TransferFrom(cross(cur), abtTest.Owner, abtTest.Other, 1) })
}

func TestOperatorRealmCanMintWithOwnAuthority(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	relay := testing.NewCodeRealm("gno.land/r/example/abt_operator")
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	admin.SetOperator(cross(cur), relay.Address())
	testing.SetOriginCaller(abtTest.Owner)
	testing.SetOriginSend(chain.Coins{{"ugnot", 1}})
	testing.SetRealm(relay)
	Mint(cross(cur), abtTest.Owner, 2)
	uassert.AbortsWithMessage(t, cur, "admin access required", func() { SetFrozen(cross(cur), false) })
	uassert.Equal(t, int64(2), TotalSupply())
	uassert.True(t, IsFrozen())
}

func TestSpoofedRealmRejected(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	stale := captureABTRealm(cross(cur))
	uassert.PanicsWithMessage(t, cur, "spoofed realm", func() { assertCanTransfer(0, stale) })
	uassert.True(t, IsFrozen())
	uassert.Equal(t, int64(0), TotalSupply())
}

setup_test.gno

package abt

import (
	"chain"
	"testing"

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

var abtTest = struct {
	Admin, Operator, Owner, Other address
}{
	Admin:    testutils.TestAddress("abtAdmin"),
	Operator: testutils.TestAddress("abtOperator"),
	Owner:    testutils.TestAddress("abtOwner"),
	Other:    testutils.TestAddress("abtOther"),
}

// Call with cross(cur) so token construction uses a live ABT realm.
func setupABT(cur realm, t *testing.T) {
	t.Helper()
	token, ledger = grc20.NewToken("Akkadia Beta Token", "abt", 6, 0, cur)
	frozen = true
	testing.SetOriginSend(chain.Coins{})
	originalAdmin := admin.GetAdmin()
	if originalAdmin != abtTest.Admin {
		testing.SetOriginCaller(originalAdmin)
		testing.SetRealm(testing.NewUserRealm(originalAdmin))
		admin.TransferAdmin(cross(cur), abtTest.Admin)
		testing.SetOriginCaller(abtTest.Admin)
		testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
		admin.AcceptAdmin(cross(cur))
	}
	testing.SetOriginCaller(abtTest.Admin)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	for _, operator := range admin.GetOperators() {
		admin.UnsetOperator(cross(cur), operator)
	}
	admin.SetOperator(cross(cur), abtTest.Operator)
}

func captureABTRealm(cur realm) realm { return cur }

transfer_test.gno

package abt

import (
	"testing"

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

func TestTransferFailuresPreserveState(cur realm, t *testing.T) {
	cases := []struct {
		name     string
		caller   address
		call     func(_ int, rlm realm)
		panicMsg string
	}{
		{"transfer address", abtTest.Owner, func(_ int, rlm realm) { Transfer(cross(rlm), address("bad"), 1) }, "abt transfer failed: invalid address"},
		{"transfer negative", abtTest.Owner, func(_ int, rlm realm) { Transfer(cross(rlm), abtTest.Other, -1) }, "abt transfer failed: invalid amount"},
		{"transfer balance", abtTest.Owner, func(_ int, rlm realm) { Transfer(cross(rlm), abtTest.Other, 11) }, "abt transfer failed: insufficient balance"},
		{"transfer self", abtTest.Owner, func(_ int, rlm realm) { Transfer(cross(rlm), abtTest.Owner, 1) }, "abt transfer failed: cannot send transfer to self"},
		{"approve address", abtTest.Owner, func(_ int, rlm realm) { Approve(cross(rlm), address(""), 1) }, "abt approval failed: invalid address"},
		{"approve negative", abtTest.Owner, func(_ int, rlm realm) { Approve(cross(rlm), abtTest.Other, -1) }, "abt approval failed: invalid amount"},
		{"transferFrom owner", abtTest.Other, func(_ int, rlm realm) { TransferFrom(cross(rlm), address(""), abtTest.Admin, 1) }, "abt transfer failed: invalid address"},
		{"transferFrom recipient", abtTest.Other, func(_ int, rlm realm) { TransferFrom(cross(rlm), abtTest.Owner, address("bad"), 1) }, "abt transfer failed: invalid address"},
		{"transferFrom negative", abtTest.Other, func(_ int, rlm realm) { TransferFrom(cross(rlm), abtTest.Owner, abtTest.Admin, -1) }, "abt transfer failed: invalid amount"},
		{"transferFrom allowance", abtTest.Other, func(_ int, rlm realm) { TransferFrom(cross(rlm), abtTest.Owner, abtTest.Admin, 6) }, "abt transfer failed: insufficient allowance"},
		{"transferFrom balance", abtTest.Other, func(_ int, rlm realm) { TransferFrom(cross(rlm), abtTest.Owner, abtTest.Admin, 11) }, "abt transfer failed: insufficient balance"},
		{"transferFrom self", abtTest.Other, func(_ int, rlm realm) { TransferFrom(cross(rlm), abtTest.Owner, abtTest.Owner, 1) }, "abt transfer failed: cannot send transfer to self"},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(cur realm, t *testing.T) {
			setupABT(cross(cur), t)
			testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
			Mint(cross(cur), abtTest.Owner, 10)
			SetFrozen(cross(cur), false)
			testing.SetOriginCaller(abtTest.Owner)
			testing.SetRealm(testing.NewUserRealm(abtTest.Owner))
			Approve(cross(cur), abtTest.Other, 5)
			testing.SetOriginCaller(tc.caller)
			testing.SetRealm(testing.NewUserRealm(tc.caller))
			uassert.AbortsWithMessage(t, cur, tc.panicMsg, func() { tc.call(0, cur) })
			uassert.Equal(t, int64(10), TotalSupply())
			uassert.Equal(t, int64(10), BalanceOf(abtTest.Owner))
			uassert.Equal(t, int64(0), BalanceOf(abtTest.Other))
			uassert.Equal(t, int64(0), BalanceOf(abtTest.Admin))
			uassert.Equal(t, int64(5), Allowance(abtTest.Owner, abtTest.Other))
		})
	}
}

func TestZeroTransfers(cur realm, t *testing.T) {
	setupABT(cross(cur), t)
	testing.SetRealm(testing.NewUserRealm(abtTest.Admin))
	SetFrozen(cross(cur), false)
	testing.SetOriginCaller(abtTest.Owner)
	testing.SetRealm(testing.NewUserRealm(abtTest.Owner))
	Transfer(cross(cur), abtTest.Other, 0)
	TransferFrom(cross(cur), abtTest.Other, abtTest.Admin, 0)
	uassert.Equal(t, int64(0), TotalSupply())
	uassert.Equal(t, int64(0), BalanceOf(abtTest.Other))
	uassert.Equal(t, int64(0), Allowance(abtTest.Other, abtTest.Owner))
}