Playground
gnomod.toml
module = "gno.land/r/demo/defi/grc20factory" gno = "0.9" [addpkg] creator = "g1edq4dugw0sgat4zxcw9xardvuydqf6cgleuc8p"
grc20factory.gno
package grc20factory
import (
"gno.land/p/moul/md/v0"
p "gno.land/p/nt/avl/pager/v0"
"gno.land/p/nt/avl/rotree/v0"
"gno.land/p/nt/avl/v0"
"gno.land/p/nt/grc20/v0"
"gno.land/p/nt/mux/v0"
"gno.land/p/nt/ownable/v0"
"gno.land/p/nt/seqid/v0"
"gno.land/p/nt/ufmt/v0"
"gno.land/r/nt/grc20reg/v0"
)
var (
instances avl.Tree // symbol -> *instance
nextTokenID seqid.ID
pager = p.NewPager(rotree.Wrap(&instances, nil), 20, false)
)
type instance struct {
token *grc20.Token
ledger *grc20.PrivateLedger
admin *ownable.Ownable
faucet int64 // per-request amount. disabled if 0.
}
func New(cur realm, name, symbol string, decimals int, initialMint, faucet int64) {
caller := cur.Previous().Address()
NewWithAdmin(cur, name, symbol, decimals, initialMint, faucet, caller)
}
func NewWithAdmin(cur realm, name, symbol string, decimals int, initialMint, faucet int64, admin address) {
exists := instances.Has(symbol)
if exists {
panic("token already exists")
}
token, ledger := grc20.NewToken(name, symbol, decimals, nextTokenID.Next(), cur)
if initialMint > 0 {
ledger.Mint(admin, initialMint)
}
inst := instance{
token: token,
ledger: ledger,
admin: ownable.NewWithAddress(admin),
faucet: faucet,
}
instances.Set(symbol, &inst)
grc20reg.Register(cross(cur), token, symbol)
}
func Bank(symbol string) *grc20.Token {
inst := mustGetInstance(symbol)
return inst.token
}
func TotalSupply(symbol string) int64 {
inst := mustGetInstance(symbol)
return inst.token.ReadonlyTeller().TotalSupply()
}
func HasAddr(symbol string, owner address) bool {
inst := mustGetInstance(symbol)
return inst.token.HasAddr(owner)
}
func BalanceOf(symbol string, owner address) int64 {
inst := mustGetInstance(symbol)
return inst.token.ReadonlyTeller().BalanceOf(owner)
}
func Allowance(symbol string, owner, spender address) int64 {
inst := mustGetInstance(symbol)
return inst.token.ReadonlyTeller().Allowance(owner, spender)
}
func Transfer(cur realm, symbol string, to address, amount int64) {
inst := mustGetInstance(symbol)
caller := cur.Previous().Address()
teller := inst.ledger.ImpersonateTeller(caller)
checkErr(teller.Transfer(0, cur, to, amount))
}
func Approve(cur realm, symbol string, spender address, amount int64) {
inst := mustGetInstance(symbol)
caller := cur.Previous().Address()
teller := inst.ledger.ImpersonateTeller(caller)
checkErr(teller.Approve(0, cur, spender, amount))
}
func TransferFrom(cur realm, symbol string, from, to address, amount int64) {
inst := mustGetInstance(symbol)
caller := cur.Previous().Address()
teller := inst.ledger.ImpersonateTeller(caller)
checkErr(teller.TransferFrom(0, cur, from, to, amount))
}
// faucet.
func Faucet(cur realm, symbol string) {
inst := mustGetInstance(symbol)
if inst.faucet == 0 {
panic("faucet disabled for this token")
}
// FIXME: add limits?
// FIXME: add payment in gnot?
caller := cur.Previous().Address()
checkErr(inst.ledger.Mint(caller, inst.faucet))
}
func Mint(cur realm, symbol string, to address, amount int64) {
inst := mustGetInstance(symbol)
inst.admin.AssertOwnedBy(cur.Previous().Address())
checkErr(inst.ledger.Mint(to, amount))
}
func Burn(cur realm, symbol string, from address, amount int64) {
inst := mustGetInstance(symbol)
inst.admin.AssertOwnedBy(cur.Previous().Address())
checkErr(inst.ledger.Burn(from, amount))
}
// instance admin functionality
func DropInstanceOwnership(cur realm, symbol string) {
inst := mustGetInstance(symbol)
checkErr(inst.admin.DropOwnership(0, cur))
}
func TransferInstanceOwnership(cur realm, symbol string, newOwner address) {
inst := mustGetInstance(symbol)
checkErr(inst.admin.TransferOwnership(0, cur, newOwner))
}
func ListTokens(pageNumber, pageSize int) []*grc20.Token {
page := pager.GetPageWithSize(pageNumber, pageSize)
tokens := make([]*grc20.Token, len(page.Items))
for i := range page.Items {
tokens[i] = page.Items[i].Value.(*instance).token
}
return tokens
}
func Render(path string) string {
router := mux.NewRouter()
router.HandleFunc("", renderHome)
router.HandleFunc("{symbol}", renderToken)
router.HandleFunc("{symbol}/balance/{address}", renderBalance)
return router.Render(path)
}
func renderHome(res *mux.ResponseWriter, req *mux.Request) {
out := md.H1(ufmt.Sprintf("GRC20 Tokens (%d)", instances.Size()))
// Get the current page of tokens based on the request path.
page := pager.MustGetPageByPath(req.RawPath)
// Render the list of tokens.
for _, item := range page.Items {
token := item.Value.(*instance).token
out += md.BulletItem(
md.Link(
ufmt.Sprintf("%s ($%s)", token.GetName(), token.GetSymbol()),
ufmt.Sprintf("/r/demo/grc20factory:%s", token.GetSymbol()),
),
)
}
out += "\n"
// Add the page picker.
out += md.Paragraph(page.Picker(req.Path))
res.Write(out)
}
func renderToken(res *mux.ResponseWriter, req *mux.Request) {
// Get the token symbol from the request.
symbol := req.GetVar("symbol")
inst := mustGetInstance(symbol)
// Render the token details.
out := inst.token.RenderHome()
out += md.BulletItem(
ufmt.Sprintf("%s: %s", md.Bold("Admin"), inst.admin.Owner()),
)
res.Write(out)
}
func renderBalance(res *mux.ResponseWriter, req *mux.Request) {
var (
symbol = req.GetVar("symbol")
addr = req.GetVar("address")
)
// Get the balance of the specified address for the token.
inst := mustGetInstance(symbol)
balance := inst.token.BalanceOf(address(addr))
// Render the balance information.
out := md.Paragraph(
ufmt.Sprintf("%s balance: %d", md.Bold(addr), balance),
)
res.Write(out)
}
func mustGetInstance(symbol string) *instance {
t := instances.Get(symbol)
if t == nil {
panic("token instance does not exist")
}
return t.(*instance)
}
func checkErr(err error) {
if err != nil {
panic(err.Error())
}
}
grc20factory_test.gno
package grc20factory
import (
"testing"
"gno.land/p/nt/testutils/v0"
"gno.land/p/nt/uassert/v0"
"gno.land/p/nt/ufmt/v0"
)
func TestReadOnlyPublicMethods(cur realm, t *testing.T) {
admin := testutils.TestAddress("admin")
bob := testutils.TestAddress("bob")
carl := testutils.TestAddress("carl")
type test struct {
name string
balance int64
fn func() int64
}
checkBalances := func(step string, totSup, balAdm, balBob, allowAdmBob, balCarl int64) {
tests := []test{
{"TotalSupply", totSup, func() int64 { return TotalSupply("FOO") }},
{"BalanceOf(admin)", balAdm, func() int64 { return BalanceOf("FOO", admin) }},
{"BalanceOf(bob)", balBob, func() int64 { return BalanceOf("FOO", bob) }},
{"Allowance(admin, bob)", allowAdmBob, func() int64 { return Allowance("FOO", admin, bob) }},
{"BalanceOf(carl)", balCarl, func() int64 { return BalanceOf("FOO", carl) }},
}
for _, tc := range tests {
reason := ufmt.Sprintf("%s.%s - %s", step, tc.name, "balances do not match")
uassert.Equal(t, tc.balance, tc.fn(), reason)
}
}
// admin creates FOO and BAR.
testing.SetOriginCaller(admin)
NewWithAdmin(cross(cur), "Foo", "FOO", 3, 1_111_111_000, 5_555, admin)
NewWithAdmin(cross(cur), "Bar", "BAR", 3, 2_222_000, 6_666, admin)
uassert.Equal(t, Bank("FOO").ID(), "gno.land/r/demo/defi/grc20factory.FOO.0000001")
uassert.Equal(t, Bank("BAR").ID(), "gno.land/r/demo/defi/grc20factory.BAR.0000002")
checkBalances("step1", 1_111_111_000, 1_111_111_000, 0, 0, 0)
// admin mints to bob.
mustGetInstance("FOO").ledger.Mint(bob, 333_333_000)
checkBalances("step2", 1_444_444_000, 1_111_111_000, 333_333_000, 0, 0)
// carl uses the faucet.
testing.SetOriginCaller(carl)
Faucet(cross(cur), "FOO")
checkBalances("step3", 1_444_449_555, 1_111_111_000, 333_333_000, 0, 5_555)
// admin gives to bob some allowance.
testing.SetOriginCaller(admin)
Approve(cross(cur), "FOO", bob, 1_000_000)
checkBalances("step4", 1_444_449_555, 1_111_111_000, 333_333_000, 1_000_000, 5_555)
// bob uses a part of the allowance.
testing.SetOriginCaller(bob)
TransferFrom(cross(cur), "FOO", admin, carl, 400_000)
checkBalances("step5", 1_444_449_555, 1_110_711_000, 333_333_000, 600_000, 405_555)
// bob uses a part of the allowance.
testing.SetOriginCaller(bob)
TransferFrom(cross(cur), "FOO", admin, carl, 600_000)
checkBalances("step6", 1_444_449_555, 1_110_111_000, 333_333_000, 0, 1_005_555)
}