Skip to content Search Apps Documentation Source Content Run Reset Eval Playground File Folder Download Copy Actions State String Boolean Number Struct Map Slice Pointer Function Closure Reference Nil Package Type Interface Unknown

Playground

erc20.gno

// Package erc20 implements MiniToken, a minimal fungible token modeled on the
// Solidity ERC-20 idea, ported to gno.land (gno 0.9 / sapphire).
//
// State is package-level and persistent. All state-mutating exported functions
// are crossing functions (they take `cur realm` as the first parameter) per the
// gno 0.9 interrealm convention, and identify the caller via
// cur.Previous().Address() after checking cur.IsCurrent().
package erc20

import (
	"errors"
	"sort"
	"strconv"
	"strings"
)

const (
	name   = "MiniToken"
	symbol = "MINI"
)

var (
	// balances maps holder address -> token balance.
	balances = map[address]uint64{}
	// allowances[owner][spender] = amount the spender may pull from owner.
	allowances = map[address]map[address]uint64{}
	// totalSupply is the sum of all balances.
	totalSupply uint64
)

var (
	errZeroAddress  = errors.New("erc20: zero address")
	errInsufficient = errors.New("erc20: insufficient balance")
	errAllowanceLow = errors.New("erc20: insufficient allowance")
	errOverflow     = errors.New("erc20: supply overflow")
	errSpoofedRealm = errors.New("erc20: spoofed realm")
	errNotUser      = errors.New("erc20: caller is not a user account")
)

// caller returns the immediate caller's address for a crossing function.
// It enforces the gno 0.9 authentication primitive: cur must be the live
// crossing frame before its Previous() is trusted.
func caller(cur realm) address {
	if !cur.IsCurrent() {
		panic(errSpoofedRealm)
	}
	prev := cur.Previous()
	if !prev.IsUser() {
		panic(errNotUser)
	}
	return prev.Address()
}

// Mint creates `amount` new tokens and credits them to `to`, increasing the
// total supply. Crossing function.
func Mint(cur realm, to address, amount uint64) {
	_ = caller(cur) // authenticate the crossing frame; anyone may mint in this demo
	if !to.IsValid() {
		panic(errZeroAddress)
	}
	if amount == 0 {
		return
	}
	if totalSupply+amount < totalSupply {
		panic(errOverflow)
	}
	totalSupply += amount
	balances[to] += amount
}

// Transfer moves `amount` tokens from the caller to `to`. Crossing function.
func Transfer(cur realm, to address, amount uint64) {
	from := caller(cur)
	if !to.IsValid() {
		panic(errZeroAddress)
	}
	if err := transfer(from, to, amount); err != nil {
		panic(err)
	}
}

// Approve authorizes `spender` to pull up to `amount` tokens from the caller.
// Crossing function.
func Approve(cur realm, spender address, amount uint64) {
	owner := caller(cur)
	if !spender.IsValid() {
		panic(errZeroAddress)
	}
	m := allowances[owner]
	if m == nil {
		m = map[address]uint64{}
		allowances[owner] = m
	}
	m[spender] = amount
}

// TransferFrom moves `amount` tokens from `from` to `to`, spending the caller's
// allowance granted by `from`. Crossing function.
func TransferFrom(cur realm, from, to address, amount uint64) {
	spender := caller(cur)
	if !from.IsValid() || !to.IsValid() {
		panic(errZeroAddress)
	}
	allowed := allowances[from][spender]
	if allowed < amount {
		panic(errAllowanceLow)
	}
	if err := transfer(from, to, amount); err != nil {
		panic(err)
	}
	allowances[from][spender] = allowed - amount
}

// transfer is the internal, non-crossing balance mover. Pure logic on package
// state; returns an error rather than panicking so callers control reverts.
func transfer(from, to address, amount uint64) error {
	if amount == 0 {
		return nil
	}
	if balances[from] < amount {
		return errInsufficient
	}
	balances[from] -= amount
	balances[to] += amount
	return nil
}

// BalanceOf returns the token balance of `holder`. Read-only, non-crossing.
func BalanceOf(holder address) uint64 {
	return balances[holder]
}

// Allowance returns how much `spender` may still pull from `owner`.
func Allowance(owner, spender address) uint64 {
	return allowances[owner][spender]
}

// TotalSupply returns the total number of tokens in existence.
func TotalSupply() uint64 {
	return totalSupply
}

// Name returns the token name.
func Name() string { return name }

// Symbol returns the token symbol.
func Symbol() string { return symbol }

// Render produces the gnoweb Markdown view of the token: metadata plus a
// deterministically-ordered table of non-zero balances. Render is NOT a
// crossing function (no `cur realm` parameter).
func Render(path string) string {
	var b strings.Builder

	b.WriteString("# " + name + " (" + symbol + ")\n\n")
	b.WriteString("A minimal ERC-20-style fungible token on gno.land.\n\n")
	b.WriteString("- **Name:** " + name + "\n")
	b.WriteString("- **Symbol:** " + symbol + "\n")
	b.WriteString("- **Total supply:** " + strconv.FormatUint(totalSupply, 10) + "\n\n")

	// Collect and sort holder addresses for deterministic output. Map iteration
	// order is not a stable contract, so we sort the string keys (gno's sort
	// package has no generic Slice; Strings is the deterministic primitive).
	keys := make([]string, 0, len(balances))
	byKey := make(map[string]uint64, len(balances))
	for addr, bal := range balances {
		if bal == 0 {
			continue
		}
		s := addr.String()
		keys = append(keys, s)
		byKey[s] = bal
	}
	sort.Strings(keys)

	b.WriteString("## Balances\n\n")
	if len(keys) == 0 {
		b.WriteString("_No holders yet — call `Mint` to create tokens._\n")
		return b.String()
	}

	b.WriteString("| Address | Amount |\n")
	b.WriteString("| --- | ---: |\n")
	for _, k := range keys {
		b.WriteString("| `" + k + "` | " +
			strconv.FormatUint(byKey[k], 10) + " |\n")
	}

	return b.String()
}

gnomod.toml

module = "gno.land/r/moul/x/daily/erc20/v0"
gno = "0.9"

[addpkg]
  creator = "g1manfred47kzduec920z88wfr64ylksmdcedlf5"
  height = 26016
  max_deposit = "100000000ugnot"