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

erc1155.gno

// Package erc1155 is an idiomatic gno.land port of the Solidity ERC-1155
// multi-token standard. A single realm tracks many distinct token ids, each
// with its own fungible balances. Balances are keyed by (owner, id) in an
// avl.Tree so Render can iterate deterministically.
package erc1155

import (
	"strconv"
	"strings"

	"chain"
	"chain/runtime/unsafe"

	"gno.land/p/nt/avl/v0"
)

// balances maps "<owner>:<id>" -> uint64 amount.
var balances avl.Tree

// supply maps "<id>" -> uint64 total minted for that id.
var supply avl.Tree

func balKey(owner address, id int) string {
	return owner.String() + ":" + strconv.Itoa(id)
}

func supKey(id int) string {
	return strconv.Itoa(id)
}

func getBalance(owner address, id int) uint64 {
	k := balKey(owner, id)
	if !balances.Has(k) {
		return 0
	}
	return balances.Get(k).(uint64)
}

func setBalance(owner address, id int, amount uint64) {
	k := balKey(owner, id)
	if amount == 0 {
		balances.Remove(k)
		return
	}
	balances.Set(k, amount)
}

func getSupply(id int) uint64 {
	k := supKey(id)
	if !supply.Has(k) {
		return 0
	}
	return supply.Get(k).(uint64)
}

// Mint creates `amount` units of token `id` and credits them to `to`.
func Mint(cur realm, to address, id int, amount uint64) {
	if !to.IsValid() {
		panic("erc1155: mint to invalid address")
	}
	if amount == 0 {
		panic("erc1155: mint amount must be > 0")
	}
	setBalance(to, id, getBalance(to, id)+amount)
	supply.Set(supKey(id), getSupply(id)+amount)

	operator := unsafe.PreviousRealm().Address()
	chain.Emit("Mint",
		"operator", operator.String(),
		"to", to.String(),
		"id", strconv.Itoa(id),
		"amount", strconv.FormatUint(amount, 10),
	)
}

// TransferSingle moves `amount` of token `id` from the caller to `to`.
func TransferSingle(cur realm, to address, id int, amount uint64) {
	if !to.IsValid() {
		panic("erc1155: transfer to invalid address")
	}
	if amount == 0 {
		panic("erc1155: transfer amount must be > 0")
	}
	from := unsafe.PreviousRealm().Address()
	fromBal := getBalance(from, id)
	if fromBal < amount {
		panic("erc1155: insufficient balance")
	}
	setBalance(from, id, fromBal-amount)
	setBalance(to, id, getBalance(to, id)+amount)

	chain.Emit("TransferSingle",
		"from", from.String(),
		"to", to.String(),
		"id", strconv.Itoa(id),
		"amount", strconv.FormatUint(amount, 10),
	)
}

// BalanceOf returns the amount of token `id` held by `owner`.
func BalanceOf(owner address, id int) uint64 {
	return getBalance(owner, id)
}

// TotalSupply returns the total amount minted of token `id`.
func TotalSupply(id int) uint64 {
	return getSupply(id)
}

// Render prints a balances table and a per-id supply table.
func Render(path string) string {
	var b strings.Builder
	b.WriteString("# ERC-1155 Multi-Token\n\n")
	b.WriteString("A single realm holding many fungible token ids. ")
	b.WriteString("Balances are keyed by `(owner, id)`.\n\n")

	b.WriteString("## Balances\n\n")
	if balances.Size() == 0 {
		b.WriteString("_No balances yet. Call `Mint` to create tokens._\n\n")
	} else {
		b.WriteString("| Owner | ID | Amount |\n")
		b.WriteString("|---|---|---|\n")
		balances.Iterate("", "", func(key string, value interface{}) bool {
			owner, id := splitBalKey(key)
			b.WriteString("| `" + owner + "` | " + id + " | " +
				strconv.FormatUint(value.(uint64), 10) + " |\n")
			return false
		})
		b.WriteString("\n")
	}

	b.WriteString("## Supply per ID\n\n")
	if supply.Size() == 0 {
		b.WriteString("_No tokens minted._\n")
	} else {
		b.WriteString("| ID | Total Supply |\n")
		b.WriteString("|---|---|\n")
		supply.Iterate("", "", func(key string, value interface{}) bool {
			b.WriteString("| " + key + " | " +
				strconv.FormatUint(value.(uint64), 10) + " |\n")
			return false
		})
	}

	return b.String()
}

// splitBalKey splits a "<owner>:<id>" balance key. The owner (a bech32
// address) contains no ':', so the id is the substring after the last ':'.
func splitBalKey(key string) (owner, id string) {
	i := strings.LastIndex(key, ":")
	if i < 0 {
		return key, ""
	}
	return key[:i], key[i+1:]
}

gnomod.toml

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

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