chore: fixup

Signed-off-by: moul <[email protected]>

Author: moul

examples/gno.land/p/demo/grc/grc20/examples_test.gno

@@ -14,31 +14,3 @@ func ExampleApprove()                         {}
 func ExampleTransferFrom()                    {}
 func ExampleMint()                            {}
 func ExampleBurn()                            {}
-
-/*
- Users
- - token creator (root)
- - token holder / enduser / basic realm (GRC20)
- - dao/intermediary-realm (vault) contracts
- - user banker. (prevrealm)
- - realm banker.
- - compatible with govdao. (and async closures).
- - working from top-level variable.
- - working from from proxified.
- - compatible with custom implementation/rules.
- - compatible with custom getCaller as a callback?
- - support addresseable OR sub treasuries.
- - single bnaker for multiple grc20 tokens; like std.Coin{}
-   - consider returning `std.Coin`
- - grc20factory.gno // var banks avl.Tree // key -> Bank
-    bank.LocalBankerWithSuffix(key).Transfer()
- - boundingtoken.gno // tokenA, boundA
- - think about the r/grc20factory special contract
-   - create new user token
-   - what about being seen by another contract as the prevRealm (dex)
- - wugnot
- - GOOD NAMES!
- - GOOD NAMES!
- - GOOD NAMES!
- - GOOD NAMES!
-*/

examples/gno.land/p/demo/grc/grc20/tellers.gno

@@ -4,8 +4,10 @@ import (
 	"std"
 )
 
-func PrevRealmTeller(b *Token) GRC20 {
-	if b == nil {
+// CallerTeller returns a GRC20 compatible teller that checks the PrevRealm caller for each calls.
+// It's usually safe to expose it publicly to let people manipulate their tokens directly or services to use their allowance.
+func (tok *Token) CallerTeller() GRC20 {
+	if tok == nil {
 		panic("Token cannot be nil")
 	}
 
@@ -14,37 +16,43 @@ func PrevRealmTeller(b *Token) GRC20 {
 			caller := std.PrevRealm().Addr()
 			return caller
 		},
-		Token: b,
+		Token: tok,
 	}
 }
 
-func RealmTeller(b *Token) GRC20 {
-	if b == nil {
+// ReadonlyTeller is a GRC20 compatible teller that panics for each write operations.
+func (tok *Token) ReadonlyTeller() GRC20 {
+	if tok == nil {
 		panic("Token cannot be nil")
 	}
 
 	return &fnTeller{
-		accountFn: func() std.Address {
-			caller := std.CurrentRealm().Addr()
-			return caller
-		},
-		Token: b,
+		accountFn: nil,
+		Token:     tok,
 	}
 }
 
-func ReadonlyTeller(b *Token) GRC20 {
-	if b == nil {
+// RealmTeller returns a GRC20 compatible teller that will store the CurrentRealm caller and then reuse the stored caller for each call.
+// It allows a realm contract to interact with a GRC20 with its own account.
+// The initializer of this teller should usually never share a pointer to its RealmTeller except maybe for advanced delegation flows such as a DAO treasury management.
+func (tok *Token) RealmTeller() GRC20 {
+	if tok == nil {
 		panic("Token cannot be nil")
 	}
 
+	caller := std.CurrentRealm().Addr()
+
 	return &fnTeller{
-		accountFn: nil,
-		Token:     b,
+		accountFn: func() std.Address {
+			return caller
+		},
+		Token: tok,
 	}
 }
 
-func SubAccountTeller(b *Token, slug string) GRC20 {
-	if b == nil {
+// RealmSubTeller is like RealmTeller but uses the provided slug to derivate a subaccount.
+func (tok *Token) RealmSubTeller(slug string) GRC20 {
+	if tok == nil {
 		panic("Token cannot be nil")
 	}
 
@@ -55,10 +63,13 @@ func SubAccountTeller(b *Token, slug string) GRC20 {
 		accountFn: func() std.Address {
 			return account
 		},
-		Token: b,
+		Token: tok,
 	}
 }
 
+// generic tellers methods.
+//
+
 func (ft *fnTeller) Transfer(to std.Address, amount uint64) error {
 	if ft.accountFn == nil {
 		return ErrReadonly
@@ -83,6 +94,9 @@ func (ft *fnTeller) TransferFrom(owner, to std.Address, amount uint64) error {
 	return ft.Token.ledger.TransferFrom(owner, spender, to, amount)
 }
 
+// helpers
+//
+
 // accountSlugAddr returns the address derived from the specified address and slug.
 func accountSlugAddr(addr std.Address, slug string) std.Address {
 	// XXX: use a new `std.XXX` call for this.

examples/gno.land/p/demo/grc/grc20/tellers_test.gno

@@ -10,10 +10,10 @@ import (
 	"gno.land/p/demo/urequire"
 )
 
-func TestPrevRealmTellerImpl(t *testing.T) {
-	token, _ := NewToken("Dummy", "DUMMY", 4)
-	teller := PrevRealmTeller(token)
-	urequire.False(t, token == nil)
+func TestCallerTellerImpl(t *testing.T) {
+	tok, _ := NewToken("Dummy", "DUMMY", 4)
+	teller := tok.CallerTeller()
+	urequire.False(t, tok == nil)
 	var _ GRC20 = teller
 }
 
@@ -81,13 +81,13 @@ func TestTeller(t *testing.T) {
 	checkAllowances(200, 0, 0, 0, 0, 0)
 }
 
-func TestPrevRealmTeller(t *testing.T) {
+func TestCallerTeller(t *testing.T) {
 	alice := testutils.TestAddress("alice")
 	bob := testutils.TestAddress("bob")
 	carl := testutils.TestAddress("carl")
 
 	token, ledger := NewToken("Dummy", "DUMMY", 6)
-	teller := PrevRealmTeller(token)
+	teller := token.CallerTeller()
 
 	checkBalances := func(aliceEB, bobEB, carlEB uint64) {
 		t.Helper()

examples/gno.land/p/demo/grc/grc20/types.gno

@@ -8,38 +8,6 @@ import (
 	"gno.land/p/demo/grc/exts"
 )
 
-var (
-	ErrInsufficientBalance   = errors.New("insufficient balance")
-	ErrInsufficientAllowance = errors.New("insufficient allowance")
-	ErrInvalidAddress        = errors.New("invalid address")
-	ErrCannotTransferToSelf  = errors.New("cannot send transfer to self")
-	ErrReadonly              = errors.New("banker is readonly")
-	ErrRestrictedTokenOwner  = errors.New("restricted to bank owner")
-)
-
-const (
-	MintEvent     = "Mint"
-	BurnEvent     = "Burn"
-	TransferEvent = "Transfer"
-	ApprovalEvent = "Approval"
-)
-
-// Token represents a token's bank, including its name, symbol,
-// decimals, and administrative functions.
-type Token struct {
-	name     string
-	symbol   string
-	decimals uint
-	ledger   *AdminLedger
-}
-
-// AdminLedger is a struct that holds administrative functions for the token.
-type AdminLedger struct {
-	totalSupply uint64
-	balances    avl.Tree // std.Address -> uint64
-	allowances  avl.Tree // owner.(std.Address)+":"+spender.(std.Address)) -> uint64
-}
-
 // GRC20 interface defines the methods that a GRC20 token must implement.
 type GRC20 interface {
 	exts.TokenMetadata
@@ -82,6 +50,38 @@ type GRC20 interface {
 	TransferFrom(from, to std.Address, amount uint64) error
 }
 
+var (
+	ErrInsufficientBalance   = errors.New("insufficient balance")
+	ErrInsufficientAllowance = errors.New("insufficient allowance")
+	ErrInvalidAddress        = errors.New("invalid address")
+	ErrCannotTransferToSelf  = errors.New("cannot send transfer to self")
+	ErrReadonly              = errors.New("banker is readonly")
+	ErrRestrictedTokenOwner  = errors.New("restricted to bank owner")
+)
+
+const (
+	MintEvent     = "Mint"
+	BurnEvent     = "Burn"
+	TransferEvent = "Transfer"
+	ApprovalEvent = "Approval"
+)
+
+type Token struct {
+	name     string
+	symbol   string
+	decimals uint
+	ledger   *AdminLedger
+}
+
+// AdminLedger is a struct that holds the balances and allowances and exposes
+// administrative functions.
+// It is unsafe to expose it publicly.
+type AdminLedger struct {
+	totalSupply uint64
+	balances    avl.Tree // std.Address -> uint64
+	allowances  avl.Tree // owner.(std.Address)+":"+spender.(std.Address)) -> uint64
+}
+
 type fnTeller struct {
 	accountFn func() std.Address
 	*Token

examples/gno.land/r/demo/atomicswap/atomicswap.gno

@@ -61,8 +61,8 @@ func NewCustomCoinSwap(recipient std.Address, hashlock string, timelock time.Tim
 func NewCustomGRC20Swap(recipient std.Address, hashlock string, timelock time.Time, token *grc20.Token) (int, *Swap) {
 	sender := std.PrevRealm().Addr()
 	curAddr := std.CurrentRealm().Addr()
-	// userTeller := grc20.PrevRealmTeller(token)
-	userTeller := grc20.SubAccountTeller(token, "") // FIXME(bug): should be the other one?
+	// userTeller := token.CallerTeller()
+	userTeller := token.RealmTeller() // FIXME(bug): should be the other one?
 
 	allowance := userTeller.Allowance(sender, curAddr)
 	require(allowance > 0, "no allowance")

examples/gno.land/r/demo/bar20/bar20.gno

@@ -14,7 +14,7 @@ import (
 
 var (
 	Token, adm = grc20.NewToken("Bar", "BAR", 4)
-	UserTeller = grc20.PrevRealmTeller(Token)
+	UserTeller = Token.CallerTeller()
 )
 
 func init() {

examples/gno.land/r/demo/foo20/foo20.gno

@@ -16,7 +16,7 @@ import (
 
 var (
 	Token, adminLedger = grc20.NewToken("Foo", "FOO", 4)
-	UserTeller         = grc20.PrevRealmTeller(Token)
+	UserTeller         = Token.CallerTeller()
 	owner              = ownable.NewWithAddress("g1u7y667z64x2h7vc6fmpcprgey4ck233jaww9zq") // @manfred
 )
 

examples/gno.land/r/demo/grc20factory/grc20factory.gno

@@ -46,8 +46,8 @@ func NewWithAdmin(name, symbol string, decimals uint, initialMint, faucet uint64
 	grc20reg.Register(token, symbol)
 }
 
-func (inst instance) PrevRealmTeller() grc20.GRC20 {
-	return grc20.PrevRealmTeller(inst.token)
+func (inst instance) CallerTeller() grc20.GRC20 {
+	return inst.token.CallerTeller()
 }
 
 func Bank(symbol string) *grc20.Token {
@@ -57,32 +57,32 @@ func Bank(symbol string) *grc20.Token {
 
 func TotalSupply(symbol string) uint64 {
 	inst := mustGetInstance(symbol)
-	return grc20.PrevRealmTeller(inst.token).TotalSupply()
+	return inst.token.CallerTeller().TotalSupply()
 }
 
 func BalanceOf(symbol string, owner std.Address) uint64 {
 	inst := mustGetInstance(symbol)
-	return grc20.PrevRealmTeller(inst.token).BalanceOf(owner)
+	return inst.token.CallerTeller().BalanceOf(owner)
 }
 
 func Allowance(symbol string, owner, spender std.Address) uint64 {
 	inst := mustGetInstance(symbol)
-	return grc20.PrevRealmTeller(inst.token).Allowance(owner, spender)
+	return inst.token.CallerTeller().Allowance(owner, spender)
 }
 
 func Transfer(symbol string, to std.Address, amount uint64) {
 	inst := mustGetInstance(symbol)
-	checkErr(grc20.PrevRealmTeller(inst.token).Transfer(to, amount))
+	checkErr(inst.token.CallerTeller().Transfer(to, amount))
 }
 
 func Approve(symbol string, spender std.Address, amount uint64) {
 	inst := mustGetInstance(symbol)
-	checkErr(grc20.PrevRealmTeller(inst.token).Approve(spender, amount))
+	checkErr(inst.token.CallerTeller().Approve(spender, amount))
 }
 
 func TransferFrom(symbol string, from, to std.Address, amount uint64) {
 	inst := mustGetInstance(symbol)
-	checkErr(grc20.PrevRealmTeller(inst.token).TransferFrom(from, to, amount))
+	checkErr(inst.token.CallerTeller().TransferFrom(from, to, amount))
 }
 
 // faucet.
@@ -124,7 +124,7 @@ func Render(path string) string {
 		symbol := parts[0]
 		inst := mustGetInstance(symbol)
 		owner := std.Address(parts[2])
-		balance := grc20.PrevRealmTeller(inst.token).BalanceOf(owner)
+		balance := inst.token.CallerTeller().BalanceOf(owner)
 		return ufmt.Sprintf("%d", balance)
 	default:
 		return "404\n"

examples/gno.land/r/demo/minidex/minidex.gno

@@ -37,7 +37,7 @@ func NewDEX() *DEX {
 func (dex *DEX) PlaceOrder(tokenFrom, tokenTo *grc20.Token, amount uint64, isBuy bool) int {
 	trader := std.PrevRealm().Addr()
 	curAddr := std.CurrentRealm().Addr()
-	userBanker := grc20.SubAccountTeller(tokenFrom, "")
+	userBanker := tokenFrom.RealmTeller()
 
 	allowance := userBanker.Allowance(trader, curAddr)
 	require(allowance >= amount, "insufficient allowance")
@@ -91,8 +91,8 @@ func (dex *DEX) matchPairOrders(tokenFrom, tokenTo *grc20.Token) int {
 				amount := min(order1.amount, order2.amount)
 				order1.amount -= amount
 				order2.amount -= amount
-				banker1 := grc20.SubAccountTeller(order1.tokenFrom, "")
-				banker2 := grc20.SubAccountTeller(order2.tokenFrom, "")
+				banker1 := order1.tokenFrom.RealmTeller()
+				banker2 := order2.tokenFrom.RealmTeller()
 				banker1.Transfer(order2.trader, amount)
 				banker2.Transfer(order1.trader, amount)
 				matched++
@@ -127,7 +127,7 @@ func (dex *DEX) CancelOrders() {
 		ordersTree.Iterate("", "", func(key string, value interface{}) bool {
 			order := value.(*Order)
 			if order.trader == trader {
-				userBanker := grc20.SubAccountTeller(order.tokenFrom, "")
+				userBanker := order.tokenFrom.RealmTeller()
 				err := userBanker.Transfer(trader, order.amount)
 				checkErr(err, "cannot refund tokens")
 				ordersTree.Remove(key)

examples/gno.land/r/demo/minidex/minidex_test.gno

@@ -4,7 +4,6 @@ import (
 	"std"
 	"testing"
 
-	"gno.land/p/demo/grc/grc20"
 	"gno.land/p/demo/testutils"
 	"gno.land/p/demo/uassert"
 	"gno.land/p/demo/ufmt"
@@ -70,7 +69,7 @@ func TestPackage(t *testing.T) {
 	checkBalances(1000, 0, 0, 0, 0, 0)
 	checkAllowances(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 
-	grc20.PrevRealmTeller(test20.Token).Approve(dexAddr, 100)
+	test20.Token.CallerTeller().Approve(dexAddr, 100)
 	checkBalances(1000, 0, 0, 0, 0, 0)
 	checkAllowances(0, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 	uassert.Equal(t, dex.Size(), 0, "A")
@@ -89,7 +88,7 @@ Sell: Test20 -> Foo 100
 	checkBalances(900, 0, 100, 0, 10000000, 0)
 	checkAllowances(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 
-	grc20.PrevRealmTeller(foo20.Token).Approve(dexAddr, 2000)
+	foo20.Token.CallerTeller().Approve(dexAddr, 2000)
 	checkBalances(900, 0, 100, 0, 10000000, 0)
 	checkAllowances(0, 0, 0, 0, 0, 0, 0, 0, 0, 2000, 0, 0)
 	uassert.Equal(t, dex.Size(), 1, "D")

examples/gno.land/r/demo/tests/test20/test20.gno

@@ -14,9 +14,9 @@ import (
 
 var (
 	Token, AdminLedger = grc20.NewToken("Test20", "TST", 4)
-	PrevRealmTeller    = grc20.PrevRealmTeller(Token)
-	AccountTeller      = grc20.SubAccountTeller(Token, "")
-	AccountTellerFoo   = grc20.SubAccountTeller(Token, "foo")
+	CallerTeller       = Token.CallerTeller()
+	RealmTeller        = Token.RealmTeller()
+	RealmTellerFoo     = Token.RealmSubTeller("foo")
 )
 
 // XXX func init() { grc20reg.Register(Pub, "") } // circular dep (testing)

examples/gno.land/r/demo/wugnot/wugnot.gno

@@ -78,20 +78,20 @@ func Allowance(owner, spender pusers.AddressOrName) uint64 {
 
 func Transfer(to pusers.AddressOrName, amount uint64) {
 	toAddr := users.Resolve(to)
-	userTeller := grc20.PrevRealmTeller(Token)
+	userTeller := Token.CallerTeller()
 	checkErr(userTeller.Transfer(toAddr, amount))
 }
 
 func Approve(spender pusers.AddressOrName, amount uint64) {
 	spenderAddr := users.Resolve(spender)
-	userTeller := grc20.PrevRealmTeller(Token)
+	userTeller := Token.CallerTeller()
 	checkErr(userTeller.Approve(spenderAddr, amount))
 }
 
 func TransferFrom(from, to pusers.AddressOrName, amount uint64) {
 	fromAddr := users.Resolve(from)
 	toAddr := users.Resolve(to)
-	userTeller := grc20.PrevRealmTeller(Token)
+	userTeller := Token.CallerTeller()
 	checkErr(userTeller.TransferFrom(fromAddr, toAddr, amount))
 }