In diesem Tutorial führe ich dich durch den Prozess der Erstellung einesSmart Contracts für Würfelspielemit Sui Move.

Dieser Vertrag ermöglicht es Spielern, auf**das Ergebnis eines Würfelwurfs zu wetten, wobei ein Administrator den Preispool verwaltet. Am Ende wirst du einen voll funktionsfähigen Vertrag haben und ein solides Verständnis der wichtigsten Sui Move-Konzepte haben.

Einführung

Der Würfelspiel-Vertrag, den wir erstellen werden, sieht die folgenden Funktionen vor:

• Initialisierung: Der Vertragsersteller richtet das Spiel ein.
• Admin-Management: Ein Admin kann Tokens in den Preispool einzahlen und diese bei Bedarf abheben.
• Spielerinteraktion: Die Spieler nehmen teil, indem sie das Ergebnis des Würfelwurfs erraten und Wetten platzieren.

Dieses Tutorial setzt ein grundlegendes Verständnis von Sui Move voraus und konzentriert sich auf die Einführung neuer Konzepte durch praktische Umsetzung. Bevor wir in den Code eintauchen, wollen wir uns mit den wichtigsten Konzepten befassen, denen Sie begegnen werden:

1.1 Abhängigkeiten hinzufügen:

Um Token aus einem anderen Vertrag (z. B. einem Faucet-Token-Vertrag) zu verwenden, müssen Sie ihn als Abhängigkeit in Ihrem Projekt hinzufügen. Dies geschieht, indem Sie die Move.tomlDatei Ihres Vertrags aktualisieren:

[dependencies]
coin_duck = { local = "../coin_duck"”}

Hier ist coin_duck der Faucet-Token-Vertrag, der sich auf dem angegebenen Pfad befindet. Der abhängige Vertrag muss außerdem sein published-at-Feld in seiner eigenen Move.toml mit der Paket-ID angeben, die bei der Veröffentlichung abgerufen wurde, etwa so: Rost

published-at = "packageId_from_publication"

1.2 Assertions verwenden

Assertions stellen sicher, dass bestimmte Bedingungen bei der Vertragsausführung erfüllt werden. Das assert!Makro überprüft eine Bedingung und gibt, falls sie fehlschlägt, einen Fehler aus und stoppt die Ausführung. Dies ist nützlich, um ungültige Zustände zu verhindern, z. B. wenn mehr als das Guthaben eines Spielers gesetzt wird.

1.3 Generieren von Zufallszahlen

Fairness im Würfelspiel hängt von der Generierung von Zufallszahlen ab. Sui Move stellt das randomModul für diesen Zweck zur Verfügung. Sie erstellen ein RandomGeneratorObjekt und verwenden es, um eine Zufallszahl zwischen 1 und 6 zu generieren, wodurch ein Würfelwurf simuliert wird.

1.4 Mit Coin and Balance arbeiten

In Sui Move werdenTokenmithilfe der Module Coin und Balance verwaltet:

• Coin: Eine Hülle rund um das Guthaben, das für die Übertragung von Tokens verwendet wird.

• Guthaben: Stellt den tatsächlichen Betrag der Tokens dar und ermöglicht Operationen wie das Teilen und Zusammenführen.

Zu den wichtigsten Methoden gehören:

• coin: :value (in_coin): Gibt den Gesamtwert eines Coin-Objekts zurück.
• coin: :take (&mut balance, amount, ctx): Extrahiert einen bestimmten Betrag aus einem Guthaben, um eine Münze zu erstellen.
• in_coin.balance_mut () .split (amount): Teilt einen bestimmten Betrag aus dem Guthaben einer Münze auf.
• balance.join (balance): Führt ein Guthaben mit einem anderen zusammen.

Diese Operationen werden verwendet, um den Preispool des Spiels und die Spielerwetten zu verwalten.

Der Vertrag über das Würfelspiel

Hier ist der komplette Code für den Würfelspielvertrag, gefolgt von ausführlichen Erklärungen:

/// Game: Dice rolling. Players bet and guess the number. If correct, they win an amount equal to their bet; if incorrect, the bet goes to the game pool.

module game_duck:game_duck;

use sui::balance::{Self, Balance};
use sui::coin::{Self, Coin};
use sui::random::{Random, new_generator, generate_u8_in_range};
use coin_duck::duckfaucet::DUCKFAUCET;

const ErrorUserInsufficient: u64 = 0x101;
const ErrorGameInsufficient: u64 = 0x102;

public struct Game has key {
    id: UID,
    pool_amount: Balance<DUCKFAUCET>,
}

public struct Admin has key {
    id: UID,
}

fun init(ctx: &mut TxContext) {
    let game = Game {
        id: object::new(ctx),
        pool_amount: balance::zero()
    };
    transfer::share_object(game);

    let admin = Admin { id: object::new(ctx) };
    transfer::transfer(admin, ctx.sender());
}

public entry fun addCoinToGamePool(game: &mut Game, in_coin: &mut Coin<DUCKFAUCET>, amount: u64, _: &mut TxContext) {
    let value = coin::value(in_coin);
    assert!(amount <= value, ErrorUserInsufficient);
    let coin_balance = in_coin.balance_mut().split(amount);
    game.pool_amount.join(coin_balance);
}

public entry fun removeCoinFromGamePool(_: &Admin, game: &mut Game, amount: u64, ctx: &mut TxContext) {
    assert!(game.pool_amount.value() >= amount, ErrorGameInsufficient);
    let coin = coin::take(&mut game.pool_amount, amount, ctx);
    transfer::public_transfer(coin, ctx.sender());
}

entry fun play(game: &mut Game, random: &Random, guess_num: u8, in_coin: &mut Coin<DUCKFAUCET>, amount: u64, ctx: &mut TxContext) {
    assert!(game.pool_amount.value() >= (amount * 3), ErrorGameInsufficient);
    assert!(in_coin.balance().value() >= amount, ErrorUserInsufficient);

    let mut g = new_generator(random, ctx);
    let win_num = generate_u8_in_range(&mut g, 1, 6);

    if (win_num == guess_num) {
        let reward_coin = coin::take(&mut game.pool_amount, amount, ctx);
        in_coin.join(reward_coin);
    } else {
        addCoinToGamePool(game, in_coin, amount, ctx);
    }
}

Struktur des Codeaufbaus

• Spiel: Ein gemeinsames Objekt mit einer eindeutigen ID und einem Pool_amount (Balance) zur Speicherung des Preispools.
• Admin: Ein Schlüsselobjekt, das dem Administrator für die Initialisierung (Init) zur Verwaltung des Pools gehört.

Initialisierung (Init):

• Erzeugt ein Spielobjekt mit leerem Preispool und teilt es öffentlich.
• Erzeugt ein Admin-Objekt und überträgt es an den Vertragsersteller.

Zum Pool hinzufügen (AddCoinToGamePool)

• Zieht einen bestimmten Betrag von der in_coin des Admins ab.
• Verwendet assert! um sicherzustellen, dass die Münze einen ausreichenden Wert hat.
• Teilt den Betrag aus dem Guthaben von in_coin auf und fügt ihn dem Pool_amount des Spiels hinzu.

Ergebnis:

• Gewinn: Stimmt der Tipp mit dem Wurf überein, wird eine Belohnung in Höhe des Einsatzes aus dem Pool genommen und mit der in_coin des Spielers zusammengerechnet.
• Verliere: Falls falsch, wird der Einsatz von in_coin abgezogen und über AddCoinToGamePool dem Pool hinzugefügt.