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