Playground
gnomod.toml
module = "gno.land/r/moul/x/daily/wrapped/v0" gno = "0.9" [addpkg] creator = "g1manfred47kzduec920z88wfr64ylksmdcedlf5" height = 26416 max_deposit = "100000000ugnot"
wrapped.gno
// Package wrapped is an accounting-only port of Wrapped Ether (WETH).
//
// The canonical WETH contract lets anyone lock native ETH and mint a 1:1
// ERC-20 representation (and burn it back). On gno.land / sapphire there is no
// msg.value / payable, so there is NO real coin transfer here: Deposit and
// Withdraw are pure accounting operations that model the wrap/unwrap. Balances
// and totalSupply are plain uint64 ledgers kept in an avl.Tree.
package wrapped
import (
"strconv"
"chain"
"chain/runtime/unsafe"
"gno.land/p/nt/avl/v0"
)
// balances maps owner address (string) -> wrapped balance (uint64).
var (
balances avl.Tree
totalSupply uint64
)
// Deposit wraps `amount` units of the (notional) native coin, crediting the
// caller's wrapped balance and the global totalSupply. Accounting only: no real
// coin ever moves — it models locking native funds to mint the wrapped token.
func Deposit(cur realm, amount uint64) {
if amount == 0 {
panic("wrapped: deposit amount must be > 0")
}
owner := unsafe.PreviousRealm().Address()
setBalance(owner, balanceOf(owner)+amount)
totalSupply += amount
chain.Emit("Deposit", "dst", owner.String(), "wad", strconv.FormatUint(amount, 10))
}
// Withdraw unwraps `amount` units, burning them from the caller's balance and
// from totalSupply. Panics if the caller lacks the balance.
func Withdraw(cur realm, amount uint64) {
if amount == 0 {
panic("wrapped: withdraw amount must be > 0")
}
owner := unsafe.PreviousRealm().Address()
bal := balanceOf(owner)
if bal < amount {
panic("wrapped: insufficient balance")
}
setBalance(owner, bal-amount)
totalSupply -= amount
chain.Emit("Withdrawal", "src", owner.String(), "wad", strconv.FormatUint(amount, 10))
}
// Transfer moves `amount` wrapped units from the caller to `to`.
func Transfer(cur realm, to address, amount uint64) {
if amount == 0 {
panic("wrapped: transfer amount must be > 0")
}
from := unsafe.PreviousRealm().Address()
if from == to {
panic("wrapped: cannot transfer to self")
}
fromBal := balanceOf(from)
if fromBal < amount {
panic("wrapped: insufficient balance")
}
setBalance(from, fromBal-amount)
setBalance(to, balanceOf(to)+amount)
chain.Emit("Transfer", "src", from.String(), "dst", to.String(), "wad", strconv.FormatUint(amount, 10))
}
// balanceOf returns the wrapped balance of `owner` (read-only, not crossing).
func balanceOf(owner address) uint64 {
v := balances.Get(owner.String())
if v == nil {
return 0
}
return v.(uint64)
}
// BalanceOf is the exported read-only accessor for a single owner.
func BalanceOf(owner address) uint64 { return balanceOf(owner) }
// TotalSupply returns the total amount of wrapped units in existence.
func TotalSupply() uint64 { return totalSupply }
func setBalance(owner address, amount uint64) {
if amount == 0 {
balances.Remove(owner.String())
return
}
balances.Set(owner.String(), amount)
}
// ---- pure/read-only helpers (unit-tested) ----
// canDebit reports whether `bal` can cover `amount` for a burn/transfer.
func canDebit(bal, amount uint64) bool {
return amount > 0 && bal >= amount
}
// formatUnits renders a raw uint64 amount as a decimal string.
func formatUnits(n uint64) string {
return strconv.FormatUint(n, 10)
}
// Render shows the total supply and a table of non-zero balances.
func Render(path string) string {
out := "# Wrapped (WETH-style, accounting-only)\n\n"
out += "Deposit mints wrapped units, Withdraw burns them. No real coins move — this is a pure ledger.\n\n"
out += "**Total supply:** " + formatUnits(totalSupply) + "\n\n"
if balances.Size() == 0 {
out += "_No balances yet. Call `Deposit` to wrap some units._\n"
return out
}
out += "| Owner | Balance |\n|---|---:|\n"
balances.Iterate("", "", func(key string, value interface{}) bool {
out += "| `" + key + "` | " + formatUnits(value.(uint64)) + " |\n"
return false
})
return out
}