Swap Function Reference

public struct Pool has key {
    id:                     UID,
    paused:                 bool,
    lp_treasury_cap:        TreasuryCap<HLP>,
    total_lp_supply:        u64,
    accounted_value_usd:    u256,
    lp_fee_bps:             u64,
    protocol_fee_bps:       u64,
    max_price_age_ms:       u64,
    sync_interval_ms:       u64,
    protocol_fee_recipient: address,
    assets:                 VecSet<TypeName>,
    asset_configs:          Table<TypeName, AssetConfig>,
}

public struct AssetConfig has copy, drop, store {
    enabled:           bool,
    asset_index:       Bytes32,  // the oracle asset ID for this token
    coin_decimals:     u8,
    target_weight_bps: u64,
    max_trade_bps:     u64,
    max_withdraw_bps:  u64,
    min_liquidity:     u64,
}

public struct AssetVault<phantom T> has key, store {
    id:               UID,
    balance:          Balance<T>,
    cached_value_usd: u256,  // updated periodically via maybe_sync_asset
    last_sync_ms:     u64,
}

public struct ProtocolFeeVault<phantom T> has key, store {
    id:      UID,
    balance: Balance<T>,
}

public entry fun deposit_liquidity<T>(
    pool:       &mut Pool,
    vault:      &mut AssetVault<T>,
    feed:       &IfaPriceFeed,
    coin:       Coin<T>,
    min_lp_out: u64,
    clock:      &Clock,
    ctx:        &mut TxContext,
)

import { Transaction } from "@mysten/sui/transactions";

const tx = new Transaction();
tx.moveCall({
  target: `${PACKAGE_ID}::hetero_swap_periphery::deposit_liquidity`,
  typeArguments: [SUI_COIN_TYPE],
  arguments: [
    tx.object(POOL_ID),
    tx.object(SUI_VAULT_ID),
    tx.object(FEED_ID),
    tx.object(coinObjectId),
    tx.pure.u64(minLpOut),
    tx.object("0x6"),
  ],
});

public entry fun withdraw_liquidity<T>(
    pool:           &mut Pool,
    vault:          &mut AssetVault<T>,
    feed:           &IfaPriceFeed,
    lp_coin:        Coin<HLP>,
    min_amount_out: u64,
    clock:          &Clock,
    ctx:            &mut TxContext,
)

public entry fun swap_exact_input<TIn, TOut>(
    pool:                   &mut Pool,
    vault_in:               &mut AssetVault<TIn>,
    vault_out:              &mut AssetVault<TOut>,
    protocol_fee_vault_out: &mut ProtocolFeeVault<TOut>,
    feed:                   &IfaPriceFeed,
    coin_in:                Coin<TIn>,
    min_amount_out:         u64,
    clock:                  &Clock,
    ctx:                    &mut TxContext,
)

lp_fee       = raw_amount_out × lp_fee_bps / 10,000
protocol_fee = raw_amount_out × protocol_fee_bps / 10,000
amount_out   = raw_amount_out - lp_fee - protocol_fee

// Swap SUI for CNGN
swap_exact_input<SUI, CNGN>(
    &mut pool,
    &mut sui_vault,
    &mut cngn_vault,
    &mut cngn_protocol_fee_vault,
    &feed,
    sui_coin_in,
    min_cngn_out,
    &clock,
    ctx,
);

public entry fun sweep<TDust, TTarget>(
    pool:                      &mut Pool,
    dust_vault:                &mut AssetVault<TDust>,
    target_vault:              &mut AssetVault<TTarget>,
    protocol_fee_vault_target: &mut ProtocolFeeVault<TTarget>,
    feed:                      &IfaPriceFeed,
    dust_coin:                 Coin<TDust>,
    min_target_amount_out:     u64,
    clock:                     &Clock,
    ctx:                       &mut TxContext,
)

public fun quote_exact_input<TIn, TOut>(
    pool:      &Pool,
    feed:      &IfaPriceFeed,
    amount_in: u64,
    clock:     &Clock,
): (u64, u64, u64, u64)

const tx = new Transaction();
tx.moveCall({
  target: `${PACKAGE_ID}::hetero_swap_periphery::quote_exact_input`,
  typeArguments: [SUI_COIN_TYPE, CNGN_COIN_TYPE],
  arguments: [
    tx.object(POOL_ID),
    tx.object(FEED_ID),
    tx.pure.u64(amountIn),
    tx.object("0x6"),
  ],
});

const result = await client.devInspectTransactionBlock({
  transactionBlock: tx,
  sender: callerAddress,
});

// result.results[0].returnValues — four u64 values in the order above
// returnValues[3] is the amount you should use to set min_amount_out
// with an appropriate slippage buffer before submitting the real swap

public fun quote_sweep<TDust, TTarget>(
    pool:        &Pool,
    feed:        &IfaPriceFeed,
    dust_amount: u64,
    clock:       &Clock,
): (u64, u64, u64, u64)

public fun preview_deposit<T>(
    pool:   &Pool,
    feed:   &IfaPriceFeed,
    amount: u64,
    clock:  &Clock,
): u64

public fun preview_withdraw<T>(
    pool:      &Pool,
    feed:      &IfaPriceFeed,
    lp_amount: u64,
    clock:     &Clock,
): u64

public fun get_pool_summary(pool: &Pool): (
    bool,    // paused
    u64,     // total_lp_supply
    u256,    // accounted_value_usd
    u64,     // lp_fee_bps
    u64,     // protocol_fee_bps
    u64,     // max_price_age_ms
    u64,     // sync_interval_ms
    address, // protocol_fee_recipient
    u64,     // number of whitelisted assets (vec_set::length)
)

public fun get_asset_summary<T>(
    pool:      &Pool,
    vault:     &AssetVault<T>,
    fee_vault: &ProtocolFeeVault<T>,
): (
    bool,        // is_whitelisted<T>(pool)
    AssetConfig, // full per-asset config struct
    u64,         // vault.balance (raw token amount currently held)
    u256,        // vault.cached_value_usd (last synced USD value, NOT live)
    u64,         // vault.last_sync_ms
    u64,         // fee_vault.balance (accumulated protocol fees, raw token amount)
)