Swap

1. Standard Swap (Without Partner)

1.1 Using Router Contract

Location: dlmm_router::swap module

swap_a2b

Swap Coin A to Coin B.

public fun swap_a2b<CoinTypeA, CoinTypeB>(
    pool: &mut Pool<CoinTypeA, CoinTypeB>,
    coin_a: &mut Coin<CoinTypeA>,
    by_amount_in: bool,
    amount: u64,
    amount_limit: u64,
    config: &GlobalConfig,
    versioned: &Versioned,
    clock: &Clock,
    ctx: &mut TxContext,
)

swap_b2a

Swap Coin B to Coin A.

public fun swap_b2a<CoinTypeA, CoinTypeB>(
    pool: &mut Pool<CoinTypeA, CoinTypeB>,
    coin_b: &mut Coin<CoinTypeB>,
    by_amount_in: bool,
    amount: u64,
    amount_limit: u64,
    config: &GlobalConfig,
    versioned: &Versioned,
    clock: &Clock,
    ctx: &mut TxContext,
)

Parameters

Parameter	Type	Description
pool	&mut Pool	Pool object (mutable)
coin_a / coin_b	&mut Coin	Input coin object
by_amount_in	bool	true: fix input amount, false: fix output amount
amount	u64	If by_amount_in=true: input amount; else: output amount
amount_limit	u64	If by_amount_in=true: min output; else: max input
config	&GlobalConfig	Global config for validations
versioned	&Versioned	Versioned object for version checking
clock	&Clock	Clock object (0x6)

1.2 Build Custom Swap (Using Flash Swap)

fun swap_<CoinTypeA, CoinTypeB>(
    pool: &mut Pool<CoinTypeA, CoinTypeB>,
    coin_a: &mut Coin<CoinTypeA>,
    coin_b: &mut Coin<CoinTypeB>,
    a2b: bool,
    by_amount_in: bool,
    amount: u64,
    amount_limit: u64,
    versioned: &Versioned,
    config: &GlobalConfig,
    clock: &Clock,
    ctx: &mut TxContext,
) {
    // Step 1: Flash swap - borrow output tokens
    let (receive_a, receive_b, flash_receipt) = pool::flash_swap<CoinTypeA, CoinTypeB>(
        pool,
        a2b,
        by_amount_in,
        amount,
        config,
        versioned,
        clock,
        ctx,
    );

    // Step 2: Validate amounts
    let (in_amount, out_amount) = (
        flash_receipt.pay_amount(),
        if (a2b) receive_b.value() else receive_a.value(),
    );

    if (by_amount_in) {
        assert!(in_amount == amount, ESwapAmountIncorrect);
        assert!(out_amount >= amount_limit, EAmountOutBelowMinLimit);
    } else {
        assert!(out_amount == amount, ESwapAmountIncorrect);
        assert!(in_amount <= amount_limit, EAmountInAboveMaxLimit);
    };

    // Step 3: Prepare repayment
    let (pay_coin_a, pay_coin_b) = if (a2b) {
        assert!(coin_a.value() >= in_amount, ENotEnoughCoin);
        (coin_a.split(in_amount, ctx).into_balance(), balance::zero<CoinTypeB>())
    } else {
        assert!(coin_b.value() >= in_amount, ENotEnoughCoin);
        (balance::zero<CoinTypeA>(), coin_b.split(in_amount, ctx).into_balance())
    };

    // Step 4: Repay flash swap
    pool::repay_flash_swap<CoinTypeA, CoinTypeB>(
        pool,
        pay_coin_a,
        pay_coin_b,
        flash_receipt,
        versioned,
    );

    // Step 5: Collect output
    coin_a.join(receive_a.into_coin(ctx));
    coin_b.join(receive_b.into_coin(ctx));
}

---

2. Partner Swap (With Referral Fee)

Partners can earn referral fees by using partner-specific swap functions. See Partner Integration Guide for complete partner setup.

2.1 Using Router Contract

Location: dlmm_router::swap module

swap_a2b_with_partner

public fun swap_a2b_with_partner<CoinTypeA, CoinTypeB>(
    pool: &mut Pool<CoinTypeA, CoinTypeB>,
    partner: &mut Partner,
    coin_a: &mut Coin<CoinTypeA>,
    by_amount_in: bool,
    amount: u64,
    amount_limit: u64,
    config: &GlobalConfig,
    versioned: &Versioned,
    clock: &Clock,
    ctx: &mut TxContext,
)

swap_b2a_with_partner

public fun swap_b2a_with_partner<CoinTypeA, CoinTypeB>(
    pool: &mut Pool<CoinTypeA, CoinTypeB>,
    partner: &mut Partner,
    coin_b: &mut Coin<CoinTypeB>,
    by_amount_in: bool,
    amount: u64,
    amount_limit: u64,
    config: &GlobalConfig,
    versioned: &Versioned,
    clock: &Clock,
    ctx: &mut TxContext,
)

Additional Parameter

Parameter	Type	Description
partner	&mut Partner	Partner object (shared, mutable)

Other parameters are the same as standard swap.

2.2 Build Custom Swap with Partner (Using Flash Swap)

fun swap_with_partner_<CoinTypeA, CoinTypeB>(
    pool: &mut Pool<CoinTypeA, CoinTypeB>,
    partner: &mut Partner,
    coin_a: &mut Coin<CoinTypeA>,
    coin_b: &mut Coin<CoinTypeB>,
    a2b: bool,
    by_amount_in: bool,
    amount: u64,
    amount_limit: u64,
    config: &GlobalConfig,
    versioned: &Versioned,
    clock: &Clock,
    ctx: &mut TxContext,
) {
    // Step 1: Flash swap with partner - calculates referral fee
    let (receive_a, receive_b, flash_receipt) = pool::flash_swap_with_partner<CoinTypeA, CoinTypeB>(
        pool,
        partner,
        a2b,
        by_amount_in,
        amount,
        config,
        versioned,
        clock,
        ctx,
    );

    // Step 2: Validate amounts
    let (in_amount, out_amount) = (
        flash_receipt.pay_amount(),
        if (a2b) receive_b.value() else receive_a.value(),
    );

    if (by_amount_in) {
        assert!(in_amount == amount, ESwapAmountIncorrect);
        assert!(out_amount >= amount_limit, EAmountOutBelowMinLimit);
    } else {
        assert!(out_amount == amount, ESwapAmountIncorrect);
        assert!(in_amount <= amount_limit, EAmountInAboveMaxLimit);
    };

    // Step 3: Prepare repayment
    let (pay_coin_a, pay_coin_b) = if (a2b) {
        assert!(coin_a.value() >= in_amount, ENotEnoughCoin);
        (coin_a.split(in_amount, ctx).into_balance(), balance::zero<CoinTypeB>())
    } else {
        assert!(coin_b.value() >= in_amount, ENotEnoughCoin);
        (balance::zero<CoinTypeA>(), coin_b.split(in_amount, ctx).into_balance())
    };

    // Step 4: Repay flash swap - referral fee is automatically deposited to partner
    pool::repay_flash_swap_with_partner<CoinTypeA, CoinTypeB>(
        pool,
        partner,
        pay_coin_a,
        pay_coin_b,
        flash_receipt,
        versioned,
    );

    // Step 5: Collect output
    coin_a.join(receive_a.into_coin(ctx));
    coin_b.join(receive_b.into_coin(ctx));
}

2.3 Key Differences from Standard Swap

Aspect	Standard Swap	Partner Swap
Function	flash_swap / repay_flash_swap	flash_swap_with_partner / repay_flash_swap_with_partner
Partner param	Not required	Required (&mut Partner)
Referral fee	None	Calculated and deposited to partner
Fee collection	N/A	Partner must manually claim

Related Documentation

---

• Partner Integration Guide - Partner setup and fee claiming