Playground
gnomod.toml
module = "gno.land/r/g1sw5xklxjjuv0yvuxy5f5s3l3mnj0nqq626a9wr/million/v0" gno = "0.9" [addpkg] creator = "g1sw5xklxjjuv0yvuxy5f5s3l3mnj0nqq626a9wr" height = 241885 max_deposit = "20000000ugnot"
million.gno
// Package million is a pay-per-pixel collaborative canvas: anyone can paint
// any pixel of a Width x Height grid in one of 15 colors by sending exactly
// Price() ugnot per pixel along with the call. Pixels can be repainted by
// anyone, for the same price. Payments are forwarded to the admin wallet
// as they arrive, and the admin paints for free.
//
// The grid logic lives in gno.land/p/g1sw5xklxjjuv0yvuxy5f5s3l3mnj0nqq626a9wr/canvas/v0; this realm adds the
// payment guard, the owner controls and the read API used by the web client.
package million
import (
"chain"
"chain/banker"
"chain/runtime/unsafe"
"strconv"
"strings"
"gno.land/p/g1sw5xklxjjuv0yvuxy5f5s3l3mnj0nqq626a9wr/canvas/v0"
"gno.land/p/nt/ufmt/v0"
)
const (
// Width and Height are fixed for the life of this version: changing
// them would change the storage layout, so it means a new /vN.
// 1250 x 800 is one million pixels in a 16:10 laptop aspect ratio.
Width = 1250
Height = 800
// MaxBatch bounds a single PaintBatch call so one tx cannot blow the
// block gas limit or overflow the price arithmetic.
MaxBatch = 500
// DefaultPrice is the initial price per pixel, in ugnot (0.05 GNOT).
DefaultPrice int64 = 50_000
// DefaultAdmin receives every payment, paints for free and holds the
// owner controls. Change it before deploying; TransferOwnership moves
// it afterwards.
DefaultAdmin = "g1sw5xklxjjuv0yvuxy5f5s3l3mnj0nqq626a9wr"
Denom = "ugnot"
)
var (
board = canvas.New(Width, Height)
price = DefaultPrice
owner = address(DefaultAdmin)
// Stats.
revenue int64 // total ugnot ever paid for pixels
paints int64 // number of successful Paint/PaintBatch calls
// Change tracking, so clients fetch only the rows that moved.
// version bumps once per successful paint call; rowVersion holds the
// version of the last paint that touched each row (0 = never painted).
version int64
rowVersion = make([]int64, Height)
)
// Paint colors one pixel. Send exactly Price() ugnot (nothing for the admin).
func Paint(cur realm, x, y, color int) {
if color <= 0 || color > int(canvas.MaxColor) {
panic(canvas.ErrInvalidColor)
}
paint([]canvas.Pixel{{X: x, Y: y, Color: byte(color)}}, cur)
}
// PaintBatch colors up to MaxBatch pixels in one call. The argument is
// "x,y,color;x,y,color;...". Send exactly Price() * count ugnot (nothing
// for the admin).
func PaintBatch(cur realm, pixels string) {
px, err := canvas.ParsePixels(pixels)
if err != nil {
panic(err)
}
paint(px, cur)
}
// paint takes the realm as its LAST parameter on purpose: a realm first
// parameter would make it a crossing function and Previous() would then
// be this realm instead of the user.
func paint(px []canvas.Pixel, rlm realm) {
if !rlm.IsCurrent() {
panic("spoofed realm")
}
// Payment guard: unsafe.OriginSend() describes the coins attached to
// the transaction, which only provably landed here when the caller is
// a plain user call (no intermediate or ephemeral realm). Keep the two
// checks together. unsafe is imported for OriginSend only; caller
// identity always comes from the realm handle.
if !rlm.Previous().IsUserCall() {
panic("must be called directly by a user (maketx call)")
}
painter := rlm.Previous().Address()
n := len(px)
if n == 0 {
panic("nothing to paint")
}
if n > MaxBatch {
panic(ufmt.Sprintf("too many pixels: %d > %d", n, MaxBatch))
}
for _, p := range px {
if err := board.Check(p); err != nil {
panic(err)
}
}
cost := price * int64(n)
if painter == owner {
cost = 0 // the admin paints for free
}
if sent := sentUgnot(unsafe.OriginSend()); sent != cost {
panic(ufmt.Sprintf("must send exactly %d%s for %d pixel(s), got %d%s", cost, Denom, n, sent, Denom))
}
if cost > 0 {
// Forward the payment to the admin right away, so nothing
// accumulates in the realm. BankerTypeOriginSend can only move
// what this very message sent, which is exactly cost.
bnk := banker.NewBanker(banker.BankerTypeOriginSend, rlm)
bnk.SendCoins(rlm.Address(), owner, chain.NewCoins(chain.NewCoin(Denom, cost)))
}
version++
for _, p := range px {
board.Set(p)
rowVersion[p.Y] = version
}
revenue += cost
paints++
// The pixel list itself is not emitted: event attribute values are
// size-capped by the node and a full batch exceeds it. Clients re-read
// Rows() after a paint.
chain.Emit("Paint",
"painter", painter.String(),
"count", strconv.Itoa(n),
"paid", strconv.Itoa(int(cost))+Denom,
)
}
// sentUgnot returns the ugnot amount in coins and rejects any other denom,
// so a caller cannot pay with something the realm does not price.
func sentUgnot(coins chain.Coins) int64 {
var amount int64
for _, c := range coins {
if c.Denom != Denom {
panic("only " + Denom + " is accepted")
}
amount += c.Amount
}
return amount
}
// --- owner controls ---
// assertOwner panics unless the verified caller behind rlm is the owner.
// The realm is deliberately not the first parameter (see paint); the
// leading blank int is the same idiom gno.land/p/nt/ownable uses.
func assertOwner(_ int, rlm realm) {
if !rlm.IsCurrent() {
panic("spoofed realm")
}
if rlm.Previous().Address() != owner {
panic("owner only")
}
}
// SetPrice changes the price per pixel, in ugnot. Zero makes painting free
// for everyone.
func SetPrice(cur realm, ugnot int64) {
assertOwner(0, cur)
if ugnot < 0 {
panic("price must not be negative")
}
price = ugnot
}
// Withdraw sends amount ugnot held by the realm to the given address.
// Payments are forwarded on arrival, so this only matters for coins sent
// to the realm outside of a paint call.
func Withdraw(cur realm, to address, amount int64) {
assertOwner(0, cur)
if !to.IsValid() {
panic("invalid address")
}
if amount <= 0 {
panic("amount must be positive")
}
bnk := banker.NewBanker(banker.BankerTypeRealmSend, cur)
bnk.SendCoins(cur.Address(), to, chain.NewCoins(chain.NewCoin(Denom, amount)))
}
// TransferOwnership hands the admin role (payments, free painting and the
// owner controls) to newOwner.
func TransferOwnership(cur realm, newOwner address) {
assertOwner(0, cur)
if !newOwner.IsValid() {
panic("invalid address")
}
owner = newOwner
}
// --- read API (used by the web client through vm/qeval) ---
func GetWidth() int { return Width }
func GetHeight() int { return Height }
func Price() int64 { return price }
func Owner() address { return owner }
func Painted() int { return board.Painted() }
func Revenue() int64 { return revenue }
func Paints() int64 { return paints }
func MaxBatchSize() int { return MaxBatch }
// Pixel returns the color index at (x, y); 0 means never painted.
func Pixel(x, y int) int { return int(board.Get(x, y)) }
// Rows returns rows [from, to) as one hex digit per pixel, Width digits per
// row, with no separators. Clients page through the grid with it.
func Rows(from, to int) string { return board.Rows(from, to) }
// Version is the number of successful paint calls so far. Clients remember
// it and ask DirtyRows for what changed since.
func Version() int64 { return version }
// DirtyRows lists the rows painted after version `since`, as "y,y,y" in
// ascending order. DirtyRows(0) is every row that was ever painted, which
// is all a fresh client needs to load: the others are blank.
func DirtyRows(since int64) string {
if since < 0 {
since = 0
}
var sb strings.Builder
for y, v := range rowVersion {
if v <= since {
continue
}
if sb.Len() > 0 {
sb.WriteByte(',')
}
sb.WriteString(strconv.Itoa(y))
}
return sb.String()
}
// Palette returns the 16 palette colors as comma-separated CSS hex values,
// index 0 being the blank color.
func Palette() string {
return strings.Join(canvas.Palette[:], ",")
}
// Render shows the game stats on gnoweb. The path is ignored.
func Render(_ string) string {
var sb strings.Builder
sb.WriteString("# Million Gno\n\n")
sb.WriteString("A pay-per-pixel canvas. Pick a color, pay the price, own the pixel until someone repaints it. Payments go to the admin wallet, which paints for free.\n\n")
sb.WriteString("| | |\n|---|---|\n")
sb.WriteString(ufmt.Sprintf("| Size | %d x %d |\n", Width, Height))
sb.WriteString(ufmt.Sprintf("| Price per pixel | %d%s |\n", price, Denom))
sb.WriteString(ufmt.Sprintf("| Pixels painted | %d / %d |\n", board.Painted(), Width*Height))
sb.WriteString(ufmt.Sprintf("| Paint calls | %d |\n", paints))
sb.WriteString(ufmt.Sprintf("| Version | %d |\n", version))
sb.WriteString(ufmt.Sprintf("| Revenue | %d%s |\n", revenue, Denom))
sb.WriteString(ufmt.Sprintf("| Admin | %s |\n", owner.String()))
sb.WriteString("\n## Palette\n\n")
for i := 1; i <= int(canvas.MaxColor); i++ {
sb.WriteString(ufmt.Sprintf("- %d: `%s`\n", i, canvas.Palette[i]))
}
sb.WriteString("\n## Paint\n\n")
sb.WriteString("- [Paint one pixel](" + Realm + "$help&func=Paint): `Paint(x, y, color)` with `-send <price>ugnot`\n")
sb.WriteString("- [Paint a batch](" + Realm + "$help&func=PaintBatch): `PaintBatch(\"x,y,color;x,y,color\")` with `-send <price*count>ugnot`\n")
return sb.String()
}
// Realm is this realm's gnoweb path.
const Realm = "/r/g1sw5xklxjjuv0yvuxy5f5s3l3mnj0nqq626a9wr/million/v0"
million_test.gno
package million
import (
"strings"
"testing"
"chain"
"chain/banker"
"gno.land/p/nt/testutils/v0"
"gno.land/p/nt/uassert/v0"
)
var (
deployer = testutils.TestAddress("deployer")
alice = testutils.TestAddress("alice")
bob = testutils.TestAddress("bob")
)
var realmAddr = chain.PackageAddress("gno.land/r/g1sw5xklxjjuv0yvuxy5f5s3l3mnj0nqq626a9wr/million/v0")
// Tests own the admin role through a test address rather than DefaultAdmin.
func init() {
owner = deployer
}
// fund credits the realm with what the next paint call claims to send, as
// the chain would before running the message, and resets the per-message
// origin-send spending limit that the previous call used up.
func fund(n int64) {
testing.SetOriginSpend(nil)
if n > 0 {
testing.IssueCoins(realmAddr, ugnot(n))
}
}
func balanceOf(a address) int64 {
return banker.NewReadonlyBanker().GetCoin(a, Denom)
}
func ugnot(n int64) chain.Coins {
return chain.NewCoins(chain.NewCoin(Denom, n))
}
// testing.SetRealm only affects the frame that calls it, so it cannot be
// wrapped in a helper: every test sets the caller inline.
func TestInitialState(t *testing.T) {
uassert.Equal(t, Width, GetWidth())
uassert.Equal(t, Height, GetHeight())
uassert.Equal(t, DefaultPrice, Price())
uassert.Equal(t, MaxBatch, MaxBatchSize())
uassert.Equal(t, 0, Pixel(0, 0))
uassert.Equal(t, deployer, Owner())
uassert.Equal(t, 16, len(strings.Split(Palette(), ",")))
}
func TestPaintOnePixel(cur realm, t *testing.T) {
adminBefore := balanceOf(owner)
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(price))
fund(price)
Paint(cross(cur), 10, 20, 6)
uassert.Equal(t, 6, Pixel(10, 20))
uassert.Equal(t, 1, Painted())
uassert.Equal(t, price, Revenue())
uassert.Equal(t, int64(1), Paints())
// The payment went straight to the admin, nothing stayed in the realm.
uassert.Equal(t, adminBefore+price, balanceOf(owner))
uassert.Equal(t, int64(0), balanceOf(realmAddr))
// Anyone can repaint for the same price; the count does not grow.
testing.SetRealm(testing.NewUserRealm(bob))
testing.SetOriginSend(ugnot(price))
fund(price)
Paint(cross(cur), 10, 20, 15)
uassert.Equal(t, 15, Pixel(10, 20))
uassert.Equal(t, 1, Painted())
uassert.Equal(t, 2*price, Revenue())
uassert.Equal(t, adminBefore+2*price, balanceOf(owner))
}
func TestAdminPaintsForFree(cur realm, t *testing.T) {
adminBefore := balanceOf(owner)
revenueBefore := Revenue()
testing.SetRealm(testing.NewUserRealm(owner))
testing.SetOriginSend(nil)
Paint(cross(cur), 400, 400, 8)
uassert.Equal(t, 8, Pixel(400, 400))
testing.SetRealm(testing.NewUserRealm(owner))
testing.SetOriginSend(nil)
PaintBatch(cross(cur), "401,400,9;402,400,10")
uassert.Equal(t, 10, Pixel(402, 400))
// Free means exactly free: the admin must not attach coins either.
testing.SetRealm(testing.NewUserRealm(owner))
testing.SetOriginSend(ugnot(price))
uassert.AbortsContains(t, cur, "must send exactly 0ugnot", func() { Paint(cross(cur), 403, 400, 1) })
uassert.Equal(t, revenueBefore, Revenue())
uassert.Equal(t, adminBefore, balanceOf(owner))
}
func TestPaintRejectsWrongPayment(cur realm, t *testing.T) {
before := Painted()
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(price-1))
uassert.AbortsContains(t, cur, "must send exactly", func() { Paint(cross(cur), 0, 0, 1) })
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(price+1))
uassert.AbortsContains(t, cur, "must send exactly", func() { Paint(cross(cur), 0, 0, 1) })
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(nil)
uassert.AbortsContains(t, cur, "must send exactly", func() { Paint(cross(cur), 0, 0, 1) })
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(chain.NewCoins(chain.NewCoin("uatom", price)))
uassert.AbortsContains(t, cur, "only ugnot is accepted", func() { Paint(cross(cur), 0, 0, 1) })
uassert.Equal(t, before, Painted())
uassert.Equal(t, 0, Pixel(0, 0))
}
func TestPaintRejectsInvalidPixels(cur realm, t *testing.T) {
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(price))
uassert.AbortsContains(t, cur, "out of range", func() { Paint(cross(cur), Width, 0, 1) })
uassert.AbortsContains(t, cur, "out of range", func() { Paint(cross(cur), 0, Height, 1) })
uassert.AbortsContains(t, cur, "out of range", func() { Paint(cross(cur), -1, 0, 1) })
uassert.AbortsContains(t, cur, "color must be", func() { Paint(cross(cur), 0, 0, 0) })
uassert.AbortsContains(t, cur, "color must be", func() { Paint(cross(cur), 0, 0, 16) })
uassert.AbortsContains(t, cur, "color must be", func() { Paint(cross(cur), 0, 0, -1) })
}
func TestPaintRejectsCodeRealm(cur realm, t *testing.T) {
// Regression for the OriginSend bypass: an intermediate realm forwards
// the call while the envelope claims the coins were sent.
testing.SetRealm(testing.NewCodeRealm("gno.land/r/attacker/wrapper"))
testing.SetOriginSend(ugnot(price))
uassert.AbortsContains(t, cur, "directly by a user", func() { Paint(cross(cur), 1, 1, 1) })
uassert.Equal(t, 0, Pixel(1, 1))
}
func TestPaintBatch(cur realm, t *testing.T) {
before := Painted()
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(3 * price))
fund(3 * price)
PaintBatch(cross(cur), "100,100,1;101,100,2;102,100,3;")
uassert.Equal(t, 1, Pixel(100, 100))
uassert.Equal(t, 2, Pixel(101, 100))
uassert.Equal(t, 3, Pixel(102, 100))
uassert.Equal(t, before+3, Painted())
row := Rows(100, 101)
uassert.Equal(t, Width, len(row))
uassert.Equal(t, "123", row[100:103])
}
func TestPaintBatchIsAtomic(cur realm, t *testing.T) {
// One bad pixel rejects the whole batch before anything is written.
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(2*price))
uassert.AbortsContains(t, cur, "out of range", func() { PaintBatch(cross(cur), "200,200,1;9999,0,1") })
uassert.Equal(t, 0, Pixel(200, 200))
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(price))
uassert.AbortsContains(t, cur, "must send exactly", func() { PaintBatch(cross(cur), "200,200,1;201,200,1") })
uassert.Equal(t, 0, Pixel(200, 200))
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(price))
uassert.AbortsContains(t, cur, "x,y,color", func() { PaintBatch(cross(cur), "garbage") })
uassert.AbortsContains(t, cur, "x,y,color", func() { PaintBatch(cross(cur), "") })
}
func TestPaintBatchTooLarge(cur realm, t *testing.T) {
var sb strings.Builder
for i := 0; i <= MaxBatch; i++ {
if i > 0 {
sb.WriteByte(';')
}
sb.WriteString("0,")
sb.WriteString(itoa(i))
sb.WriteString(",1")
}
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(int64(MaxBatch+1)*price))
uassert.AbortsContains(t, cur, "too many pixels", func() { PaintBatch(cross(cur), sb.String()) })
}
func TestSetPrice(cur realm, t *testing.T) {
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(nil)
uassert.AbortsWithMessage(t, cur, "owner only", func() { SetPrice(cross(cur), 1) })
testing.SetRealm(testing.NewUserRealm(owner))
testing.SetOriginSend(nil)
uassert.AbortsWithMessage(t, cur, "price must not be negative", func() { SetPrice(cross(cur), -1) })
SetPrice(cross(cur), 0)
uassert.Equal(t, int64(0), Price())
// Free painting requires sending nothing.
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(nil)
Paint(cross(cur), 300, 300, 4)
uassert.Equal(t, 4, Pixel(300, 300))
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(1))
uassert.AbortsContains(t, cur, "must send exactly", func() { Paint(cross(cur), 300, 301, 4) })
testing.SetRealm(testing.NewUserRealm(owner))
testing.SetOriginSend(nil)
SetPrice(cross(cur), DefaultPrice)
}
func TestWithdraw(cur realm, t *testing.T) {
testing.IssueCoins(realmAddr, ugnot(1_000))
ro := banker.NewReadonlyBanker()
bobBefore := ro.GetCoin(bob, Denom)
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(nil)
uassert.AbortsWithMessage(t, cur, "owner only", func() { Withdraw(cross(cur), alice, 1) })
testing.SetRealm(testing.NewUserRealm(owner))
testing.SetOriginSend(nil)
uassert.AbortsWithMessage(t, cur, "amount must be positive", func() { Withdraw(cross(cur), bob, 0) })
uassert.AbortsWithMessage(t, cur, "invalid address", func() { Withdraw(cross(cur), address("nope"), 1) })
Withdraw(cross(cur), bob, 600)
uassert.Equal(t, bobBefore+600, ro.GetCoin(bob, Denom))
uassert.Equal(t, int64(400), ro.GetCoin(realmAddr, Denom))
// Leave the realm empty for the tests that assert on it.
Withdraw(cross(cur), bob, 400)
}
func TestTransferOwnership(cur realm, t *testing.T) {
original := owner
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(nil)
uassert.AbortsWithMessage(t, cur, "owner only", func() { TransferOwnership(cross(cur), alice) })
testing.SetRealm(testing.NewUserRealm(original))
testing.SetOriginSend(nil)
uassert.AbortsWithMessage(t, cur, "invalid address", func() { TransferOwnership(cross(cur), address("nope")) })
TransferOwnership(cross(cur), alice)
uassert.Equal(t, alice, Owner())
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(nil)
TransferOwnership(cross(cur), original)
uassert.Equal(t, original, Owner())
}
func TestVersionAndDirtyRows(cur realm, t *testing.T) {
v := Version()
uassert.Equal(t, "", DirtyRows(v))
testing.SetRealm(testing.NewUserRealm(alice))
testing.SetOriginSend(ugnot(3 * price))
fund(3 * price)
PaintBatch(cross(cur), "0,700,1;1,700,2;0,701,3")
uassert.Equal(t, v+1, Version())
uassert.Equal(t, "700,701", DirtyRows(v))
uassert.Equal(t, "", DirtyRows(Version()))
// A second call on one of those rows moves only that row forward.
testing.SetRealm(testing.NewUserRealm(bob))
testing.SetOriginSend(ugnot(price))
fund(price)
Paint(cross(cur), 5, 701, 4)
uassert.Equal(t, v+2, Version())
uassert.Equal(t, "701", DirtyRows(v+1))
uassert.Equal(t, "700,701", DirtyRows(v))
// A rejected paint changes nothing.
testing.SetRealm(testing.NewUserRealm(bob))
testing.SetOriginSend(ugnot(1))
uassert.AbortsContains(t, cur, "must send exactly", func() { Paint(cross(cur), 5, 702, 4) })
uassert.Equal(t, v+2, Version())
uassert.Equal(t, "", DirtyRows(v+2))
// Negative "since" behaves like zero: painted rows only, never blank ones.
uassert.Equal(t, DirtyRows(0), DirtyRows(-1))
uassert.True(t, !strings.Contains(","+DirtyRows(0)+",", ",799,"), "row 799 was never painted")
}
func TestRender(t *testing.T) {
out := Render("")
uassert.True(t, strings.Contains(out, "# Million Gno"), "title")
uassert.True(t, strings.Contains(out, "| Size | 1250 x 800 |"), "size row")
uassert.True(t, strings.Contains(out, "| Price per pixel | 50000ugnot |"), "price row")
uassert.True(t, strings.Contains(out, "| Admin | "+owner.String()+" |"), "admin row")
uassert.True(t, strings.Contains(out, "$help&func=PaintBatch"), "help link")
}
func itoa(n int) string {
if n == 0 {
return "0"
}
var b []byte
for n > 0 {
b = append([]byte{byte('0' + n%10)}, b...)
n /= 10
}
return string(b)
}