feat: r/coins balance checker

examples/gno.land/r/gnoland/coins/coins.gno

@@ -0,0 +1,112 @@
+// Package coins provides simple helpers to retrieve information about coins
+// on the Gno.land blockchain.
+//
+// The primary goal of this realm is to allow users to check their token balances without
+// relying on external tools or services. This is particularly valuable for new networks
+// that aren't yet widely supported by public explorers or wallets. By using this realm,
+// users can always access their balance information directly through the gnodev.
+//
+// While currently focused on basic balance checking functionality, this realm could
+// potentially be extended to support other banker-related workflows in the future.
+// However, we aim to keep it minimal and focused on its core purpose.
+//
+// This is a "Render-only realm" - it exposes only a Render function as its public
+// interface and doesn't maintain any state of its own. This pattern allows for
+// simple, stateless information retrieval directly through the blockchain's
+// rendering capabilities.
+//
+// Example usage:
+//
+//	/r/gnoland/coins:ugnot - shows the total supply of ugnot
+//	/r/gnoland/coins:ugnot/g1... - shows the ugnot balance of a specific address
+package coins
+
+import (
+	"std"
+	"strings"
+)
+
+// TotalSupply returns the total supply of the specified denomination
+func TotalSupply(banker std.Banker, denom string) int64 {
+	if denom == "" {
+		panic("empty denom")
+	}
+	// make the coin's denom to follow the correct format
+	qualifiedDenom := std.CurrentRealm().CoinDenom(denom)
+	return banker.TotalCoin(qualifiedDenom)
+}
+
+// AddressBalance returns the balance of the specified token for the given address
+func AddressBalance(banker std.Banker, denom string, address std.Address) int64 {
+	if denom == "" {
+		panic("empty denom")
+	}
+	if !address.IsValid() {
+		panic("invalid address")
+	}
+	return banker.GetCoins(address).AmountOf(denom)
+}
+
+// Path parsing logic:
+// - Empty path: Show homepage with general info and usage instructions
+// - "<denom>": Show total supply and info about the specified coin
+// - "<denom>/<address>": Show specific address balance for the given coin
+func Render(path string) string {
+	banker := std.NewBanker(std.BankerTypeReadonly)
+
+	if path == "" {
+		return renderHomepage()
+	}
+
+	if !strings.Contains(path, "/") {
+		denom := path
+		totalSupply := TotalSupply(banker, denom)
+		return renderCoinInfo(denom, totalSupply)
+	}
+
+	parts := strings.Split(path, "/")
+	if len(parts) != 2 {
+		panic("invalid path")
+	}
+
+	denom, addr := parts[0], parts[1]
+	return renderAddressBalance(banker, denom, std.Address(addr))
+
+	// TODO: implement an explanatory homepage that shows usage instructions
+	// TODO: implement a coin info page showing total supply, and other metrics if we have them
+	// TODO: implement an address page showing balance for specified coin
+	// TODO: create navigation links between pages to enable intuitive exploration without typing URLs
+}
+
+func renderHomepage() string {
+	return `# Gno.land Coins
+`
+}
+
+func renderCoinInfo(denom string, totalSupply int64) string {
+	return `# Coin Info
+
+## Denom
+` + denom + `
+
+## Total Supply
+` + std.NewCoin(denom, totalSupply).String() + `
+
+[Back to Home](/r/gnoland/coins:)
+`
+}
+
+func renderAddressBalance(banker std.Banker, denom string, address std.Address) string {
+	balance := AddressBalance(banker, denom, address)
+	return `# Address Balance
+
+## Address
+` + address.String() + `
+
+## Balance
+` + std.NewCoin(denom, balance).String() + `
+
+[Back to Coin Info](/r/gnoland/coins:` + denom + `)
+[Back to Home](/r/gnoland/coins:)
+`
+}

examples/gno.land/r/gnoland/coins/coins_test.gno

@@ -0,0 +1,67 @@
+package coins
+
+import (
+	"std"
+	"strings"
+	"testing"
+
+	"gno.land/p/demo/testutils"
+)
+
+func TestAirdropChecker(t *testing.T) {
+	addr1 := testutils.TestAddress("addr1")
+	addr2 := testutils.TestAddress("addr2")
+
+	realm := std.CurrentRealm()
+	testDenom := realm.CoinDenom("test")
+	test2Denom := realm.CoinDenom("test2")
+
+	tests := []struct {
+		name      string
+		path      string
+		setupFunc func(std.Banker)
+		expected  string
+		wantPanic bool
+	}{
+		{
+			name: "homepage shows supported tokens",
+			path: "",
+			setupFunc: func(banker std.Banker) {
+				banker.IssueCoin(addr1, test2Denom, 1000)
+				banker.IssueCoin(addr2, test2Denom, 1000)
+			},
+			expected: `# Gno.land Coins`,
+		},
+		{
+			name: "show total supply for test token",
+			path: "test",
+			setupFunc: func(banker std.Banker) {
+				banker.IssueCoin(addr1, testDenom, 1000000)
+				banker.IssueCoin(addr2, testDenom, 500000)
+
+				println("setup amount", banker.TotalCoin(testDenom))
+			},
+			expected: `1500000test`,
+		},
+	}
+
+	for _, tt := range tests {
+		banker := std.NewBanker(std.BankerTypeRealmIssue)
+		tt.setupFunc(banker)
+
+		if tt.wantPanic {
+			defer func() {
+				if r := recover(); r == nil {
+					t.Errorf("expected panic for %s", tt.name)
+				}
+			}()
+		}
+
+		result := Render(tt.path)
+		if !tt.wantPanic {
+			if !strings.Contains(result, tt.expected) {
+				t.Errorf("expected %s to contain %s", result, tt.expected)
+			}
+		}
+	}
+}

examples/gno.land/r/gnoland/coins/gno.mod

@@ -0,0 +1 @@
+module gno.land/r/gnoland/coins

gno.land/pkg/sdk/vm/builtins.go

@@ -41,7 +41,19 @@
 }
 
 func (bnk *SDKBanker) TotalCoin(denom string) int64 {
-	panic("not yet implemented")
+	if denom == "" {
+		panic("empty denom")
+	}
+	accounts := bnk.vmk.acck.GetAllAccounts(bnk.ctx)
+	var totalAmount int64
+
+	for _, acc := range accounts {
+		if acc == nil {
+			continue
+		}
+		totalAmount += acc.GetCoins().AmountOf(denom)
+	}
+	return totalAmount
 }
 
 func (bnk *SDKBanker) IssueCoin(b32addr crypto.Bech32Address, denom string, amount int64) {

gno.land/pkg/sdk/vm/builtins_test.go

@@ -3,12 +3,16 @@ package vm
 import (
 	"testing"
 
+	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/std"
+
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestParamsKeeper(t *testing.T) {
 	env := setupTestEnv()
-	params := NewSDKParams(env.vmk.prmk, env.ctx)
+	params := NewSDKParams(env.prmk, env.ctx)
 
 	testCases := []struct {
 		name        string
@@ -65,3 +69,47 @@ func TestParamsKeeper(t *testing.T) {
 		})
 	}
 }
+
+func TestSDKBankerTotalCoin(t *testing.T) {
+	env := setupTestEnv()
+	ctx := env.vmk.MakeGnoTransactionStore(env.ctx)
+	banker := NewSDKBanker(env.vmk, ctx)
+
+	// create test accounts and set coins
+	addr1 := crypto.AddressFromPreimage([]byte("addr1"))
+	addr2 := crypto.AddressFromPreimage([]byte("addr2"))
+
+	acc1 := env.acck.NewAccountWithAddress(ctx, addr1)
+	env.acck.SetAccount(ctx, acc1)
+	env.bankk.SetCoins(ctx, addr1, std.MustParseCoins("1000ugnot,500atom"))
+
+	acc2 := env.acck.NewAccountWithAddress(ctx, addr2)
+	env.acck.SetAccount(ctx, acc2)
+	env.bankk.SetCoins(ctx, addr2, std.MustParseCoins("2000ugnot,1500atom"))
+
+	tests := []struct {
+		name      string
+		denom     string
+		expected  int64
+		mustPanic bool
+	}{
+		{"ugnot total", "ugnot", 3000, false},
+		{"atom total", "atom", 2000, false},
+		{"non-existent denom", "foo", 0, false},
+		{"zero balance accounts included", "ugnot", 3000, false},
+		{"empty string denom", "", 0, true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.mustPanic {
+				assert.Panics(t, func() {
+					banker.TotalCoin(tt.denom)
+				})
+			} else {
+				total := banker.TotalCoin(tt.denom)
+				assert.Equal(t, tt.expected, total)
+			}
+		})
+	}
+}

gnovm/stdlibs/std/banker.gno

@@ -120,6 +120,7 @@ func (b banker) SendCoins(from, to Address, amt Coins) {
 }
 
 func (b banker) TotalCoin(denom string) int64 {
+	assertCoinDenom(denom)
 	return bankerTotalCoin(uint8(b.bt), denom)
 }
 

gnovm/tests/stdlibs/std/std.go

@@ -209,26 +209,33 @@ func (tb *TestBanker) SendCoins(from, to crypto.Bech32Address, amt tm2std.Coins)
 	tb.CoinTable[from] = frest
 	// Second, add to 'to'.
 	// NOTE: even works when from==to, due to 2-step isolation.
-	tcoins, _ := tb.CoinTable[to]
+	tcoins := tb.CoinTable[to]
 	tsum := tcoins.Add(amt)
 	tb.CoinTable[to] = tsum
 }
 
 // TotalCoin implements the Banker interface.
 func (tb *TestBanker) TotalCoin(denom string) int64 {
-	panic("not yet implemented")
+	if denom == "" {
+		panic("empty denom")
+	}
+	var total int64
+	for _, coins := range tb.CoinTable {
+		total += coins.AmountOf(denom)
+	}
+	return total
 }
 
 // IssueCoin implements the Banker interface.
 func (tb *TestBanker) IssueCoin(addr crypto.Bech32Address, denom string, amt int64) {
-	coins, _ := tb.CoinTable[addr]
+	coins := tb.CoinTable[addr]
 	sum := coins.Add(tm2std.Coins{{Denom: denom, Amount: amt}})
 	tb.CoinTable[addr] = sum
 }
 
 // RemoveCoin implements the Banker interface.
 func (tb *TestBanker) RemoveCoin(addr crypto.Bech32Address, denom string, amt int64) {
-	coins, _ := tb.CoinTable[addr]
+	coins := tb.CoinTable[addr]
 	rest := coins.Sub(tm2std.Coins{{Denom: denom, Amount: amt}})
 	tb.CoinTable[addr] = rest
 }