> ## Documentation Index > Fetch the complete documentation index at: https://docs.therootnetwork.com/llms.txt > Use this file to discover all available pages before exploring further. # Dex ## Calls ### addLiquidity Add liquidity to Enabled trading pair, or add provision to Provisioning trading pair. * Add liquidity success will issue shares in current price which decided by the liquidity scale. Shares are temporarily not allowed to transfer and trade, it represents the proportion of assets in liquidity pool. * Add provision success will record the provision, issue shares to caller in the initial price when trading pair convert to Enabled. * Creates and enables TradingPair LP token if it does not exist for trading pair. * Fails to add liquidity for `NotEnabled` trading pair. * `token_a`: Asset id A. * `token_b`: Asset id B. * `amount_a_desired`: amount a desired to add. * `amount_b_desired`: amount b desired to add. * `amount_a_min`: amount a minimum willing to add. * `amount_b_min`: amount b minimum willing to add. * `to`: The recipient of the LP token. The caller is the default recipient if it is set to None. * `deadline`: The deadline of executing this extrinsic. The deadline won't be checked if it is set to None **Namespace** ``` api.tx.dex.addLiquidity ``` **Type** ``` function addLiquidity( token_a: u32, token_b: u32, amount_a_desired: Compact, amount_b_desired: Compact, amount_a_min: Compact, amount_b_min: Compact, to: Option, deadline: Option ) ``` ### disableTradingPair Disable an `Enabled` trading pair. * Requires LP token to be created and in the `Enabled` status * Only root can disable trading pair * `token_a`: Asset id A. * `token_b`: Asset id B. **Namespace** ``` api.tx.dex.disableTradingPair ``` **Type** ``` function disableTradingPair( token_a: u32, token_b: u32 ) ``` ### reenableTradingPair Re enable a `NotEnabled` trading pair. * Requires LP token to be created and in the `NotEnabled` status * Only root can enable a disabled trading pair * `token_a`: Asset id A. * `token_b`: Asset id B. **Namespace** ``` api.tx.dex.reenableTradingPair ``` **Type** ``` function reenableTradingPair( token_a: u32, token_b: u32 ) ``` ### removeLiquidity Remove liquidity from specific liquidity pool in the form of burning shares, and withdrawing currencies in trading pairs from liquidity pool in proportion, and withdraw liquidity incentive interest. * note: liquidity can still be withdrawn for `NotEnabled` trading pairs. * `token_a`: Asset id A. * `token_b`: Asset id B. * `liquidity`: liquidity amount to remove. * `amount_a_min`: minimum amount of asset A to be withdrawn from LP token. * `amount_b_min`: minimum amount of asset B to be withdrawn from LP token. * `to`: The recipient of the withdrawn token assets. The caller is the default recipient if it is set to None. * `deadline`: The deadline of executing this extrinsic. The deadline won't be checked if it is set to None **Namespace** ``` api.tx.dex.removeLiquidity ``` **Type** ``` function removeLiquidity( token_a: u32, token_b: u32, liquidity: Compact, amount_a_min: Compact, amount_b_min: Compact, to: Option, deadline: Option ) ``` ### setFeeTo Set the `FeeTo` account. This operation requires root access. * note: analogous to Uniswapv2 `setFeeTo` * `fee_to`: the new account or None assigned to FeeTo. **Namespace** ``` api.tx.dex.setFeeTo ``` **Type** ``` function setFeeTo( fee_to: Option ) ``` ### swapWithExactSupply Trading with DEX, swap with exact supply amount. Specify your input; retrieve variable output. * note: analogous to Uniswapv2 `swapExactTokensForTokens` * `path`: trading path. * `amount_in`: exact supply amount. * `amount_out_min`: acceptable minimum target amount. * `to`: The recipient of the swapped token asset. The caller is the default recipient if it is set to None. * `deadline`: The deadline of executing this extrinsic. The deadline won't be checked if it is set to None **Namespace** ``` api.tx.dex.swapWithExactSupply ``` **Type** ``` function swapWithExactSupply( amount_in: Compact, amount_out_min: Compact, path: Vec, to: Option, deadline: Option ) ``` ### swapWithExactTarget Trading with DEX, swap with exact target amount. Specify your output; supply variable input. * note: analogous to Uniswapv2 `swapTokensForExactTokens` * `amount_out`: exact target amount. * `amount_in_max`: acceptable maximum supply amount. * `path`: trading path. * `to`: The recipient of the swapped token asset. The caller is the default recipient if it is set to None. * `deadline`: The deadline of executing this extrinsic. The deadline won't be checked if it is set to None **Namespace** ``` api.tx.dex.swapWithExactTarget ``` **Type** ``` function swapWithExactTarget( amount_out: Compact, amount_in_max: Compact, path: Vec, to: Option, deadline: Option ) ``` ## Storage ### feeTo FeeTo account where network fees are deposited **Namespace** ``` api.query.dex.feeTo ``` **Type** ``` function feeTo( ): Option ``` ### liquidityPool **Namespace** ``` api.query.dex.liquidityPool ``` **Type** ``` function liquidityPool( PalletDexTradingPair ): (u128,u128) ``` ### liquidityPoolLastK **Namespace** ``` api.query.dex.liquidityPoolLastK ``` **Type** ``` function liquidityPoolLastK( u32 ): U256 ``` ### tradingPairLPToken **Namespace** ``` api.query.dex.tradingPairLPToken ``` **Type** ``` function tradingPairLPToken( PalletDexTradingPair ): Option ``` ### tradingPairStatuses **Namespace** ``` api.query.dex.tradingPairStatuses ``` **Type** ``` function tradingPairStatuses( PalletDexTradingPair ): PalletDexTradingPairStatus ``` ## Events ### AddLiquidity Add liquidity success. \[who, asset\_id\_0, reserve\_0\_increment, asset\_id\_1, reserve\_1\_increment, share\_increment, to] **Namespace** ``` api.events.dex.AddLiquidity ``` **Type** ``` type AddLiquidity = { param0: SeedPrimitivesSignatureAccountId20, param1: u32, param2: u128, param3: u32, param4: u128, param5: u128, param6: SeedPrimitivesSignatureAccountId20 } ``` ### AddProvision Add provision success. \[who, asset\_id\_0, contribution\_0, asset\_id\_1, contribution\_1] **Namespace** ``` api.events.dex.AddProvision ``` **Type** ``` type AddProvision = { param0: SeedPrimitivesSignatureAccountId20, param1: u32, param2: u128, param3: u32, param4: u128 } ``` ### DisableTradingPair Disable trading pair. \[trading\_pair] **Namespace** ``` api.events.dex.DisableTradingPair ``` **Type** ``` type DisableTradingPair = { param0: PalletDexTradingPair } ``` ### EnableTradingPair Enable trading pair. \[trading\_pair] **Namespace** ``` api.events.dex.EnableTradingPair ``` **Type** ``` type EnableTradingPair = { param0: PalletDexTradingPair } ``` ### FeeToSet Set FeeTo account success. \[fee\_to] **Namespace** ``` api.events.dex.FeeToSet ``` **Type** ``` type FeeToSet = { param0: Option } ``` ### ProvisioningToEnabled Provisioning trading pair convert to Enabled. \[trading\_pair, pool\_0\_amount, pool\_1\_amount, total\_share\_amount] **Namespace** ``` api.events.dex.ProvisioningToEnabled ``` **Type** ``` type ProvisioningToEnabled = { param0: PalletDexTradingPair, param1: u128, param2: u128, param3: u128 } ``` ### RemoveLiquidity Remove liquidity from the trading pool success. \[who, asset\_id\_0, reserve\_0\_decrement, asset\_id\_1, reserve\_1\_decrement, share\_decrement, to] **Namespace** ``` api.events.dex.RemoveLiquidity ``` **Type** ``` type RemoveLiquidity = { param0: SeedPrimitivesSignatureAccountId20, param1: u32, param2: u128, param3: u32, param4: u128, param5: u128, param6: SeedPrimitivesSignatureAccountId20 } ``` ### Swap Use supply Asset to swap target Asset. \[trader, trading\_path, supply\_Asset\_amount, target\_Asset\_amount, to] **Namespace** ``` api.events.dex.Swap ``` **Type** ``` type Swap = { param0: SeedPrimitivesSignatureAccountId20, param1: Vec, param2: u128, param3: u128, param4: SeedPrimitivesSignatureAccountId20 } ``` ## Errors ### ExcessiveSupplyAmount Supply amount is more than max\_supply\_amount **Namespace** ``` api.errors.dex.ExcessiveSupplyAmount ``` ### ExpiredDeadline The deadline has been missed **Namespace** ``` api.errors.dex.ExpiredDeadline ``` ### IdenticalTokenAddress **Namespace** ``` api.errors.dex.IdenticalTokenAddress ``` ### InsufficientAmount Insufficent amount **Namespace** ``` api.errors.dex.InsufficientAmount ``` ### InsufficientAmountA Insufficient asset\_a liquidity amount **Namespace** ``` api.errors.dex.InsufficientAmountA ``` ### InsufficientAmountB Insufficient asset\_b liquidity amount **Namespace** ``` api.errors.dex.InsufficientAmountB ``` ### InsufficientInputAmount Insufficient input amount **Namespace** ``` api.errors.dex.InsufficientInputAmount ``` ### InsufficientLiquidity Liquidity is not enough **Namespace** ``` api.errors.dex.InsufficientLiquidity ``` ### InsufficientLiquidityBurnt Insufficient liquidity burnt **Namespace** ``` api.errors.dex.InsufficientLiquidityBurnt ``` ### InsufficientOutputAmount Insufficient output amount **Namespace** ``` api.errors.dex.InsufficientOutputAmount ``` ### InsufficientTargetAmount Target amount is less to min\_target\_amount **Namespace** ``` api.errors.dex.InsufficientTargetAmount ``` ### InsufficientWithdrawnAmountA Insufficient withdraw amount for token A **Namespace** ``` api.errors.dex.InsufficientWithdrawnAmountA ``` ### InsufficientWithdrawnAmountB Insufficient withdraw amount for token B **Namespace** ``` api.errors.dex.InsufficientWithdrawnAmountB ``` ### InvalidAssetId Invalid Asset id **Namespace** ``` api.errors.dex.InvalidAssetId ``` ### InvalidConstantProduct Invalid constant product K **Namespace** ``` api.errors.dex.InvalidConstantProduct ``` ### InvalidInputAmounts Must provide non-zero amount of liquidity **Namespace** ``` api.errors.dex.InvalidInputAmounts ``` ### InvalidLiquidityIncrement The increment of liquidity is invalid **Namespace** ``` api.errors.dex.InvalidLiquidityIncrement ``` ### InvalidTradingPathLength Invalid trading path length **Namespace** ``` api.errors.dex.InvalidTradingPathLength ``` ### LiquidityProviderTokenNotCreated The Liquidity Provider token does not exist **Namespace** ``` api.errors.dex.LiquidityProviderTokenNotCreated ``` ### MustBeEnabled Trading pair must be in Enabled status **Namespace** ``` api.errors.dex.MustBeEnabled ``` ### MustBeNotEnabled Trading pair must be in NotEnabled status **Namespace** ``` api.errors.dex.MustBeNotEnabled ``` ### ZeroSupplyAmount The supply amount is zero **Namespace** ``` api.errors.dex.ZeroSupplyAmount ``` ### ZeroTargetAmount The target amount is zero **Namespace** ``` api.errors.dex.ZeroTargetAmount ``` ## Constants ### defaultFeeTo The default FeeTo account **Namespace** ``` api.consts.dex.defaultFeeTo ``` **Type** ``` type defaultFeeTo = Option ``` ### dexBurnPalletId The DEX's burn id, to provide for a redundant, unredeemable minter/burner address. **Namespace** ``` api.consts.dex.dexBurnPalletId ``` **Type** ``` type dexBurnPalletId = FrameSupportPalletId ``` ### getExchangeFee Trading fee rate The first item of the tuple is the numerator of the fee rate, second item is the denominator, fee\_rate = numerator / denominator, use (u32, u32) over `Rate` type to minimize internal division operation. **Namespace** ``` api.consts.dex.getExchangeFee ``` **Type** ``` type getExchangeFee = (u32,u32) ``` ### lpTokenDecimals Liquidity pair default token decimals **Namespace** ``` api.consts.dex.lpTokenDecimals ``` **Type** ``` type lpTokenDecimals = u8 ``` ### tradingPathLimit The limit for length of trading path **Namespace** ``` api.consts.dex.tradingPathLimit ``` **Type** ``` type tradingPathLimit = u32 ``` ## JSON-RPC Methods ### `getAmountsIn` Given an array of AssetIds, return amounts in for an amount out **Interface** ``` api.rpc.dex.getAmountsIn(amountOut: u128, path: Vec): Json ``` **JSON** ``` { "id":1, "jsonrpc":"2.0", "method":"dex_getAmountsIn", "params":[amountOut: u128, path: Vec] } ``` ### `getAmountsOut` Given an array of AssetIds, return amounts out for an amount in **Interface** ``` api.rpc.dex.getAmountsOut(amountIn: u128, path: Vec): Json ``` **JSON** ``` { "id":1, "jsonrpc":"2.0", "method":"dex_getAmountsOut", "params":[amountIn: u128, path: Vec] } ``` ### `getLPTokenID` Given two AssetIds, return liquidity token created for the pair **Interface** ``` api.rpc.dex.getLPTokenID(assetA: AssetId, assetB: AssetId): Json ``` **JSON** ``` { "id":1, "jsonrpc":"2.0", "method":"dex_getLPTokenID", "params":[assetA: AssetId, assetB: AssetId] } ``` ### `getLiquidity` Given two AssetIds, return liquidity **Interface** ``` api.rpc.dex.getLiquidity(assetA: AssetId, assetB: AssetId): Json ``` **JSON** ``` { "id":1, "jsonrpc":"2.0", "method":"dex_getLiquidity", "params":[assetA: AssetId, assetB: AssetId] } ``` ### `getTradingPairStatus` Given two AssetIds, return whether trading pair is enabled or disabled **Interface** ``` api.rpc.dex.getTradingPairStatus(assetA: AssetId, assetB: AssetId): Text ``` **JSON** ``` { "id":1, "jsonrpc":"2.0", "method":"dex_getTradingPairStatus", "params":[assetA: AssetId, assetB: AssetId] } ``` ### `quote` Given some amount of an asset and pair reserves, returns an equivalent amount of the other asset **Interface** ``` api.rpc.dex.quote(amountA: u128, reserveA: u128, reserveB: u128): Json ``` **JSON** ``` { "id":1, "jsonrpc":"2.0", "method":"dex_quote", "params":[amountA: u128, reserveA: u128, reserveB: u128] } ```