chore: fixup

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

Author: moul

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

@@ -0,0 +1,3 @@
+package grc20
+
+// XXX: func Mock(t *Token)

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

@@ -0,0 +1,94 @@
+package grc20
+
+import (
+	"std"
+)
+
+func PrevRealmTeller(b *Token) GRC20 {
+	if b == nil {
+		panic("Token cannot be nil")
+	}
+
+	return &fnTeller{
+		accountFn: func() std.Address {
+			caller := std.PrevRealm().Addr()
+			return caller
+		},
+		Token: b,
+	}
+}
+
+func RealmTeller(b *Token) GRC20 {
+	if b == nil {
+		panic("Token cannot be nil")
+	}
+
+	return &fnTeller{
+		accountFn: func() std.Address {
+			caller := std.CurrentRealm().Addr()
+			return caller
+		},
+		Token: b,
+	}
+}
+
+func ReadonlyTeller(b *Token) GRC20 {
+	if b == nil {
+		panic("Token cannot be nil")
+	}
+
+	return &fnTeller{
+		accountFn: nil,
+		Token:     b,
+	}
+}
+
+func SubAccountTeller(b *Token, slug string) GRC20 {
+	if b == nil {
+		panic("Token cannot be nil")
+	}
+
+	caller := std.CurrentRealm().Addr()
+	account := accountSlugAddr(caller, slug)
+
+	return &fnTeller{
+		accountFn: func() std.Address {
+			return account
+		},
+		Token: b,
+	}
+}
+
+func (ft *fnTeller) Transfer(to std.Address, amount uint64) error {
+	if ft.accountFn == nil {
+		return ErrReadonly
+	}
+	caller := ft.accountFn()
+	return ft.Token.ledger.Transfer(caller, to, amount)
+}
+
+func (ft *fnTeller) Approve(spender std.Address, amount uint64) error {
+	if ft.accountFn == nil {
+		return ErrReadonly
+	}
+	caller := ft.accountFn()
+	return ft.Token.ledger.Approve(caller, spender, amount)
+}
+
+func (ft *fnTeller) TransferFrom(owner, to std.Address, amount uint64) error {
+	if ft.accountFn == nil {
+		return ErrReadonly
+	}
+	spender := ft.accountFn()
+	return ft.Token.ledger.TransferFrom(owner, spender, to, amount)
+}
+
+// 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.
+	if slug == "" {
+		return addr
+	}
+	key := addr.String() + "/" + slug
+	return std.DerivePkgAddr(key) // temporarily using this helper
+}

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

@@ -7,10 +7,10 @@ import (
 	"gno.land/p/demo/ufmt"
 )
 
-// NewBank creates a new Bank.
-// It returns a pointer to the Bank and a pointer to the AdminBanker.
-// Expected usage: Bank, admin := NewBank("Dummy", "DUMMY", 4)
-func NewBank(name, symbol string, decimals uint) (*Bank, *AdminBanker) {
+// NewToken creates a new Token.
+// It returns a pointer to the Token and a pointer to the Ledger.
+// Expected usage: Token, admin := NewToken("Dummy", "DUMMY", 4)
+func NewToken(name, symbol string, decimals uint) (*Token, *AdminLedger) {
 	if name == "" {
 		panic("name should not be empty")
 	}
@@ -19,60 +19,60 @@ func NewBank(name, symbol string, decimals uint) (*Bank, *AdminBanker) {
 	}
 	// XXX additional checks (length, characters, limits, etc)
 
-	bank := &Bank{
+	ledger := &AdminLedger{}
+	token := &Token{
 		name:     name,
 		symbol:   symbol,
 		decimals: decimals,
+		ledger:   ledger,
 	}
-	adm := &AdminBanker{}
-	bank.adm = adm
-	return bank, adm
+	return token, ledger
 }
 
 // GetName returns the name of the token.
-func (b Bank) GetName() string { return b.name }
+func (tok Token) GetName() string { return tok.name }
 
 // GetSymbol returns the symbol of the token.
-func (b Bank) GetSymbol() string { return b.symbol }
+func (tok Token) GetSymbol() string { return tok.symbol }
 
 // GetDecimals returns the number of decimals used to get the token's precision.
-func (b Bank) GetDecimals() uint { return b.decimals }
+func (tok Token) GetDecimals() uint { return tok.decimals }
 
 // TotalSupply returns the total supply of the token.
-func (b Bank) TotalSupply() uint64 { return b.adm.totalSupply }
+func (tok Token) TotalSupply() uint64 { return tok.ledger.totalSupply }
 
 // KnownAccounts returns the number of known accounts in the bank.
-func (b Bank) KnownAccounts() int { return b.adm.balances.Size() }
+func (tok Token) KnownAccounts() int { return tok.ledger.balances.Size() }
 
 // BalanceOf returns the balance of the specified address.
-func (b Bank) BalanceOf(address std.Address) uint64 {
-	return b.adm.balanceOf(address)
+func (tok Token) BalanceOf(address std.Address) uint64 {
+	return tok.ledger.balanceOf(address)
 }
 
 // Allowance returns the allowance of the specified owner and spender.
-func (b Bank) Allowance(owner, spender std.Address) uint64 {
-	return b.adm.allowance(owner, spender)
+func (tok Token) Allowance(owner, spender std.Address) uint64 {
+	return tok.ledger.allowance(owner, spender)
 }
 
-func (b *Bank) RenderHome() string {
+func (tok *Token) RenderHome() string {
 	str := ""
-	str += ufmt.Sprintf("# %s ($%s)\n\n", b.name, b.symbol)
-	str += ufmt.Sprintf("* **Decimals**: %d\n", b.decimals)
-	str += ufmt.Sprintf("* **Total supply**: %d\n", b.adm.totalSupply)
-	str += ufmt.Sprintf("* **Known accounts**: %d\n", b.KnownAccounts())
+	str += ufmt.Sprintf("# %s ($%s)\n\n", tok.name, tok.symbol)
+	str += ufmt.Sprintf("* **Decimals**: %d\n", tok.decimals)
+	str += ufmt.Sprintf("* **Total supply**: %d\n", tok.ledger.totalSupply)
+	str += ufmt.Sprintf("* **Known accounts**: %d\n", tok.KnownAccounts())
 	return str
 }
 
 // SpendAllowance decreases the allowance of the specified owner and spender.
-func (b *AdminBanker) SpendAllowance(owner, spender std.Address, amount uint64) error {
+func (led *AdminLedger) SpendAllowance(owner, spender std.Address, amount uint64) error {
 	if !owner.IsValid() {
 		return ErrInvalidAddress
 	}
 	if !spender.IsValid() {
 		return ErrInvalidAddress
 	}
 
-	currentAllowance := b.allowance(owner, spender)
+	currentAllowance := led.allowance(owner, spender)
 	if currentAllowance < amount {
 		return ErrInsufficientAllowance
 	}
@@ -81,16 +81,16 @@ func (b *AdminBanker) SpendAllowance(owner, spender std.Address, amount uint64)
 	newAllowance := currentAllowance - amount
 
 	if newAllowance == 0 {
-		b.allowances.Remove(key)
+		led.allowances.Remove(key)
 	} else {
-		b.allowances.Set(key, newAllowance)
+		led.allowances.Set(key, newAllowance)
 	}
 
 	return nil
 }
 
 // Transfer transfers tokens from the specified from address to the specified to address.
-func (b *AdminBanker) Transfer(from, to std.Address, amount uint64) error {
+func (led *AdminLedger) Transfer(from, to std.Address, amount uint64) error {
 	if !from.IsValid() {
 		return ErrInvalidAddress
 	}
@@ -101,18 +101,22 @@ func (b *AdminBanker) Transfer(from, to std.Address, amount uint64) error {
 		return ErrCannotTransferToSelf
 	}
 
-	toBalance := b.balanceOf(to)
-	fromBalance := b.balanceOf(from)
+	var (
+		toBalance   = led.balanceOf(to)
+		fromBalance = led.balanceOf(from)
+	)
 
 	if fromBalance < amount {
 		return ErrInsufficientBalance
 	}
 
-	newToBalance := toBalance + amount
-	newFromBalance := fromBalance - amount
+	var (
+		newToBalance   = toBalance + amount
+		newFromBalance = fromBalance - amount
+	)
 
-	b.balances.Set(string(to), newToBalance)
-	b.balances.Set(string(from), newFromBalance)
+	led.balances.Set(string(to), newToBalance)
+	led.balances.Set(string(from), newFromBalance)
 
 	std.Emit(
 		TransferEvent,
@@ -126,27 +130,24 @@ func (b *AdminBanker) Transfer(from, to std.Address, amount uint64) error {
 
 // TransferFrom transfers tokens from the specified owner to the specified to address.
 // It first checks if the owner has sufficient balance and then decreases the allowance.
-func (b *AdminBanker) TransferFrom(owner, spender, to std.Address, amount uint64) error {
-	if b.balanceOf(owner) < amount {
+func (led *AdminLedger) TransferFrom(owner, spender, to std.Address, amount uint64) error {
+	if led.balanceOf(owner) < amount {
 		return ErrInsufficientBalance
 	}
-	if err := b.SpendAllowance(owner, spender, amount); err != nil {
+	if err := led.SpendAllowance(owner, spender, amount); err != nil {
 		return err
 	}
 	// XXX: since we don't "panic", we should take care of rollbacking spendAllowance if transfer fails.
-	return b.Transfer(owner, to, amount)
+	return led.Transfer(owner, to, amount)
 }
 
 // Approve sets the allowance of the specified owner and spender.
-func (b *AdminBanker) Approve(owner, spender std.Address, amount uint64) error {
-	if !owner.IsValid() {
-		return ErrInvalidAddress
-	}
-	if !spender.IsValid() {
+func (led *AdminLedger) Approve(owner, spender std.Address, amount uint64) error {
+	if !owner.IsValid() || !spender.IsValid() {
 		return ErrInvalidAddress
 	}
 
-	b.allowances.Set(allowanceKey(owner, spender), amount)
+	led.allowances.Set(allowanceKey(owner, spender), amount)
 
 	std.Emit(
 		ApprovalEvent,
@@ -159,18 +160,18 @@ func (b *AdminBanker) Approve(owner, spender std.Address, amount uint64) error {
 }
 
 // Mint increases the total supply of the token and adds the specified amount to the specified address.
-func (a *AdminBanker) Mint(address std.Address, amount uint64) error {
+func (led *AdminLedger) Mint(address std.Address, amount uint64) error {
 	if !address.IsValid() {
 		return ErrInvalidAddress
 	}
 
 	// XXX check for overflow
 
-	a.totalSupply += amount
-	currentBalance := a.balanceOf(address)
+	led.totalSupply += amount
+	currentBalance := led.balanceOf(address)
 	newBalance := currentBalance + amount
 
-	a.balances.Set(string(address), newBalance)
+	led.balances.Set(string(address), newBalance)
 
 	std.Emit(
 		TransferEvent,
@@ -183,21 +184,21 @@ func (a *AdminBanker) Mint(address std.Address, amount uint64) error {
 }
 
 // Burn decreases the total supply of the token and subtracts the specified amount from the specified address.
-func (a *AdminBanker) Burn(address std.Address, amount uint64) error {
+func (led *AdminLedger) Burn(address std.Address, amount uint64) error {
 	if !address.IsValid() {
 		return ErrInvalidAddress
 	}
 	// XXX check for overflow
 
-	currentBalance := a.balanceOf(address)
+	currentBalance := led.balanceOf(address)
 	if currentBalance < amount {
 		return ErrInsufficientBalance
 	}
 
-	a.totalSupply -= amount
+	led.totalSupply -= amount
 	newBalance := currentBalance - amount
 
-	a.balances.Set(string(address), newBalance)
+	led.balances.Set(string(address), newBalance)
 
 	std.Emit(
 		TransferEvent,
@@ -210,17 +211,17 @@ func (a *AdminBanker) Burn(address std.Address, amount uint64) error {
 }
 
 // balanceOf returns the balance of the specified address.
-func (b AdminBanker) balanceOf(address std.Address) uint64 {
-	balance, found := b.balances.Get(address.String())
+func (led AdminLedger) balanceOf(address std.Address) uint64 {
+	balance, found := led.balances.Get(address.String())
 	if !found {
 		return 0
 	}
 	return balance.(uint64)
 }
 
 // allowance returns the allowance of the specified owner and spender.
-func (b AdminBanker) allowance(owner, spender std.Address) uint64 {
-	allowance, found := b.allowances.Get(allowanceKey(owner, spender))
+func (led AdminLedger) allowance(owner, spender std.Address) uint64 {
+	allowance, found := led.allowances.Get(allowanceKey(owner, spender))
 	if !found {
 		return 0
 	}

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

@@ -14,7 +14,7 @@ var (
 	ErrInvalidAddress        = errors.New("invalid address")
 	ErrCannotTransferToSelf  = errors.New("cannot send transfer to self")
 	ErrReadonly              = errors.New("banker is readonly")
-	ErrRestrictedBankOwner   = errors.New("restricted to bank owner")
+	ErrRestrictedTokenOwner  = errors.New("restricted to bank owner")
 )
 
 const (
@@ -24,17 +24,17 @@ const (
 	ApprovalEvent = "Approval"
 )
 
-// Bank represents a token's bank, including its name, symbol,
+// Token represents a token's bank, including its name, symbol,
 // decimals, and administrative functions.
-type Bank struct {
+type Token struct {
 	name     string
 	symbol   string
 	decimals uint
-	adm      *AdminBanker
+	ledger   *AdminLedger
 }
 
-// AdminBanker is a struct that holds administrative functions for the token.
-type AdminBanker struct {
+// 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
@@ -82,24 +82,14 @@ type GRC20 interface {
 	TransferFrom(from, to std.Address, amount uint64) error
 }
 
-type fnBanker struct {
+type fnTeller struct {
 	accountFn func() std.Address
-	*Bank
+	*Token
 }
 
-var _ GRC20 = (*fnBanker)(nil)
+var _ GRC20 = (*fnTeller)(nil)
 
-// adminBanker is a struct that holds administrative functions for the token.
-type adminBanker struct {
-	bank *Bank
-}
-
-// 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.
-	if slug == "" {
-		return addr
-	}
-	key := addr.String() + "/" + slug
-	return std.DerivePkgAddr(key) // temporarily using this helper
+// ledger is a struct that holds administrative functions for the token.
+type ledger struct {
+	token *Token
 }

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

@@ -58,7 +58,7 @@ func NewCustomCoinSwap(recipient std.Address, hashlock string, timelock time.Tim
 
 // NewCustomGRC20Swap creates a new atomic swap contract for grc20 tokens.
 // It is not callable with `gnokey maketx call`, but can be imported by another contract or `gnokey maketx run`.
-func NewCustomGRC20Swap(recipient std.Address, hashlock string, timelock time.Time, bank *grc20.Bank) (int, *Swap) {
+func NewCustomGRC20Swap(recipient std.Address, hashlock string, timelock time.Time, bank *grc20.Token) (int, *Swap) {
 	sender := std.PrevRealm().Addr()
 	curAddr := std.CurrentRealm().Addr()
 	// userBanker := grc20.PrevRealmBanker(bank)

examples/gno.land/p/demo/grc/grc20/bank.gno examples/gno.land/p/demo/grc/grc20/token.gno

@@ -9,9 +9,9 @@ import (
 	"gno.land/p/demo/ufmt"
 )
 
-var registry = avl.NewTree() // rlmPath[.slug] -> *grc20.Bank
+var registry = avl.NewTree() // rlmPath[.slug] -> *grc20.Token
 
-func Register(bank *grc20.Bank, slug string) {
+func Register(bank *grc20.Token, slug string) {
 	rlmPath := std.PrevRealm().PkgPath()
 	key := fqname.Construct(rlmPath, slug)
 	registry.Set(key, bank)
@@ -22,15 +22,15 @@ func Register(bank *grc20.Bank, slug string) {
 	)
 }
 
-func Get(key string) *grc20.Bank {
+func Get(key string) *grc20.Token {
 	bank, ok := registry.Get(key)
 	if !ok {
 		return nil
 	}
-	return bank.(*grc20.Bank)
+	return bank.(*grc20.Token)
 }
 
-func MustGet(key string) *grc20.Bank {
+func MustGet(key string) *grc20.Token {
 	bank := Get(key)
 	if bank == nil {
 		panic("unknown bank: " + key)
@@ -46,7 +46,7 @@ func Render(path string) string {
 		count := 0
 		registry.Iterate("", "", func(key string, bankI interface{}) bool {
 			count++
-			bank := bankI.(*grc20.Bank)
+			bank := bankI.(*grc20.Token)
 			rlmPath, slug := fqname.Parse(key)
 			rlmLink := fqname.RenderLink(rlmPath, slug)
 			infoLink := "/r/demo/grc20reg:" + key

examples/gno.land/p/demo/grc/grc20/bank_test.gno examples/gno.land/p/demo/grc/grc20/token_test.gno

@@ -13,8 +13,8 @@ import (
 // Order represents an order in the DEX.
 type Order struct {
 	trader    std.Address
-	tokenFrom *grc20.Bank
-	tokenTo   *grc20.Bank
+	tokenFrom *grc20.Token
+	tokenTo   *grc20.Token
 	amount    uint64
 	isBuy     bool
 }
@@ -34,7 +34,7 @@ func NewDEX() *DEX {
 
 // PlaceOrder places a new order and matches orders.
 // Returns the amount of matched orders, if any.
-func (dex *DEX) PlaceOrder(tokenFrom, tokenTo *grc20.Bank, amount uint64, isBuy bool) int {
+func (dex *DEX) PlaceOrder(tokenFrom, tokenTo *grc20.Token, amount uint64, isBuy bool) int {
 	trader := std.PrevRealm().Addr()
 	curAddr := std.CurrentRealm().Addr()
 	userBanker := grc20.AccountBanker(tokenFrom, "")
@@ -73,7 +73,7 @@ func (dex *DEX) PlaceOrder(tokenFrom, tokenTo *grc20.Bank, amount uint64, isBuy
 }
 
 // matchPairOrders matches orders for a given pair.
-func (dex *DEX) matchPairOrders(tokenFrom, tokenTo *grc20.Bank) int {
+func (dex *DEX) matchPairOrders(tokenFrom, tokenTo *grc20.Token) int {
 	pair := createPairString(tokenFrom, tokenTo)
 	ordersTree, ok := dex.pairs.Get(pair)
 	if !ok {
@@ -184,7 +184,7 @@ func (o Order) String() string {
 }
 
 // createPairString creates a pair string based on two tokens, sorting by the token names to ensure consistency.
-func createPairString(token1, token2 *grc20.Bank) string {
+func createPairString(token1, token2 *grc20.Token) string {
 	tokens := []string{token1.GetName(), token2.GetName()}
 	sort.Strings(tokens)
 	return tokens[0] + "/" + tokens[1]