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

Community realm. Read the code first. Community realm, deployed by its author. Read the code before you interact or send coins.

Playground

admin.gno

package gnodice

import (
	"chain"
	"strconv"
)

// Administration : réservée au propriétaire (sauf AcceptOwnership).
// Chaque action émet un événement on-chain, pour garder une trace publique.

// SetPaused met le jeu en pause (true) ou le relance (false). En pause, les
// nouvelles mises sont refusées mais les parties en cours peuvent se terminer.
func SetPaused(cur realm, value bool) {
	assertOwner(cur)
	paused = value
	chain.Emit("PauseChanged", "paused", strconv.FormatBool(value), "by", "owner")
}

// SetCroupier désigne l'adresse du service qui tire les dés.
func SetCroupier(cur realm, addr address) {
	assertOwner(cur)
	if !addr.IsValid() {
		panic("gnodice: adresse invalide")
	}
	previous := croupier
	croupier = addr
	chain.Emit("CroupierChanged", "from", previous.String(), "to", addr.String())
}

// SetBlocked interdit (true) ou autorise de nouveau (false) une adresse à jouer.
// Les parties déjà en cours de cette adresse se terminent normalement.
func SetBlocked(cur realm, addr address, value bool) {
	assertOwner(cur)
	if !addr.IsValid() {
		panic("gnodice: adresse invalide")
	}
	if value {
		blocked.Set(addr.String(), true)
	} else {
		blocked.Remove(addr.String())
	}
	chain.Emit("PlayerBlocked", "player", addr.String(), "blocked", strconv.FormatBool(value))
}

// SetLimits règle le coupe-circuit (gains maximum par jour) et le seuil
// d'alerte de la banque, en ugnot.
func SetLimits(cur realm, dailyLimit, lowBankrollThreshold int64) {
	assertOwner(cur)
	if dailyLimit < MaxBet*PayoutMultiplier {
		panic("gnodice: la limite du jour doit couvrir au moins un gain maximal (50 GNOT)")
	}
	if lowBankrollThreshold < 0 {
		panic("gnodice: seuil invalide")
	}
	dailyPayoutLimit = dailyLimit
	lowBankroll = lowBankrollThreshold
	chain.Emit("LimitsChanged", "dailyPayoutLimit", itoa64(dailyLimit), "lowBankroll", itoa64(lowBankrollThreshold))
}

// TransferOwnership PROPOSE un nouveau propriétaire. Il ne devient
// propriétaire qu'en appelant AcceptOwnership : une faute de frappe dans
// l'adresse ne fait donc jamais perdre le contrôle du contrat.
func TransferOwnership(cur realm, newOwner address) {
	assertOwner(cur)
	if !newOwner.IsValid() {
		panic("gnodice: adresse invalide")
	}
	pendingOwner = newOwner
	chain.Emit("OwnershipProposed", "from", owner.String(), "to", newOwner.String())
}

// AcceptOwnership : le propriétaire proposé accepte le contrôle du contrat.
func AcceptOwnership(cur realm) {
	caller := cur.Previous().Address()
	if pendingOwner == "" || caller != pendingOwner {
		panic("gnodice: aucune proposition de transfert pour cette adresse")
	}
	previous := owner
	owner = pendingOwner
	pendingOwner = ""
	chain.Emit("OwnershipTransferred", "from", previous.String(), "to", owner.String())
}

// Owner renvoie l'adresse du propriétaire.
func Owner() address { return owner }

// Croupier renvoie l'adresse du croupier.
func Croupier() address { return croupier }

func assertOwner(cur realm) {
	if cur.Previous().Address() != owner {
		panic("gnodice: action réservée au propriétaire du contrat")
	}
}

api.gno

package gnodice

import (
	"strconv"
	"strings"
)

// Lectures : ces fonctions ne modifient rien. Le site et le croupier les
// appellent gratuitement (sans transaction) pour lire l'état du jeu en JSON.
// Les seules chaînes écrites sont des adresses, des empreintes/graines
// hexadécimales (vérifiées) et des statuts fixes : rien à échapper.

// GetInfoJSON renvoie l'état global du jeu et les dernières parties terminées.
func GetInfoJSON() string {
	t := now()
	var b strings.Builder
	b.WriteString("{")
	str(&b, "owner", owner.String())
	str(&b, "pendingOwner", pendingOwner.String())
	str(&b, "croupier", croupier.String())
	str(&b, "realm", realmAddr.String())
	boolean(&b, "paused", paused)
	num(&b, "bankroll", Bankroll())
	num(&b, "reserved", reserved)
	num(&b, "available", available())
	num(&b, "maxCoverableBet", MaxCoverableBet())
	num(&b, "minBet", MinBet)
	num(&b, "maxBet", MaxBet)
	num(&b, "multiplier", PayoutMultiplier)
	num(&b, "cooldown", CooldownSeconds)
	num(&b, "historySize", HistorySize)
	num(&b, "resolveTimeout", ResolveTimeout)
	num(&b, "revealWindow", RevealWindow)
	num(&b, "totalGames", totalGames)
	num(&b, "totalWins", int64(totalWins))
	num(&b, "totalLosses", int64(totalLosses))
	num(&b, "totalRefunded", int64(totalRefunded))
	num(&b, "totalExpired", int64(totalExpired))
	num(&b, "totalWagered", totalWagered)
	num(&b, "totalPaid", totalPaid)
	num(&b, "totalFunded", totalFunded)
	num(&b, "totalWithdrawn", totalWithdrawn)
	num(&b, "openGames", int64(openGames.Size()))
	num(&b, "dailyPayoutLimit", dailyPayoutLimit)
	todayPaid := int64(0)
	if t/86400 == payoutDay {
		todayPaid = payoutToday
	}
	num(&b, "payoutToday", todayPaid)
	num(&b, "lowBankroll", lowBankroll)
	num(&b, "now", t)
	b.WriteString(`"recent":`)
	writeGameIDs(&b, recent)
	b.WriteString("}")
	return b.String()
}

// GetPlayerJSON renvoie les statistiques d'un joueur, son temps d'attente,
// ses parties en cours et ses 10 dernières parties terminées.
func GetPlayerJSON(addr string) string {
	player := address(addr)
	if !player.IsValid() {
		return `{"error":"adresse invalide"}`
	}
	p := getPlayer(player)
	if p == nil {
		p = &playerData{}
	}
	t := now()
	nextPlayAt := int64(0)
	if p.LastPlay > 0 {
		nextPlayAt = p.LastPlay + CooldownSeconds
	}

	var b strings.Builder
	b.WriteString("{")
	str(&b, "address", player.String())
	num(&b, "played", int64(p.Played))
	num(&b, "wins", int64(p.Wins))
	num(&b, "wagered", p.Wagered)
	num(&b, "paid", p.Paid)
	num(&b, "lastPlay", p.LastPlay)
	num(&b, "nextPlayAt", nextPlayAt)
	num(&b, "cooldownRemaining", cooldownRemaining(p, t))
	boolean(&b, "blocked", isBlocked(player))
	num(&b, "now", t)
	b.WriteString(`"open":`)
	writePlayerOpenGames(&b, player, p.Open)
	b.WriteString(`,"history":`)
	writeGameIDs(&b, p.History)
	b.WriteString("}")
	return b.String()
}

// GetGameJSON renvoie une partie, ou {"error":...} si elle n'existe pas.
func GetGameJSON(id int64) string {
	g := getGame(id)
	if g == nil {
		return `{"error":"partie introuvable"}`
	}
	var b strings.Builder
	writeGame(&b, g)
	return b.String()
}

// GetOpenGamesJSON renvoie les parties en cours (en attente de tirage ou de
// révélation), de la plus ancienne à la plus récente, à partir du numéro
// `after` exclu (pagination ; 0 pour commencer). Utilisé par le croupier.
func GetOpenGamesJSON(after int64) string {
	var b strings.Builder
	b.WriteString("[")
	count := 0
	openGames.Iterate(gameKey(after+1), "", func(key string, _ any) bool {
		v := games.Get(key)
		if count > 0 {
			b.WriteString(",")
		}
		writeGame(&b, v.(*Game))
		count++
		return count >= maxPageSize
	})
	b.WriteString("]")
	return b.String()
}

// --- écriture JSON ---

func writePlayerOpenGames(b *strings.Builder, player address, open int) {
	b.WriteString("[")
	if open > 0 {
		count := 0
		// Les parties en cours sont peu nombreuses (cooldown de 10 min) :
		// on parcourt la liste des parties ouvertes en partant de la plus récente.
		openGames.ReverseIterate("", "", func(key string, _ any) bool {
			v := games.Get(key)
			g := v.(*Game)
			if g.Player == player {
				if count > 0 {
					b.WriteString(",")
				}
				writeGame(b, g)
				count++
			}
			return count >= open || count >= maxPageSize
		})
	}
	b.WriteString("]")
}

// writeGameIDs écrit les parties de la plus récente à la plus ancienne.
func writeGameIDs(b *strings.Builder, ids []int64) {
	b.WriteString("[")
	for i := len(ids) - 1; i >= 0; i-- {
		if i != len(ids)-1 {
			b.WriteString(",")
		}
		writeGame(b, mustGetGame(ids[i]))
	}
	b.WriteString("]")
}

func writeGame(b *strings.Builder, g *Game) {
	b.WriteString("{")
	num(b, "id", g.ID)
	str(b, "player", g.Player.String())
	str(b, "status", g.Status.String())
	str(b, "commitment", g.Commitment)
	str(b, "seed", g.Seed)
	num(b, "guess", int64(g.Guess))
	num(b, "roll", int64(g.Roll))
	num(b, "bet", g.Bet)
	num(b, "payout", g.Payout)
	boolean(b, "won", g.Won())
	num(b, "time", g.PlacedAt)
	num(b, "height", g.PlacedHeight)
	num(b, "rolledAt", g.RolledAt)
	num(b, "settledAt", g.SettledAt)
	b.WriteString(`"resolveDeadline":` + itoa64(g.PlacedAt+ResolveTimeout))
	b.WriteString("}")
}

// Chaque champ est suivi d'une virgule ; le dernier champ d'un objet est
// écrit à la main, sans virgule.
func str(b *strings.Builder, key, value string) {
	b.WriteString(`"` + key + `":"` + value + `",`)
}

func num(b *strings.Builder, key string, value int64) {
	b.WriteString(`"` + key + `":` + strconv.FormatInt(value, 10) + `,`)
}

func boolean(b *strings.Builder, key string, value bool) {
	b.WriteString(`"` + key + `":` + strconv.FormatBool(value) + `,`)
}

bank.gno

package gnodice

import (
	"chain"
	"chain/banker"
	"chain/runtime/unsafe"
)

// La banque du jeu : son solde est celui de l'adresse du contrat.
// Une partie de ce solde est « réservée » : c'est le gain maximal promis aux
// parties en cours. Seul le reste (« disponible ») peut couvrir de nouvelles
// mises ou être retiré par le propriétaire.

// Fund alimente la banque. N'importe qui peut l'appeler en envoyant des GNOT.
func Fund(cur realm) {
	caller := cur.Previous()
	if !caller.IsUserCall() {
		panic("gnodice: Fund doit être appelé directement depuis un wallet")
	}
	sent := unsafe.OriginSend()
	if len(sent) != 1 || sent[0].Denom != Denom || sent[0].Amount <= 0 {
		panic("gnodice: envoie des GNOT (et uniquement des GNOT) pour alimenter la banque")
	}
	totalFunded += sent[0].Amount
	chain.Emit("BankFunded", "from", caller.Address().String(), "amount", itoa64(sent[0].Amount))
}

// Withdraw retire des GNOT DISPONIBLES vers le propriétaire. L'argent réservé
// aux parties en cours ne peut pas être retiré. amount est en ugnot.
func Withdraw(cur realm, amount int64) {
	assertOwner(cur)
	if amount <= 0 {
		panic("gnodice: montant invalide")
	}
	if amount > available() {
		panic("gnodice: montant supérieur au solde disponible (hors réserve des parties en cours)")
	}
	totalWithdrawn += amount
	chain.Emit("BankWithdrawn", "to", owner.String(), "amount", itoa64(amount))
	pay(cur, owner, amount) // en dernier
	checkLowBankroll()
}

// Bankroll renvoie le solde total de la banque en ugnot.
func Bankroll() int64 {
	return banker.NewReadonlyBanker().GetCoin(realmAddr, Denom)
}

// Reserved renvoie la somme réservée aux parties en cours, en ugnot.
func Reserved() int64 {
	return reserved
}

// Available renvoie le solde libre (non réservé), en ugnot.
func Available() int64 {
	return available()
}

// MaxCoverableBet renvoie la plus grosse mise (en ugnot) acceptée en ce moment.
// Une mise b arrive dans la banque puis réserve 5 x b : il faut donc
// disponible + b >= 5 x b, soit b <= disponible / 4.
// Renvoie 0 si le jeu est en pause ou si la limite du jour est atteinte.
func MaxCoverableBet() int64 {
	if paused || dailyLimitReached(now()) {
		return 0
	}
	max := available() / (PayoutMultiplier - 1)
	if max > MaxBet {
		return MaxBet
	}
	if max < 0 {
		return 0
	}
	return max
}

func available() int64 {
	return Bankroll() - reserved
}

// rollDay remet le compteur de gains à zéro quand on change de jour.
func rollDay(t int64) {
	day := t / 86400
	if day != payoutDay {
		payoutDay = day
		payoutToday = 0
	}
}

func dailyLimitReached(t int64) bool {
	if t/86400 != payoutDay {
		return false
	}
	return payoutToday >= dailyPayoutLimit
}

// recordPayout compte un gain payé. Coupe-circuit : si les gains du jour
// dépassent la limite (signe possible d'une attaque ou d'un croupier
// compromis), le jeu se met en pause tout seul. Le gain en cours est quand
// même payé : le joueur a gagné honnêtement.
func recordPayout(amount int64) {
	rollDay(now())
	payoutToday += amount
	if payoutToday >= dailyPayoutLimit && !paused {
		paused = true
		chain.Emit("CircuitBreakerTripped", "payoutToday", itoa64(payoutToday), "limit", itoa64(dailyPayoutLimit))
		chain.Emit("PauseChanged", "paused", "true", "by", "circuit-breaker")
	}
}

// checkLowBankroll émet une alerte quand le solde disponible passe sous le seuil.
func checkLowBankroll() {
	if a := available(); a < lowBankroll {
		chain.Emit("BankrollLow", "available", itoa64(a), "threshold", itoa64(lowBankroll))
	}
}

fairness.gno

package gnodice

import (
	"crypto/sha256"
	"encoding/binary"
	"encoding/hex"
	"strconv"
)

// Équité du jeu : empreinte du chiffre caché et calcul du dé.
// Tout est vérifiable par n'importe qui avec SHA-256 :
//
//	empreinte = sha256("gnodice|v1|commit|" + adresse + "|" + chiffre + "|" + secret)
//	dé        = 1 + (8 premiers octets de sha256("gnodice|v1|roll|" + graine + "|" + empreinte + "|" + numéro)) mod 6
//
// Le secret du joueur et la graine du croupier font 32 octets (64 caractères
// hexadécimaux). Un secret plus court permettrait au croupier de retrouver le
// chiffre en essayant les 6 possibilités : il est donc refusé.

const hexLen = 64 // 32 octets écrits en hexadécimal

// Commitment calcule l'empreinte d'un chiffre caché. Lecture seule : le site
// et le croupier peuvent l'appeler pour vérifier leurs calculs.
func Commitment(player address, guess int, salt string) string {
	sum := sha256.Sum256([]byte("gnodice|v1|commit|" + player.String() + "|" + strconv.Itoa(guess) + "|" + salt))
	return hex.EncodeToString(sum[:])
}

// rollFromSeed calcule le dé à partir de la graine du croupier, de l'empreinte
// du joueur et du numéro de la partie.
// Le modulo 6 sur 64 bits a un biais inférieur à 1 sur 3 milliards de milliards :
// négligeable.
func rollFromSeed(seed, commitment string, id int64) int {
	sum := sha256.Sum256([]byte("gnodice|v1|roll|" + seed + "|" + commitment + "|" + itoa64(id)))
	return int(binary.BigEndian.Uint64(sum[0:8])%DieFaces) + 1
}

// RollFor : version publique de rollFromSeed, pour que chacun puisse vérifier
// un tirage passé (graine et empreinte sont publiques après le tirage).
func RollFor(seed, commitment string, id int64) int {
	if !isHex64(seed) || !isHex64(commitment) {
		return 0
	}
	return rollFromSeed(seed, commitment, id)
}

// isHex64 : exactement 64 caractères hexadécimaux minuscules.
func isHex64(s string) bool {
	if len(s) != hexLen {
		return false
	}
	for i := 0; i < len(s); i++ {
		c := s[i]
		if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
			return false
		}
	}
	return true
}

func itoa64(v int64) string { return strconv.FormatInt(v, 10) }

game.gno

package gnodice

import (
	"chain"
	"chain/banker"
	"chain/runtime/unsafe"
	"strconv"
)

// Les étapes d'une partie : Play -> Resolve -> Reveal, avec deux sorties de
// secours, Refund (croupier trop lent) et Expire (chiffre jamais dévoilé).
// Règle d'or suivie partout : on vérifie, puis on met à jour l'état, et on
// envoie l'argent en tout dernier (contrôles -> effets -> paiement).

// Play mise sur un chiffre caché. Le joueur envoie sa mise (1 à 10 GNOT) avec
// la transaction et l'empreinte de son chiffre (voir Commitment).
// Renvoie le numéro de la partie, par exemple "id=42".
func Play(cur realm, commitment string) string {
	caller := cur.Previous()

	// La mise est lue dans « l'enveloppe » de la transaction (OriginSend) :
	// ce n'est fiable que pour un appel direct depuis un wallet (MsgCall).
	// Un script (MsgRun) ou un autre contrat pourrait détourner ces GNOT.
	if !caller.IsUserCall() {
		panic("gnodice: Play doit être appelé directement depuis un wallet")
	}
	player := caller.Address()
	if paused {
		panic("gnodice: le jeu est en pause")
	}
	if isBlocked(player) {
		panic("gnodice: cette adresse n'est pas autorisée à jouer")
	}
	if !isHex64(commitment) {
		panic("gnodice: empreinte invalide (64 caractères hexadécimaux attendus)")
	}
	bet := receivedBet()

	t := now()
	rollDay(t)
	if payoutToday >= dailyPayoutLimit {
		panic("gnodice: limite de gains du jour atteinte, réessaie demain")
	}

	p := getPlayer(player)
	if wait := cooldownRemaining(p, t); wait > 0 {
		panic("gnodice: attends encore " + formatDuration(wait) + " avant de rejouer")
	}

	// La banque (qui contient déjà la mise reçue) doit pouvoir couvrir le gain
	// maximal EN PLUS de tout ce qu'elle a déjà promis aux parties en cours.
	game := &Game{
		Player:       player,
		Commitment:   commitment,
		Bet:          bet,
		Status:       StatusPending,
		PlacedAt:     t,
		PlacedHeight: height(),
	}
	if available() < game.reservation() {
		panic("gnodice: la banque ne peut pas couvrir ce gain, essaie une mise plus petite")
	}

	// Effets
	totalGames++
	game.ID = totalGames
	games.Set(gameKey(game.ID), game)
	openGames.Set(gameKey(game.ID), true)
	reserved += game.reservation()

	if p == nil {
		p = &playerData{}
		players.Set(player.String(), p)
	}
	p.LastPlay = t
	p.Open++
	p.Wagered += bet
	totalWagered += bet

	chain.Emit(
		"GamePlaced",
		"id", itoa64(game.ID),
		"player", player.String(),
		"bet", itoa64(bet),
		"commitment", commitment,
	)
	return "id=" + itoa64(game.ID)
}

// Resolve tire le dé d'une partie en attente. Réservé au croupier, qui fournit
// une graine aléatoire de 32 octets (64 caractères hexadécimaux) sans connaître
// le chiffre du joueur. La graine est publiée : chacun peut refaire le calcul.
func Resolve(cur realm, id int64, seed string) {
	caller := cur.Previous()
	if !caller.IsUserCall() || caller.Address() != croupier {
		panic("gnodice: seul le croupier peut tirer les dés")
	}
	if !isHex64(seed) {
		panic("gnodice: graine invalide (64 caractères hexadécimaux attendus)")
	}
	g := mustGetGame(id)
	if g.Status != StatusPending {
		panic("gnodice: cette partie n'attend pas de tirage")
	}
	// Fenêtres disjointes : avant la limite, seul le tirage est possible ;
	// après, seul le remboursement. Sinon un joueur qui voit passer un tirage
	// tardif (et sa graine) pourrait le devancer avec Refund s'il a perdu.
	if now() >= g.PlacedAt+ResolveTimeout {
		panic("gnodice: délai de tirage dépassé, la partie doit être remboursée")
	}

	g.Seed = seed
	g.Roll = rollFromSeed(seed, g.Commitment, g.ID)
	g.Status = StatusRolled
	g.RolledAt = now()

	chain.Emit("DiceRolled", "id", itoa64(g.ID), "player", g.Player.String(), "roll", strconv.Itoa(g.Roll), "seed", seed)
}

// Reveal dévoile le chiffre caché et termine la partie. N'importe qui peut
// l'appeler (le joueur ou le service du site) : le gain va toujours au joueur.
// Renvoie le résultat, par exemple "roll=4;won=true;payout=50000000".
func Reveal(cur realm, id int64, guess int, salt string) string {
	g := mustGetGame(id)
	if g.Status != StatusRolled {
		panic("gnodice: cette partie ne peut pas être dévoilée maintenant")
	}
	if now() > g.RolledAt+RevealWindow {
		panic("gnodice: délai dépassé, la partie a expiré")
	}
	if guess < 1 || guess > DieFaces {
		panic("gnodice: le chiffre doit être entre 1 et 6")
	}
	if !isHex64(salt) {
		panic("gnodice: secret invalide (64 caractères hexadécimaux attendus)")
	}
	if Commitment(g.Player, guess, salt) != g.Commitment {
		panic("gnodice: le chiffre ou le secret ne correspond pas à l'empreinte")
	}

	g.Guess = guess
	won := guess == g.Roll
	payout := int64(0)
	if won {
		payout = g.reservation()
		g.Status = StatusWon
	} else {
		g.Status = StatusLost
	}
	g.Payout = payout
	finish(g)

	p := getPlayer(g.Player)
	p.Played++
	p.Paid += payout
	if won {
		p.Wins++
		totalWins++
	} else {
		totalLosses++
	}
	totalPaid += payout

	chain.Emit(
		"GameSettled",
		"id", itoa64(g.ID),
		"player", g.Player.String(),
		"guess", strconv.Itoa(guess),
		"roll", strconv.Itoa(g.Roll),
		"bet", itoa64(g.Bet),
		"payout", itoa64(payout),
		"won", strconv.FormatBool(won),
	)

	if won {
		recordPayout(payout)
		pay(cur, g.Player, payout) // en dernier
	}
	checkLowBankroll()
	return "roll=" + strconv.Itoa(g.Roll) + ";won=" + strconv.FormatBool(won) + ";payout=" + itoa64(payout)
}

// Refund rend sa mise au joueur si le croupier n'a pas tiré le dé à temps
// (ResolveTimeout). N'importe qui peut le déclencher : l'argent va au joueur.
func Refund(cur realm, id int64) {
	g := mustGetGame(id)
	if g.Status != StatusPending {
		panic("gnodice: seule une partie en attente de tirage peut être remboursée")
	}
	if now() < g.PlacedAt+ResolveTimeout {
		panic("gnodice: le croupier a encore " + formatDuration(g.PlacedAt+ResolveTimeout-now()) + " pour tirer le dé")
	}

	g.Status = StatusRefunded
	g.Payout = g.Bet
	finish(g)

	p := getPlayer(g.Player)
	p.Wagered -= g.Bet
	totalWagered -= g.Bet
	totalRefunded++

	chain.Emit("GameRefunded", "id", itoa64(g.ID), "player", g.Player.String(), "amount", itoa64(g.Bet))
	pay(cur, g.Player, g.Bet) // en dernier
}

// Expire termine une partie dont le chiffre n'a jamais été dévoilé
// (RevealWindow) : elle compte comme perdue et la réserve est libérée.
// N'importe qui peut l'appeler.
func Expire(cur realm, id int64) {
	g := mustGetGame(id)
	if g.Status != StatusRolled {
		panic("gnodice: seule une partie tirée et non dévoilée peut expirer")
	}
	if now() <= g.RolledAt+RevealWindow {
		panic("gnodice: le joueur peut encore dévoiler son chiffre")
	}

	g.Status = StatusExpired
	finish(g)

	p := getPlayer(g.Player)
	p.Played++
	totalExpired++

	chain.Emit("GameExpired", "id", itoa64(g.ID), "player", g.Player.String())
}

// --- outils internes ---

// receivedBet vérifie la mise envoyée avec la transaction et renvoie son montant.
func receivedBet() int64 {
	sent := unsafe.OriginSend()
	if len(sent) != 1 || sent[0].Denom != Denom {
		panic("gnodice: envoie ta mise en GNOT uniquement")
	}
	amount := sent[0].Amount
	if amount < MinBet || amount > MaxBet {
		panic("gnodice: la mise doit être entre 1 et 10 GNOT")
	}
	return amount
}

// finish : partie terminée. Libère la réserve, la retire des parties en cours
// et l'ajoute aux historiques.
func finish(g *Game) {
	g.SettledAt = now()
	reserved -= g.reservation()
	openGames.Remove(gameKey(g.ID))
	p := getPlayer(g.Player)
	p.Open--
	p.History = pushID(p.History, g.ID)
	recent = pushID(recent, g.ID)
}

// pay envoie des GNOT de la banque vers une adresse.
func pay(cur realm, to address, amount int64) {
	bk := banker.NewBanker(banker.BankerTypeRealmSend, cur)
	bk.SendCoins(realmAddr, to, chain.NewCoins(chain.NewCoin(Denom, amount)))
}

// cooldownRemaining renvoie le nombre de secondes à attendre avant de pouvoir
// rejouer (0 si le joueur peut jouer maintenant).
func cooldownRemaining(p *playerData, t int64) int64 {
	if p == nil || p.LastPlay == 0 {
		return 0
	}
	wait := p.LastPlay + CooldownSeconds - t
	if wait < 0 {
		return 0
	}
	return wait
}

// formatDuration transforme un nombre de secondes en texte, ex. "7 min 12 s".
func formatDuration(seconds int64) string {
	if seconds < 60 {
		return itoa64(seconds) + " s"
	}
	return itoa64(seconds/60) + " min " + itoa64(seconds%60) + " s"
}

gnodice.gno

// Package gnodice est un jeu de dés décentralisé sur gno.land, « prouvablement
// équitable » (provably fair).
//
// Règles du jeu :
//   - le joueur choisit un chiffre entre 1 et 6 et mise entre 1 et 10 GNOT ;
//   - si le dé tombe sur son chiffre, il reçoit 5 fois sa mise ;
//   - chaque joueur ne peut lancer le dé qu'une fois toutes les 10 minutes.
//
// POURQUOI TROIS ÉTAPES (sécurité) :
// Sur une blockchain, tout est public et une transaction peut contenir
// plusieurs messages exécutés « tout ou rien ». Si le dé était tiré pendant
// Play, un tricheur pourrait ajouter un 2e message qui annule toute la
// transaction quand il perd (ou simuler le tirage avant de miser) : il ne
// garderait que ses victoires et viderait la banque. On sépare donc le jeu en
// trois étapes, pour que PERSONNE ne puisse choisir le résultat en connaissant
// les données de l'autre :
//
//  1. Play    : le joueur mise et envoie son chiffre CACHÉ (une empreinte
//               SHA-256 de « chiffre + secret aléatoire + adresse »).
//  2. Resolve : le croupier (un service du site) fournit une graine aléatoire
//               de 32 octets SANS connaître le chiffre. Le dé est calculé à
//               partir de la graine et de l'empreinte, et la graine est publiée.
//  3. Reveal  : on dévoile le chiffre et le secret. Le contrat vérifie
//               l'empreinte et paie si le chiffre est le bon.
//
// Garde-fous : si le croupier ne répond pas, le joueur récupère sa mise
// (Refund) ; si le chiffre n'est jamais dévoilé, la partie est perdue (Expire).
// La banque réserve à chaque mise le gain maximal possible : elle ne peut
// jamais promettre plus qu'elle ne possède.
package gnodice

import (
	"chain/runtime"
	"time"

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

// Paramètres du jeu. 1 GNOT = 1 000 000 ugnot (la plus petite unité).
const (
	Denom            = "ugnot"
	UgnotPerGnot     = int64(1_000_000)
	MinBet           = 1 * UgnotPerGnot  // mise minimale : 1 GNOT
	MaxBet           = 10 * UgnotPerGnot // mise maximale : 10 GNOT
	PayoutMultiplier = int64(5)          // gain = 5 x la mise
	CooldownSeconds  = int64(10 * 60)    // 10 minutes entre deux lancers
	HistorySize      = 10                // nombre de parties gardées par joueur
	DieFaces         = 6

	// Délais (en secondes, heure des blocs)
	ResolveTimeout = int64(30 * 60)       // sans tirage au bout de 30 min : le joueur peut être remboursé
	RevealWindow   = int64(7 * 24 * 3600) // 7 jours pour dévoiler son chiffre après le tirage

	// Limites par défaut (modifiables par le propriétaire avec SetLimits)
	DefaultDailyPayoutLimit = 500 * UgnotPerGnot // au-delà, le jeu se met en pause tout seul
	DefaultLowBankroll      = 100 * UgnotPerGnot // en dessous, un événement d'alerte est émis

	maxPageSize = 50 // nombre maximal de parties renvoyées par une lecture
)

// Status : étape d'une partie.
type Status int

const (
	StatusPending  Status = iota // mise reçue, en attente du tirage
	StatusRolled                 // dé tiré, en attente du chiffre dévoilé
	StatusWon                    // chiffre dévoilé : gagné et payé
	StatusLost                   // chiffre dévoilé : perdu
	StatusRefunded               // croupier trop lent : mise rendue
	StatusExpired                // chiffre jamais dévoilé : perdu
)

func (s Status) String() string {
	switch s {
	case StatusPending:
		return "pending"
	case StatusRolled:
		return "rolled"
	case StatusWon:
		return "won"
	case StatusLost:
		return "lost"
	case StatusRefunded:
		return "refunded"
	case StatusExpired:
		return "expired"
	}
	return "unknown"
}

// isOpen : la partie n'est pas terminée (sa réserve est encore bloquée).
func (s Status) isOpen() bool {
	return s == StatusPending || s == StatusRolled
}

// Game décrit une partie.
type Game struct {
	ID           int64
	Player       address
	Commitment   string // empreinte du chiffre caché (64 caractères hexadécimaux)
	Bet          int64  // mise en ugnot
	Status       Status
	Seed         string // graine du croupier, publiée au tirage (vide avant)
	Roll         int    // résultat du dé (0 avant le tirage)
	Guess        int    // chiffre dévoilé (0 tant qu'il est caché)
	Payout       int64  // somme versée au joueur (gain, ou mise rendue)
	PlacedAt     int64  // heure du bloc de la mise (secondes Unix)
	PlacedHeight int64
	RolledAt     int64
	SettledAt    int64
}

// Won : true si la partie est gagnée.
func (g *Game) Won() bool { return g.Status == StatusWon }

// reservation : ce que la banque bloque pour cette partie (le gain maximal).
func (g *Game) reservation() int64 { return g.Bet * PayoutMultiplier }

// playerData regroupe les informations d'un joueur.
type playerData struct {
	LastPlay int64   // heure de la dernière mise (secondes Unix)
	Played   int     // parties terminées (gagnées, perdues ou expirées)
	Wins     int     // victoires
	Wagered  int64   // total misé en ugnot
	Paid     int64   // total gagné en ugnot
	History  []int64 // numéros des HistorySize dernières parties (plus ancienne en premier)
	Open     int     // parties en cours (non terminées)
}

var (
	owner        address // propriétaire : retraits, pause, réglages
	pendingOwner address // propriétaire proposé, qui doit accepter (TransferOwnership en 2 temps)
	croupier     address // service autorisé à tirer les dés (Resolve)
	realmAddr    address // adresse du contrat = adresse de la banque
	paused       bool

	games     = avl.NewTree() // numéro (texte à zéros) -> *Game
	openGames = avl.NewTree() // parties en cours, même clé -> true
	players   = avl.NewTree() // adresse -> *playerData
	blocked   = avl.NewTree() // adresses interdites de jeu -> true
	recent    []int64         // dernières parties, tous joueurs confondus

	reserved int64 // somme des gains maximaux des parties en cours

	totalGames     int64 // parties créées (= dernier numéro)
	totalWins      int
	totalLosses    int
	totalRefunded  int
	totalExpired   int
	totalWagered   int64
	totalPaid      int64
	totalFunded    int64
	totalWithdrawn int64

	// Coupe-circuit : gains payés aujourd'hui (jour = heure du bloc / 86 400)
	dailyPayoutLimit = DefaultDailyPayoutLimit
	lowBankroll      = DefaultLowBankroll
	payoutDay        int64
	payoutToday      int64
)

// init s'exécute une seule fois, au déploiement du contrat.
// Celui qui déploie devient le propriétaire ET le croupier par défaut.
func init(cur realm) {
	owner = cur.Previous().Address()
	croupier = owner
	realmAddr = cur.Address()
}

// --- outils internes partagés ---

func now() int64 { return time.Now().Unix() }

func height() int64 { return runtime.ChainHeight() }

// gameKey : clé de tri des parties (zéros devant pour garder l'ordre).
func gameKey(id int64) string {
	s := itoa64(id)
	for len(s) < 12 {
		s = "0" + s
	}
	return s
}

func getGame(id int64) *Game {
	v := games.Get(gameKey(id))
	if v == nil {
		return nil
	}
	return v.(*Game)
}

func mustGetGame(id int64) *Game {
	g := getGame(id)
	if g == nil {
		panic("gnodice: partie introuvable")
	}
	return g
}

func getPlayer(addr address) *playerData {
	v := players.Get(addr.String())
	if v == nil {
		return nil
	}
	return v.(*playerData)
}

func isBlocked(addr address) bool {
	return blocked.Has(addr.String())
}

// pushID ajoute un numéro de partie en ne gardant que les HistorySize derniers.
func pushID(list []int64, id int64) []int64 {
	if len(list) < HistorySize {
		return append(list, id)
	}
	out := make([]int64, 0, HistorySize)
	out = append(out, list[len(list)-HistorySize+1:]...)
	return append(out, id)
}

gnomod.toml

module = "gno.land/r/g1u97n45s4s6q7vn5clr8339pv4up455hnqn4aff/gnodice"
gno = "0.9"

[addpkg]
  creator = "g1u97n45s4s6q7vn5clr8339pv4up455hnqn4aff"
  height = 88987
  max_deposit = "100000000ugnot"

render.gno

package gnodice

import (
	"strconv"
	"strings"
)

// Render affiche une page lisible sur gnoweb (le site officiel de gno.land).
//   - chemin ""               : règles, banque et dernières parties
//   - chemin "player/<g1...>" : statistiques et historique d'un joueur
//   - chemin "game/<numéro>"  : une partie, avec de quoi vérifier le tirage
//
// Le chemin est choisi par le visiteur : on ne l'affiche jamais tel quel, on
// n'utilise qu'une adresse ou un numéro validés.
func Render(path string) string {
	switch {
	case strings.HasPrefix(path, "player/"):
		player := address(strings.TrimPrefix(path, "player/"))
		if !player.IsValid() {
			return "# GNO-DICE\n\nAdresse invalide.\n"
		}
		return renderPlayer(player)
	case strings.HasPrefix(path, "game/"):
		id, err := strconv.ParseInt(strings.TrimPrefix(path, "game/"), 10, 64)
		if err != nil || getGame(id) == nil {
			return "# GNO-DICE\n\nPartie introuvable.\n"
		}
		return renderGame(getGame(id))
	}
	return renderHome()
}

func renderHome() string {
	var b strings.Builder
	b.WriteString("# 🎲 GNO-DICE\n\n")
	b.WriteString("Choisis un chiffre de 1 à 6, mise entre 1 et 10 GNOT. ")
	b.WriteString("Si le dé tombe sur ton chiffre, tu gagnes **5 fois ta mise**. ")
	b.WriteString("Un lancer toutes les 10 minutes.\n\n")
	b.WriteString("Le jeu est **prouvablement équitable** : ton chiffre reste caché (empreinte SHA-256) pendant que le croupier tire le dé, ")
	b.WriteString("puis il est dévoilé et vérifié par le contrat. Chaque tirage publie sa graine : `game/<numéro>` pour le vérifier.\n\n")

	if paused {
		b.WriteString("> ⏸️ Le jeu est actuellement en pause.\n\n")
	}

	b.WriteString("## Banque\n\n")
	b.WriteString("- Solde : " + formatGnot(Bankroll()) + " GNOT (dont " + formatGnot(reserved) + " réservés aux parties en cours)\n")
	b.WriteString("- Mise maximale acceptée en ce moment : " + formatGnot(MaxCoverableBet()) + " GNOT\n")
	b.WriteString("- Parties : " + itoa64(totalGames) + " (" + strconv.Itoa(totalWins) + " gagnées, " + strconv.Itoa(openGames.Size()) + " en cours)\n")
	b.WriteString("- Total misé : " + formatGnot(totalWagered) + " GNOT, total payé : " + formatGnot(totalPaid) + " GNOT\n\n")

	b.WriteString("## Dernières parties\n\n")
	writeGamesTable(&b, recent, true)
	return b.String()
}

func renderPlayer(player address) string {
	var b strings.Builder
	b.WriteString("# 🎲 GNO-DICE : joueur\n\n")
	b.WriteString("`" + player.String() + "`\n\n")

	p := getPlayer(player)
	if p == nil {
		b.WriteString("Aucune partie jouée pour l'instant.\n")
		return b.String()
	}
	b.WriteString("- Parties terminées : " + strconv.Itoa(p.Played) + " (" + strconv.Itoa(p.Wins) + " gagnées), en cours : " + strconv.Itoa(p.Open) + "\n")
	b.WriteString("- Total misé : " + formatGnot(p.Wagered) + " GNOT, total gagné : " + formatGnot(p.Paid) + " GNOT\n\n")
	b.WriteString("## Dernières parties\n\n")
	writeGamesTable(&b, p.History, false)
	return b.String()
}

func renderGame(g *Game) string {
	var b strings.Builder
	b.WriteString("# 🎲 GNO-DICE : partie n° " + itoa64(g.ID) + "\n\n")
	b.WriteString("- Joueur : `" + g.Player.String() + "`\n")
	b.WriteString("- Mise : " + formatGnot(g.Bet) + " GNOT, bloc " + itoa64(g.PlacedHeight) + "\n")
	b.WriteString("- Statut : " + g.Status.String() + "\n")
	b.WriteString("- Empreinte du chiffre : `" + g.Commitment + "`\n")
	if g.Seed != "" {
		b.WriteString("- Graine du croupier : `" + g.Seed + "`\n")
		b.WriteString("- Dé : **" + strconv.Itoa(g.Roll) + "**\n")
	}
	if g.Guess != 0 {
		b.WriteString("- Chiffre dévoilé : **" + strconv.Itoa(g.Guess) + "**\n")
	}
	if g.Payout > 0 {
		b.WriteString("- Versé au joueur : " + formatGnot(g.Payout) + " GNOT\n")
	}
	b.WriteString("\n### Vérifier ce tirage\n\n")
	b.WriteString("dé = 1 + (8 premiers octets de sha256(\"gnodice|v1|roll|\" + graine + \"|\" + empreinte + \"|\" + numéro)) mod 6\n")
	return b.String()
}

func writeGamesTable(b *strings.Builder, ids []int64, withPlayer bool) {
	if len(ids) == 0 {
		b.WriteString("Aucune partie terminée pour l'instant.\n")
		return
	}
	if withPlayer {
		b.WriteString("| # | Bloc | Joueur | Mise | Chiffre | Dé | Résultat |\n")
		b.WriteString("|---|---|---|---|---|---|---|\n")
	} else {
		b.WriteString("| # | Bloc | Mise | Chiffre | Dé | Résultat |\n")
		b.WriteString("|---|---|---|---|---|---|\n")
	}
	for i := len(ids) - 1; i >= 0; i-- {
		g := mustGetGame(ids[i])
		b.WriteString("| [" + itoa64(g.ID) + "](:game/" + itoa64(g.ID) + ") | " + itoa64(g.PlacedHeight) + " | ")
		if withPlayer {
			b.WriteString(shortAddress(g.Player) + " | ")
		}
		b.WriteString(formatGnot(g.Bet) + " GNOT | " + digitOrDash(g.Guess) + " | " + digitOrDash(g.Roll) + " | ")
		switch g.Status {
		case StatusWon:
			b.WriteString("✅ +" + formatGnot(g.Payout) + " GNOT |\n")
		case StatusRefunded:
			b.WriteString("↩️ remboursé |\n")
		case StatusExpired:
			b.WriteString("⌛ expiré |\n")
		default:
			b.WriteString("❌ perdu |\n")
		}
	}
}

func digitOrDash(v int) string {
	if v == 0 {
		return "-"
	}
	return strconv.Itoa(v)
}

// shortAddress raccourcit une adresse : g1abcd...wxyz
func shortAddress(a address) string {
	s := a.String()
	if len(s) <= 12 {
		return s
	}
	return s[:6] + "..." + s[len(s)-4:]
}

// formatGnot convertit des ugnot en GNOT lisibles : 1500000 -> "1.5"
func formatGnot(ugnot int64) string {
	sign := ""
	if ugnot < 0 {
		sign = "-"
		ugnot = -ugnot
	}
	whole := ugnot / UgnotPerGnot
	frac := ugnot % UgnotPerGnot
	if frac == 0 {
		return sign + itoa64(whole)
	}
	fracStr := itoa64(frac + UgnotPerGnot)[1:] // complète avec des zéros : 500000 -> "500000"
	fracStr = strings.TrimRight(fracStr, "0")
	return sign + itoa64(whole) + "." + fracStr
}