Willkommen auf der nächsten Stufe der Sui Move-Entwicklung. In diesem praktischen Leitfaden tauchen wir tief in DeepBook ein — die leistungsstarke CLOB-Engine (Central Limit Order Book) im Sui-Ökosystem, um Ihnen zu zeigen, wie Sie einen DEX von Grund auf neu erstellen. Egal, ob Sie Prototypen von DeFi-Apps erstellen oder die Token-Mechanik erkunden, dieses Tutorial führt Sie durch die Erstellung, Interaktion und das Testen intelligenter Verträge mit den neuesten Modulen von DeepBook.

Einführung: Warum DeepBook wichtig ist

Wenn Sie mit DeFi-Protokollen wie Uniswap oder dYdX vertraut sind, wissen Sie, wie wichtig ein performantes On-Chain-Orderbuch ist. DeepBook bietet Sui diese Funktion mit einem nativ zusammensetzbaren Design. Es ermöglicht Limit-Orders, Market Orders, Liquiditätspools und Depotkonten — alles in Move-Modulen.

Dieser Artikel knüpft an unsere vorherige Einführung in DeepBook an und wird ganz praktisch: Wir zeigen Ihnen, wie Sie Tokens prägen, Liquiditätspools erstellen, Vermögenswerte einzahlen/abheben und sowohl Limit- als auch Marktaufträge ausführen.

Richten Sie Ihr Projekt ein

Erstellen Sie zunächst ein neues Move-Projekt:

$ sui move new howtosui_deepbook

Wir bauen zwei Module:

*usdt: ein Asset-Token für benutzerdefinierte Angebote *deepbook: unsere Interaktionslogik mit DeepBook-Modulen

USDT-Token-Modul

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);
    }
}

Integration des DeepBook-Moduls

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));
    }
}

Umgebungs-Setup: Localnet-Testing

Führen Sie Ihren Validator lokal aus:

$ sui client switch --env localnet

Erstellen Sie zwei Konten:

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

Finanzieren Sie beide über einen lokalen Wasserhahn.

Bereitstellen und Interagieren

4.1 Module veröffentlichen

$ sui client publish --gas-budget 100000000

Exportieren Sie wichtige Objekte wie PACKAGE_ID, TREASURY_CAP_ID, POOL_ID usw.

4.2 Mint Quote Token (USDT)

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

4.3 Pool erstellen

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

4.4 Depotkonto erstellen

$ sui client call --function new_custodian_account

4.5 Vermögen einzahlen

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

4.6 Limitbestellungen aufgeben

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

4.7 Marktaufträge ausführen

$ sui client call --function place_base_market_order

5. Zusammenfassung

Mit DeepBook bietet Sui eine vollständig ketteninterne, zusammensetzbare und effiziente Orderbuch-Engine, die für leistungsstarke DeFi-Protokolle geeignet ist. Vom Token-Mining bis zur Orderausführung ist jede Komponente über Move programmierbar und testbar. Dieser Leitfaden bietet Ihnen die Grundlage für den Aufbau Ihrer eigenen Handelsplattformen, Liquiditätsstrategien oder sogar komplexer DAO-gesteuerter DeFi-Ökosysteme auf Sui.

Seien Sie gespannt auf Teil 3, in dem wir mithilfe des Sui SDK in die Analyse von Ereignissen, die Verfolgung des Auftragsverlaufs und die Frontend-Integration eintauchen. Lassen Sie uns weiter aufbauen