Skip to main content

​
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<u128>,
  amount_b_desired: Compact<u128>,
  amount_a_min: Compact<u128>,
  amount_b_min: Compact<u128>,
  to: Option<SeedPrimitivesSignatureAccountId20>,
  deadline: Option<u32>
)

​
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<u128>,
  amount_a_min: Compact<u128>,
  amount_b_min: Compact<u128>,
  to: Option<SeedPrimitivesSignatureAccountId20>,
  deadline: Option<u32>
)

​
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<SeedPrimitivesSignatureAccountId20>
)

​
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<u128>,
  amount_out_min: Compact<u128>,
  path: Vec<u32>,
  to: Option<SeedPrimitivesSignatureAccountId20>,
  deadline: Option<u32>
)

​
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<u128>,
  amount_in_max: Compact<u128>,
  path: Vec<u32>,
  to: Option<SeedPrimitivesSignatureAccountId20>,
  deadline: Option<u32>
)

​
Storage

​
feeTo

FeeTo account where network fees are deposited Namespace 
api.query.dex.feeTo
Type 
function feeTo(

): Option<SeedPrimitivesSignatureAccountId20>

​
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<u32>

​
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<SeedPrimitivesSignatureAccountId20>
}

​
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<u32>,
  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<FrameSupportPalletId>

​
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<AssetId>): Json
JSON 
{ "id":1, "jsonrpc":"2.0", "method":"dex_getAmountsIn", "params":[amountOut: u128, path: Vec<AssetId>] }

​
getAmountsOut

Given an array of AssetIds, return amounts out for an amount in Interface 
api.rpc.dex.getAmountsOut(amountIn: u128, path: Vec<AssetId>): Json
JSON 
{ "id":1, "jsonrpc":"2.0", "method":"dex_getAmountsOut", "params":[amountIn: u128, path: Vec<AssetId>] }

​
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] }