Bienvenido al siguiente nivel de desarrollo de Sui Move. En esta guía práctica, profundizamos en DeepBook, el potente motor CLOB (libro de órdenes con límite central) del ecosistema de Sui para enseñarte cómo crear un DEX desde cero. Ya sea que estés creando prototipos de aplicaciones DeFi o explorando la mecánica de los tokens, este tutorial te guiará a través de la creación, la interacción y las pruebas de contratos inteligentes con los módulos más recientes de DeepBook.

Introducción: ¿Por qué es importante DeepBook

Si está familiarizado con los protocolos DeFi como Uniswap o dYdX, sabrá lo esencial que es una cartera de pedidos eficiente y en cadena. DeepBook aporta esa capacidad a Sui con un diseño que admite composición de forma nativa. Permite limitar las órdenes, las órdenes de mercado, los fondos de liquidez y las cuentas de custodia, todo ello incluido en los módulos Move.

Este artículo da continuidad a nuestra anterior introducción a DeepBook y es totalmente práctico: te mostraremos cómo acuñar fichas, crear fondos de liquidez, depositar y retirar activos y ejecutar órdenes de mercado y de límite.

Configuración de su proyecto

Empieza por crear un nuevo proyecto de Move:

$ sui move new howtosui_deepbook

Construiremos dos módulos:

*usdt: un token de activo cotizado personalizado *deepbook: nuestra lógica de interacción con los módulos de DeepBook

Módulo de token 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);
    }
}

Integración del módulo 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));
    }
}

Configuración del entorno: pruebas de Localnet

Ejecute su validador localmente:

$ sui client switch --env localnet

Crea dos cuentas:

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

Financie ambos a través de un grifo local.

Despliegue e interactúe

4.1 Publicar módulos

$ sui client publish --gas-budget 100000000

Exporte objetos clave como PACKAGE_ID, TREASURY_CAP_ID, POOL_ID, etc.

4.2 Mint Quote Token (USDT)

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

4.3 Crear grupo

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

4.4 Crear una cuenta de custodio

$ sui client call --function new_custodian_account

4.5 Depositar activos

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

4.6 Realizar pedidos con límite

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

4.7 Ejecutar órdenes de mercado

$ sui client call --function place_base_market_order

5. Conclusión

Con DeepBook, Sui ofrece un motor de cartera de pedidos eficiente, totalmente integrado en cadena y con capacidad de composición, adecuado para protocolos DeFi de alto rendimiento. Desde la acuñación de fichas hasta la ejecución de órdenes, cada componente es programable y se puede comprobar mediante Move. Esta guía le brinda la base para crear sus propias plataformas de negociación, estrategias de liquidez o incluso ecosistemas DeFi complejos gobernados por DAO en Sui.

Estad atentos a la tercera parte, en la que profundizamos en el análisis de eventos, el seguimiento del historial de pedidos y la integración de interfaces mediante el SDK de Sui. Sigamos construyendo