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
}