Bienvenue au niveau supérieur du développement de Sui Move. Dans ce guide pratique, nous approfondissons DeepBook, le puissant moteur CLOB (Central Limit Order Book) de l'écosystème Sui, pour vous montrer comment créer un DEX à partir de zéro. Que vous soyez en train de prototyper des applications DeFi ou d'explorer la mécanique des jetons, ce didacticiel vous expliquera la création, l'interaction et les tests de contrats intelligents à l'aide des derniers modules de DeepBook.

Introduction : pourquoi DeepBook est important

Si vous connaissez les protocoles DeFi tels que Uniswap ou dYdX, vous savez à quel point un carnet de commandes performant et en chaîne est essentiel. DeepBook apporte cette fonctionnalité à Sui grâce à un design composable de manière native. Il permet les ordres à cours limité, les ordres de marché, les pools de liquidités et les comptes de dépôt, le tout intégré dans les modules Move.

Cet article fait suite à notre précédente introduction à DeepBook et est entièrement pratique : nous vous montrerons comment créer des jetons, créer des pools de liquidités, déposer/retirer des actifs et exécuter à la fois des ordres à cours limité et des ordres de marché.

Configuration de votre projet

Commencez par créer un nouveau projet Move :

$ sui move new howtosui_deepbook

Nous allons créer deux modules :

* usdt: un jeton d'actif de cotation personnalisé * deepbook: notre logique d'interaction avec les modules DeepBook

Module de jetons USDT

module howtosui::usdt {
    use sui::coin::{Coin, TreasuryCap, Self};
    public struct USDT has drop {}

    fun init(witness: USDT, ctx: &mut TxContext) {
        let (treasury, metadata) = coin::create_currency(witness, 6, b"USDT", b"", b"", option::none(), ctx);
        transfer::public_freeze_object(metadata);
        transfer::public_transfer(treasury, tx_context::sender(ctx))
    }

    public entry fun mint(treasury_cap: &mut TreasuryCap<USDT>, amount: u64, recipient: address, ctx: &mut TxContext) {
        treasury_cap.mint_and_transfer(amount, recipient, ctx)
    }

    public entry fun burn(treasury_cap: &mut TreasuryCap<USDT>, coin: Coin<USDT>) {
        treasury_cap.burn(coin);
    }
}

Intégration du module DeepBook

module howtosui::deepbook {
    use deepbook::clob_v2 as deepbook;
    use deepbook::custodian_v2 as custodian;
    use sui::coin::{Coin, Self};
    use sui::clock::Clock;

    const FLOAT_SCALING: u64 = 1_000_000_000;

    public fun new_pool<Base, Quote>(payment: &mut Coin<SUI>, ctx: &mut TxContext) {
        let fee = coin::balance_mut(payment).split(100 * FLOAT_SCALING);
        let coin = coin::from_balance(fee, ctx);
        deepbook::create_pool<Base, Quote>(1 * FLOAT_SCALING, 1, coin, ctx);
    }

    public fun new_custodian_account(ctx: &mut TxContext) {
        transfer::public_transfer(deepbook::create_account(ctx), tx_context::sender(ctx));
    }

    public fun make_base_deposit<Base, Quote>(pool: &mut deepbook::Pool<Base, Quote>, coin: Coin<Base>, account_cap: &custodian::AccountCap) {
        deepbook::deposit_base(pool, coin, account_cap);
    }

    public fun make_quote_deposit<Base, Quote>(pool: &mut deepbook::Pool<Base, Quote>, coin: Coin<Quote>, account_cap: &custodian::AccountCap) {
        deepbook::deposit_quote(pool, coin, account_cap);
    }

    public fun withdraw_base<Base, Quote>(pool: &mut deepbook::Pool<Base, Quote>, quantity: u64, account_cap: &custodian::AccountCap, ctx: &mut TxContext) {
        let base = deepbook::withdraw_base(pool, quantity, account_cap, ctx);
        transfer::public_transfer(base, tx_context::sender(ctx));
    }

    public fun place_limit_order<Base, Quote>(
        pool: &mut deepbook::Pool<Base, Quote>,
        client_order_id: u64,
        price: u64,
        quantity: u64,
        self_matching_prevention: u8,
        is_bid: bool,
        expire_timestamp: u64,
        restriction: u8,
        clock: &Clock,
        account_cap: &custodian::AccountCap,
        ctx: &mut TxContext
    ): (u64, u64, bool, u64) {
        deepbook::place_limit_order(pool, client_order_id, price, quantity, self_matching_prevention, is_bid, expire_timestamp, restriction, clock, account_cap, ctx)
    }

    public fun place_base_market_order<Base, Quote>(
        pool: &mut deepbook::Pool<Base, Quote>,
        account_cap: &custodian::AccountCap,
        base_coin: Coin<Base>,
        client_order_id: u64,
        is_bid: bool,
        clock: &Clock,
        ctx: &mut TxContext
    ) {
        let quote_coin = coin::zero<Quote>(ctx);
        let quantity = coin::value(&base_coin);
        place_market_order(pool, account_cap, client_order_id, quantity, is_bid, base_coin, quote_coin, clock, ctx);
    }

    fun place_market_order<Base, Quote>(
        pool: &mut deepbook::Pool<Base, Quote>,
        account_cap: &custodian::AccountCap,
        client_order_id: u64,
        quantity: u64,
        is_bid: bool,
        base_coin: Coin<Base>,
        quote_coin: Coin<Quote>,
        clock: &Clock,
        ctx: &mut TxContext
    ) {
        let (base, quote) = deepbook::place_market_order(pool, account_cap, client_order_id, quantity, is_bid, base_coin, quote_coin, clock, ctx);
        transfer::public_transfer(base, tx_context::sender(ctx));
        transfer::public_transfer(quote, tx_context::sender(ctx));
    }
}

Configuration de l'environnement : tests sur le réseau local

Exécutez votre validateur localement :

$ sui client switch --env localnet

Créez deux comptes :

$ sui client new-address ed25519 yasmine
$ sui client new-address ed25519 yoyo

Financez les deux via un robinet local.

Déployez et interagissez

4.1 Publier des modules

$ sui client publish --gas-budget 100000000

Exportez des objets clés tels que PACKAGE_ID, TREASURY_CAP_ID, POOL_ID, etc.

4.2 Jeton Mint Quote (USDT)

$ sui client call --function mint ... 1000000000 <address>

4.3 Créer un pool

$ sui client call --function new_pool --args <payment_coin_id>

4.4 Créer un compte dépositaire

$ sui client call --function new_custodian_account

4.5 Actifs de dépôt

$ sui client call --function make_base_deposit
$ sui client call --function make_quote_deposit

4.6 Passer des commandes à cours limité

$ sui client call --function place_limit_order --args <price> <quantity> <expire>

4.7 Exécuter les ordres de marché

$ sui client call --function place_base_market_order

5. Récapitulation

Avec DeepBook, Sui propose un moteur de carnet de commandes entièrement en chaîne, composable et efficace, adapté aux protocoles DeFi hautes performances. De la création de jetons à l'exécution des ordres, chaque composant est programmable et testable via Move. Ce guide vous donne la base de référence pour créer vos propres plateformes de trading, stratégies de liquidité ou même des écosystèmes DeFi complexes régis par la DAO sur Sui.

Restez connectés pour la troisième partie, où nous aborderons l'analyse des événements, le suivi de l'historique des commandes et l'intégration du frontend à l'aide du SDK Sui. Continuons à construire