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

gnomod.toml

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

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

splitter.gno

// Package splitter is a share-based payment splitter for gno.land.
//
// It is an accounting-only port of the Solidity PaymentSplitter pattern:
// no real coins move. A group is registered with a list of payees and a
// matching list of integer shares. Income recorded against a group is
// pooled, and each payee is owed a slice of that pool proportional to
// their shares: owed = pool * share / totalShares.
package splitter

import (
	"errors"
	"strconv"
	"strings"

	"chain"
	"chain/runtime/unsafe"

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

// payee is a single share holder inside a group.
type payee struct {
	addr   address
	shares int
}

// group is one payment-splitting arrangement.
type group struct {
	id          int
	owner       address
	payees      []payee
	totalShares int
	pool        int // total income recorded, in abstract units
}

var (
	groups   avl.Tree // id (zero-padded string) -> *group
	nextID   int
	errEmpty = errors.New("splitter: no payees")
)

// Register creates a new group from comma-separated payees and shares.
// payees:  "g1abc...,g1def..."  (addresses)
// shares:  "3,1"                (positive integers, same count as payees)
// Returns the new group id. Panics on malformed input.
func Register(cur realm, payees string, shares string) int {
	caller := unsafe.PreviousRealm().Address()

	addrParts := splitTrim(payees)
	shareParts := splitTrim(shares)

	if len(addrParts) == 0 {
		panic(errEmpty)
	}
	if len(addrParts) != len(shareParts) {
		panic("splitter: payees and shares count mismatch")
	}

	g := &group{
		id:    nextID,
		owner: caller,
	}
	for i := range addrParts {
		if addrParts[i] == "" {
			panic("splitter: empty payee address")
		}
		s, err := strconv.Atoi(shareParts[i])
		if err != nil {
			panic("splitter: bad share value: " + shareParts[i])
		}
		if s <= 0 {
			panic("splitter: share must be positive")
		}
		g.payees = append(g.payees, payee{
			addr:   address(addrParts[i]),
			shares: s,
		})
		g.totalShares += s
	}

	groups.Set(key(g.id), g)
	nextID++

	chain.Emit(
		"GroupRegistered",
		"id", strconv.Itoa(g.id),
		"payees", strconv.Itoa(len(g.payees)),
		"totalShares", strconv.Itoa(g.totalShares),
	)
	return g.id
}

// RecordIncome adds amount to the pool of group id. amount must be positive.
func RecordIncome(cur realm, id int, amount int) {
	if amount <= 0 {
		panic("splitter: amount must be positive")
	}
	v := groups.Get(key(id))
	if v == nil {
		panic("splitter: unknown group id: " + strconv.Itoa(id))
	}
	g := v.(*group)
	g.pool += amount
	groups.Set(key(id), g)

	chain.Emit(
		"IncomeRecorded",
		"id", strconv.Itoa(id),
		"amount", strconv.Itoa(amount),
		"pool", strconv.Itoa(g.pool),
	)
}

// owed returns the amount owed to a payee: pool * shares / totalShares.
func (g *group) owed(p payee) int {
	if g.totalShares == 0 {
		return 0
	}
	return g.pool * p.shares / g.totalShares
}

// Render shows all groups, their payees, shares, and computed owed amounts.
func Render(path string) string {
	if groups.Size() == 0 {
		return "# Payment Splitter\n\n_No groups registered yet._\n"
	}

	var b strings.Builder
	b.WriteString("# Payment Splitter\n\n")
	b.WriteString("Share-based accounting. `owed = pool * share / totalShares`.\n\n")

	groups.Iterate("", "", func(k string, v interface{}) bool {
		g := v.(*group)
		b.WriteString("## Group #" + strconv.Itoa(g.id) + "\n\n")
		b.WriteString("- Owner: `" + g.owner.String() + "`\n")
		b.WriteString("- Pool: " + strconv.Itoa(g.pool) + "\n")
		b.WriteString("- Total shares: " + strconv.Itoa(g.totalShares) + "\n\n")

		b.WriteString("| Payee | Shares | Owed |\n")
		b.WriteString("|---|---:|---:|\n")
		distributed := 0
		for _, p := range g.payees {
			o := g.owed(p)
			distributed += o
			b.WriteString("| `" + p.addr.String() + "` | " +
				strconv.Itoa(p.shares) + " | " + strconv.Itoa(o) + " |\n")
		}
		remainder := g.pool - distributed
		if remainder > 0 {
			b.WriteString("| _remainder (rounding)_ | | " +
				strconv.Itoa(remainder) + " |\n")
		}
		b.WriteString("\n")
		return false
	})

	return b.String()
}

// splitTrim splits on commas and trims whitespace around each element.
func splitTrim(s string) []string {
	if strings.TrimSpace(s) == "" {
		return nil
	}
	parts := strings.Split(s, ",")
	out := make([]string, 0, len(parts))
	for _, p := range parts {
		out = append(out, strings.TrimSpace(p))
	}
	return out
}

// key produces a zero-padded, lexicographically-sortable avl key for an id,
// so Render iterates groups in ascending numeric order.
func key(id int) string {
	s := strconv.Itoa(id)
	for len(s) < 12 {
		s = "0" + s
	}
	return s
}