chore: fixup

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

Author: moul

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

@@ -7,6 +7,9 @@ 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) {
 	if name == "" {
 		panic("name should not be empty")
@@ -26,16 +29,27 @@ func NewBank(name, symbol string, decimals uint) (*Bank, *AdminBanker) {
 	return bank, adm
 }
 
-func (b Bank) GetName() string     { return b.name }
-func (b Bank) GetSymbol() string   { return b.symbol }
-func (b Bank) GetDecimals() uint   { return b.decimals }
+// GetName returns the name of the token.
+func (b Bank) GetName() string { return b.name }
+
+// GetSymbol returns the symbol of the token.
+func (b Bank) GetSymbol() string { return b.symbol }
+
+// GetDecimals returns the number of decimals used to get the token's precision.
+func (b Bank) GetDecimals() uint { return b.decimals }
+
+// TotalSupply returns the total supply of the token.
 func (b Bank) TotalSupply() uint64 { return b.adm.totalSupply }
-func (b Bank) KnownAccounts() int  { return b.adm.balances.Size() }
 
+// KnownAccounts returns the number of known accounts in the bank.
+func (b Bank) KnownAccounts() int { return b.adm.balances.Size() }
+
+// BalanceOf returns the balance of the specified address.
 func (b Bank) BalanceOf(address std.Address) uint64 {
 	return b.adm.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)
 }
@@ -49,6 +63,7 @@ func (b *Bank) RenderHome() string {
 	return str
 }
 
+// SpendAllowance decreases the allowance of the specified owner and spender.
 func (b *AdminBanker) SpendAllowance(owner, spender std.Address, amount uint64) error {
 	if !owner.IsValid() {
 		return ErrInvalidAddress
@@ -74,6 +89,7 @@ func (b *AdminBanker) SpendAllowance(owner, spender std.Address, amount uint64)
 	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 {
 	if !from.IsValid() {
 		return ErrInvalidAddress
@@ -108,6 +124,8 @@ func (b *AdminBanker) Transfer(from, to std.Address, amount uint64) error {
 	return nil
 }
 
+// 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 {
 		return ErrInsufficientBalance
@@ -119,6 +137,7 @@ func (b *AdminBanker) TransferFrom(owner, spender, to std.Address, amount uint64
 	return b.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
@@ -139,6 +158,7 @@ func (b *AdminBanker) Approve(owner, spender std.Address, amount uint64) error {
 	return nil
 }
 
+// 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 {
 	if !address.IsValid() {
 		return ErrInvalidAddress
@@ -162,6 +182,7 @@ func (a *AdminBanker) Mint(address std.Address, amount uint64) error {
 	return nil
 }
 
+// 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 {
 	if !address.IsValid() {
 		return ErrInvalidAddress
@@ -188,6 +209,7 @@ func (a *AdminBanker) Burn(address std.Address, amount uint64) error {
 	return nil
 }
 
+// balanceOf returns the balance of the specified address.
 func (b AdminBanker) balanceOf(address std.Address) uint64 {
 	balance, found := b.balances.Get(address.String())
 	if !found {
@@ -196,6 +218,7 @@ func (b AdminBanker) balanceOf(address std.Address) uint64 {
 	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))
 	if !found {
@@ -204,14 +227,7 @@ func (b AdminBanker) allowance(owner, spender std.Address) uint64 {
 	return allowance.(uint64)
 }
 
+// allowanceKey returns the key for the allowance of the specified owner and spender.
 func allowanceKey(owner, spender std.Address) string {
 	return owner.String() + ":" + spender.String()
 }
-
-func AccountSlugAddr(addr std.Address, slug string) std.Address {
-	if slug == "" {
-		return addr
-	}
-	key := addr.String() + "/" + slug
-	return std.DerivePkgAddr(key) // temporarily using this helper
-}

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

@@ -0,0 +1,79 @@
+package grc20
+
+import (
+	"testing"
+
+	"gno.land/p/demo/testutils"
+	"gno.land/p/demo/uassert"
+	"gno.land/p/demo/ufmt"
+	"gno.land/p/demo/urequire"
+)
+
+func TestBankImpl(t *testing.T) {
+	bank, _ := NewBank("Dummy", "DUMMY", 4)
+	urequire.False(t, bank == nil, "dummy should not be nil")
+}
+
+func TestBank(t *testing.T) {
+	var (
+		alice = testutils.TestAddress("alice")
+		bob   = testutils.TestAddress("bob")
+		carl  = testutils.TestAddress("carl")
+	)
+
+	bank, adm := NewBank("Dummy", "DUMMY", 6)
+
+	checkBalances := func(aliceEB, bobEB, carlEB uint64) {
+		t.Helper()
+		exp := ufmt.Sprintf("alice=%d bob=%d carl=%d", aliceEB, bobEB, carlEB)
+		aliceGB := bank.BalanceOf(alice)
+		bobGB := bank.BalanceOf(bob)
+		carlGB := bank.BalanceOf(carl)
+		got := ufmt.Sprintf("alice=%d bob=%d carl=%d", aliceGB, bobGB, carlGB)
+		uassert.Equal(t, got, exp, "invalid balances")
+	}
+	checkAllowances := func(abEB, acEB, baEB, bcEB, caEB, cbEB uint64) {
+		t.Helper()
+		exp := ufmt.Sprintf("ab=%d ac=%d ba=%d bc=%d ca=%d cb=%s", abEB, acEB, baEB, bcEB, caEB, cbEB)
+		abGB := bank.Allowance(alice, bob)
+		acGB := bank.Allowance(alice, carl)
+		baGB := bank.Allowance(bob, alice)
+		bcGB := bank.Allowance(bob, carl)
+		caGB := bank.Allowance(carl, alice)
+		cbGB := bank.Allowance(carl, bob)
+		got := ufmt.Sprintf("ab=%d ac=%d ba=%d bc=%d ca=%d cb=%s", abGB, acGB, baGB, bcGB, caGB, cbGB)
+		uassert.Equal(t, got, exp, "invalid allowances")
+	}
+
+	checkBalances(0, 0, 0)
+	checkAllowances(0, 0, 0, 0, 0, 0)
+
+	urequire.NoError(t, adm.Mint(alice, 1000))
+	urequire.NoError(t, adm.Mint(alice, 100))
+	checkBalances(1100, 0, 0)
+	checkAllowances(0, 0, 0, 0, 0, 0)
+
+	urequire.NoError(t, adm.Approve(alice, bob, 99999999))
+	checkBalances(1100, 0, 0)
+	checkAllowances(99999999, 0, 0, 0, 0, 0)
+
+	urequire.NoError(t, adm.Approve(alice, bob, 400))
+	checkBalances(1100, 0, 0)
+	checkAllowances(400, 0, 0, 0, 0, 0)
+
+	urequire.Error(t, adm.TransferFrom(alice, bob, carl, 100000000))
+	checkBalances(1100, 0, 0)
+	checkAllowances(400, 0, 0, 0, 0, 0)
+
+	urequire.NoError(t, adm.TransferFrom(alice, bob, carl, 100))
+	checkBalances(1000, 0, 100)
+	checkAllowances(300, 0, 0, 0, 0, 0)
+
+	urequire.Error(t, adm.SpendAllowance(alice, bob, 2000000))
+	checkBalances(1000, 0, 100)
+	checkAllowances(300, 0, 0, 0, 0, 0)
+
+	urequire.NoError(t, adm.SpendAllowance(alice, bob, 100))
+	checkBalances(1000, 0, 100)
+	checkAllowances(200, 0, 0, 0, 0, 0)
+}

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

@@ -5,6 +5,10 @@ import (
 )
 
 func PrevRealmBanker(b *Bank) GRC20 {
+	if b == nil {
+		panic("Bank cannot be nil")
+	}
+
 	return &fnBanker{
 		accountFn: func() std.Address {
 			caller := std.PrevRealm().Addr()
@@ -14,16 +18,39 @@ func PrevRealmBanker(b *Bank) GRC20 {
 	}
 }
 
+func RealmBanker(b *Bank) GRC20 {
+	if b == nil {
+		panic("Bank cannot be nil")
+	}
+
+	return &fnBanker{
+		accountFn: func() std.Address {
+			caller := std.CurrentRealm().Addr()
+			return caller
+		},
+		Bank: b,
+	}
+}
+
 func ReadonlyBanker(b *Bank) GRC20 {
+	if b == nil {
+		panic("Bank cannot be nil")
+	}
+
 	return &fnBanker{
 		accountFn: nil,
 		Bank:      b,
 	}
 }
 
-func AccountBanker(b *Bank, slug string) GRC20 {
+func SubAccountBanker(b *Bank, slug string) GRC20 {
+	if b == nil {
+		panic("Bank cannot be nil")
+	}
+
 	caller := std.CurrentRealm().Addr()
-	account := AccountSlugAddr(caller, slug)
+	account := accountSlugAddr(caller, slug)
+
 	return &fnBanker{
 		accountFn: func() std.Address {
 			return account

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

@@ -1,14 +1,25 @@
 package grc20
 
+// XXX: write Examples
+
+func ExampleInit()                            {}
+func ExampleExposeBankForMaketxRunOrImports() {}
+func ExampleCustomGRC20Impl()                 {}
+func ExampleAllowance()                       {}
+func ExampleRealmBanker()                     {}
+func ExamplePrevRealmBanker()                 {}
+func ExampleAccountBanker()                   {}
+func ExampleTransfer()                        {}
+func ExampleApprove()                         {}
+func ExampleTransferFrom()                    {}
+func ExampleMint()                            {}
+func ExampleBurn()                            {}
+
 /*
  Users
  - token creator (root)
  - token holder / enduser / basic realm (GRC20)
  - dao/intermediary-realm (vault) contracts
- Some challenges I've in mind:
- - making a `GRC20` interface that is an interface. -> CHECK
- - making a `grc20.XXX` structure which provides the best suggested implementation.
- - encouraging realms to store an admin Banker while exposing other things (TBD).
  - user banker. (prevrealm)
  - realm banker.
  - compatible with govdao. (and async closures).

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

@@ -17,6 +17,13 @@ var (
 	ErrRestrictedBankOwner   = errors.New("restricted to bank owner")
 )
 
+const (
+	MintEvent     = "Mint"
+	BurnEvent     = "Burn"
+	TransferEvent = "Transfer"
+	ApprovalEvent = "Approval"
+)
+
 // Bank represents a token's bank, including its name, symbol,
 // decimals, and administrative functions.
 type Bank struct {
@@ -75,8 +82,6 @@ type GRC20 interface {
 	TransferFrom(from, to std.Address, amount uint64) error
 }
 
-// fnBanker is a wrapper around Bank that provides a custom account address
-// through a function. This allows for dynamic account addressing in GRC20 operations.
 type fnBanker struct {
 	accountFn func() std.Address
 	*Bank
@@ -89,9 +94,12 @@ type adminBanker struct {
 	bank *Bank
 }
 
-const (
-	MintEvent     = "Mint"
-	BurnEvent     = "Burn"
-	TransferEvent = "Transfer"
-	ApprovalEvent = "Approval"
-)
+// 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
+}