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/merkledrop/v0"
gno = "0.9"

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

merkledrop.gno

// Package merkledrop is an idiomatic gno.land port of the classic Solidity
// MerkleDistributor airdrop (Uniswap's contract, OpenZeppelin's MerkleProof).
//
// A fixed merkleRoot commits to a set of (address, amount) allocations. A
// recipient proves membership by supplying the sibling hashes on the path from
// their leaf up to the root. Each address may claim exactly once.
//
// Leaf and node hashing use crypto/sha256 (available in the gno stdlib), the
// same primitive Solidity distributors use via keccak — here sha256 keeps the
// off-chain tree builder trivially reproducible. Internal nodes hash the two
// children in sorted order (the OpenZeppelin "commutative" scheme), so proofs
// carry no left/right flags.
//
//	leaf   = sha256(addr.String() + "|" + amount)
//	node   = sha256(min(a,b) || max(a,b))
//
// Balances are pure accounting (uint64); no real coin moves — there is no
// msg.value on gno, so this models the allocation ledger only.
package merkledrop

import (
	"bytes"
	"crypto/sha256"
	"encoding/hex"
	"strconv"
	"strings"

	"chain"
	"chain/runtime/unsafe"

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

// merkleRoot commits to the airdrop allocation set. Generated off-chain with
// the exact scheme above over the four example recipients in README.md.
const merkleRoot = "0d00b73577019dc92924f0ae001d3e1839d51fb358adda2ad1510c39eb82b13f"

// claimed maps claimer address string -> claimed amount (uint64).
var claimed avl.Tree

// totalClaimed is the running sum of all claimed allocations.
var totalClaimed uint64

// leaf computes the tree leaf for an (address, amount) allocation.
func leaf(claimer address, amount uint64) []byte {
	data := claimer.String() + "|" + strconv.FormatUint(amount, 10)
	h := sha256.Sum256([]byte(data))
	return h[:]
}

// hashPair hashes two nodes in sorted order (commutative), so the proof does
// not need to encode child positions.
func hashPair(a, b []byte) []byte {
	var d []byte
	if bytes.Compare(a, b) <= 0 {
		d = append(append(d, a...), b...)
	} else {
		d = append(append(d, b...), a...)
	}
	h := sha256.Sum256(d)
	return h[:]
}

// parseProof splits a comma-separated list of hex hashes into raw 32-byte
// nodes, panicking on any malformed element.
func parseProof(proof string) [][]byte {
	proof = strings.TrimSpace(proof)
	if proof == "" {
		return nil
	}
	parts := strings.Split(proof, ",")
	out := make([][]byte, 0, len(parts))
	for _, p := range parts {
		p = strings.TrimSpace(p)
		if p == "" {
			continue
		}
		raw, err := hex.DecodeString(p)
		if err != nil {
			panic("merkledrop: bad proof hash: " + p)
		}
		if len(raw) != sha256.Size {
			panic("merkledrop: proof hash must be 32 bytes: " + p)
		}
		out = append(out, raw)
	}
	return out
}

// computeRoot walks the proof from the given leaf up to a candidate root and
// returns its hex encoding.
func computeRoot(leafHash []byte, proof [][]byte) string {
	node := leafHash
	for _, sib := range proof {
		node = hashPair(node, sib)
	}
	return hex.EncodeToString(node)
}

// Verify reports whether (claimer, amount, proof) resolves to merkleRoot. Pure
// and read-only — safe to call from tests and Render.
func Verify(claimer address, amount uint64, proof string) bool {
	got := computeRoot(leaf(claimer, amount), parseProof(proof))
	return got == merkleRoot
}

// AmountClaimed returns how much the address has already claimed (0 if none).
func AmountClaimed(claimer address) uint64 {
	if !claimed.Has(claimer.String()) {
		return 0
	}
	return claimed.Get(claimer.String()).(uint64)
}

// HasClaimed reports whether the address already claimed.
func HasClaimed(claimer address) bool {
	return claimed.Has(claimer.String())
}

// Claim proves the caller is entitled to `amount` via `proof` (comma-separated
// hex sibling hashes) and marks the allocation claimed. Panics on a bad proof
// or a double claim. Mirrors MerkleDistributor.claim (msg.sender is the caller).
func Claim(cur realm, amount uint64, proof string) {
	caller := unsafe.PreviousRealm().Address()
	if HasClaimed(caller) {
		panic("merkledrop: already claimed")
	}
	if !Verify(caller, amount, proof) {
		panic("merkledrop: invalid proof")
	}
	claimed.Set(caller.String(), amount)
	totalClaimed += amount

	chain.Emit("Claimed",
		"account", caller.String(),
		"amount", strconv.FormatUint(amount, 10),
	)
}

// Render shows the committed root, aggregate stats, and the list of claimers.
func Render(path string) string {
	var b strings.Builder
	b.WriteString("# MerkleDrop\n\n")
	b.WriteString("A fixed Merkle root gates a one-per-address airdrop. Prove your allocation with `Claim(amount, proof)`.\n\n")

	b.WriteString("## Root\n\n")
	b.WriteString("`" + merkleRoot + "`\n\n")

	b.WriteString("## Stats\n\n")
	b.WriteString("- Distinct claimers: " + strconv.Itoa(claimed.Size()) + "\n")
	b.WriteString("- Total claimed: " + strconv.FormatUint(totalClaimed, 10) + "\n\n")

	b.WriteString("## Claimers\n\n")
	if claimed.Size() == 0 {
		b.WriteString("_No claims yet._\n")
		return b.String()
	}
	b.WriteString("| Address | Amount |\n|---|---|\n")
	claimed.Iterate("", "", func(key string, value interface{}) bool {
		b.WriteString("| " + key + " | " + strconv.FormatUint(value.(uint64), 10) + " |\n")
		return false
	})
	return b.String()
}