One Format: one1u0zxuhm69tfl0e5ujtltrj99mpr04xm0judmux
0x Format:
0xe3c46e5f7a2ad3f7e69c92feb1c8a5d846fa9b6f
| Parameter | Type | Description |
|---|---|---|
| Parameter | Type | Description |
| tokenA | address | The contract address of the provided token to be converted into the LP token. |
| requireToken | address | The contract address of the other token in the liquidity pool. In other words, the asset that half of tokenA will be converted to that will be added to the liquidity pool. |
| amount | uint | The amount of tokenA to be sent to the liquidity pool. |
| to | address | The recipient of the LP tokens. |
| minOut | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. |
amountIn
(msg.value)
The pathway to change depositToken into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change the depositToken into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### convertSingleAssetToOtherLiquidityETH ``` function convertSingleAssetToOtherLiquidityETH( address requireTokenA,address requireTokenB , address to, address[] calldata path1, address[] calldata path2,uint minOut) payable external ; ``` The `convertSingleAssetToOtherLiquidityETH`function converts AVAX to an uTrade V2 LP token made up of two different tokens. In other words, AVAX will be converted to the two tokens that make up a liquidity pair, and then the two tokens are added to the liquidity pool. | Parameter | Type | Description | | ------------------------------------------------ | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |amountIn
(msg.value)
The pathway to change AVAX into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address must be WAVAX's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As AVAX must be converted to WAVAX, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change AVAX into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address in the array must be WAVAX's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As AVAX must be converted to WAVAX, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsSingleAsset ``` function withdrawSupplyAsSingleAsset( address receiveToken , address liquidityToken ,address tokenA,address tokenB, address payable to, uint amount, bool toReceiveWNative,uint minOut) external ; ``` The `withdrawSupplyAsSingleAsset` function withdraws a user's liquidity from a pool, and converts it to one of the two tokens that makes up the liquidity pool. In other words, it redeems an LP token for one of the two assets that make up an LP token. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native AVAX. If true, the *receiveToken* address should be WAVAX, as it will unwrap WAVAX and send AVAX. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsOtherSingleAsset ``` function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; ``` The `withdrawSupplyAsOtherSingleAsset`function withdraws a user's liquidity from a pool, and converts it to any other asset that is available on uTrade V2. In other words, it redeems an LP token for AVAX or any ERC-20 token available. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *path1* | address |The pathway to change tokenA into the desired asset, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenA to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 must be the same as the last token contract address in path2.
| | *path2* | address |The pathway to change tokenB into the desired asset, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenB to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 must be the same as the last token contract address in path1.
| | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native AVAX. If true, the *receiveToken* address should be WAVAX, as it will unwrap WAVAX and send AVAX. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ## Interface Code ``` interface IUnifiSingleLiquidity { function convertSingleAssetToLiquidity(address tokenA, address requireToken, uint amount, address to, uint minOut) external ; function convertSingleAssetToLiquidityEth(address requireToken, address to, uint minOut) payable external ; function convertSingleAssetToOtherLiquidity(address depositToken, address requireTokenA, address requireTokenB, uint amount, address to, address[] calldata path1, address[] calldata path2, uint minOut) external ; function convertSingleAssetToOtherLiquidityETH(address requireTokenA, address requireTokenB, address to, address[] calldata path1, address[] calldata path2, uint minOut) payable external ; function withdrawSupplyAsSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, bool toReceiveWNative, uint minOut) external ; function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; } ``` # UnifiController.sol # UnifiERC20.sol **Primary Uses -** UnifiERC20.sol essentially ports the properties of BEP-20 tokens on to Unifi LP Tokens, or uTokens. An example of this in practice would be the 'approve' transaction. ## uTrade V2 UnifiERC20 Code / Interfaces | | | | ------------------------------------------- | ------------------------------------------------------------------------------------------------------ | | uTrade V2 UnifiERC20 (Solidity) | [Github](https://github.com/unifiprotocol/utrade-contracts/blob/main/Avalanche/Factory/UnifiERC20.sol) | | uTrade V2 AVAX Interfaces in Solidity | [Github](https://github.com/unifiprotocol/utrade-contracts/blob/main/Avalanche/Factory/interfaces.sol) | | Import statement codeblock (when available) | | ## uTrade V2 UnifiERC20 Contract Addresses Each uTrade V2 Liquidity Pool uses the uTrade V2 ERC20 Interface in the contract. ## Events ### Approval ``` event Approval(address indexed owner, address indexed spender, uint value); ``` The `Approval` event is emitted anytime an `approve` or `permit` function is called. ### Transfer ``` event Transfer(address indexed from, address indexed to, uint value); ``` The `Transfer` event is emitted anytime a transfer of LP tokens occurs, by the `transfer`, `transferFrom`, `mint`, or `burn` functions. ## Read-Only Functions ### name ``` function name() external pure returns (string memory); ``` The `name` function will return "Unifi LPs" for all liquidity pool contracts. ### symbol ``` function symbol() external pure returns (string memory); ``` The `symbol` function will return "Unifi-LP" for all liquidity pool contracts. ### decimals ``` function decimals() external pure returns (uint8); ``` The `decimals` function returns "18" as a uint8 value, which is the precision for each uToken on uTrade V2. ### totalSupply ``` function totalSupply() external view returns (uint); ``` The `totalSupply` function returns the total amount uTokens for a pair. ### balanceOf ``` function balanceOf(address owner) external view returns (uint); ``` The `balanceOf` function returns the balance of uTokens for the provided address. ### allowance ``` function allowance(address owner, address spender) external view returns (uint); ``` The `allowance` function returns the amount of tokens an address is approved to transfer when using the `transferFrom` function. ### DOMAIN\_SEPARATOR ``` function DOMAIN_SEPARATOR() external view returns (bytes32); ``` The `DOMAIN_SEPARATOR` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in `permit` function. ### PERMIT\_TYPEHASH ``` function PERMIT_TYPEHASH() external view returns (bytes32); ``` The `PERMIT_TYPEHASH` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in the `permit` function. ### nonces ``` function nonces(address owner) external view returns (uint); ``` The `nonces` function is used in the permit function. It returns the current nonce of the *address* provided. ## State-Changing Functions ### approve ``` function approve(address spender, uint value) external returns (bool); ``` The `approve` function sets a *value* for the amount of LP tokens the *address* provided is allowed to transfer. Returns a boolean value and emits the `Approval` event. ### transfer ``` function transfer(address to, uint value) external returns (bool); ``` The `transfer` function lets an address send uTokens from one address to another, and returns a boolean value and emits a `Transfer` event. ### transferFrom ``` function transferFrom(address from, address to, uint value) external returns (bool); ``` The `transferFrom` function sends uTokens from one address to another. This requires the sending address to have approval to send uTokens. Returns a boolean value and emits a `Transfer`event. ### permit ``` function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; ``` The permit function allows a sender to use a signature in lieu of an approval transaction, and sets the allowance for an address to send. #### Function Parameter Breakdown | Parameter | Type | Description | | ---------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | *owner* | address | The owner of the address. | | *spender* | address | The spender of the uTokens. | | *value* | uint | The amount of uTokens to be transferred. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | | *v* | uint8 | The v value of the permit. This is one of the three values that makes up the approval signature. | | *r* | bytes32 | The r value of the permit. This is one of the three values that makes up the approval signature. | | *s* | bytes32 | The s value of the permit. This is one of the three values that makes up the approval signature. | ## Interface Code ``` interface IUnifiERC20 { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; } ``` # UnifiFactory.sol **Primary Uses** - The uTrade V2 Factory contract creates an LP token for any pairs listed on uTrade V2, and indexes them for easy retrieval. In addition, it can return the address of the LP token based on a call of the addresses of the two tokens that make up the liquidity pool. ## uTrade V2 Factory Code / Interfaces| uTrade V2 Factory (Solidity) | GitHub |
| uTrade V2 Factory Interface as JSON | GitHub |
| uTrade V2 Factory Interface as Typescript | GitHub |
| Import statement codeblock (when available) |
Sets the minimum amount of tokenA that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of tokenB that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of the supplied token that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of AVAX that can added to the pool before the transaction reverts. This acts as a safeguard.
The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactTokens ``` function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); ``` The `swapTokensForExactTokens` function sends the minimum amount of tokens for the exact amount of another token. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the desired tokens to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactETHForTokens ``` function swapExactETHForTokens( uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapExactETHForTokens` function sends an exact amount of AVAX for a desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of AVAX to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping AVAX to WAVAX, the first address must be WAVAX.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | -------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of AVAX sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactETH ``` function swapTokensForExactETH( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapTokensForExactETH` function sends an amount of tokens for an exact amount of AVAX. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the AVAX to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapExactTokensForETH ``` function swapExactTokensForETH( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapExactTokensForETH` function sends an exact amount of tokens for AVAX. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into AVAX. | | *amountOutMin* | uint | Sets the minimum amount of the AVAX to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Parameter Return Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapETHForExactTokens ``` function swapETHForExactTokens( uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapETHForExactTokens` function swaps an exact amount of AVAX for an amount of the desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of AVAX to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping AVAX to WAVAX, the first address must be WAVX.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | -------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of AVAX sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactTokensForTokensSupportingFeeOnTransferTokens ``` function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The `swapExactTokensForTokensSupportingFeeOnTransferTokens` function is similar to `swapExactTokensForTokens` as it swaps one ERC-20 token for another ERC-20 token. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Name | Type | | | -------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into AVAX. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactETHForTokensSupportingFeeOnTransferTokens ``` function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; ``` The `swapExactETHForTokensSupportingFeeOnTransferTokens`function is similar to `swapExactETHForTokens` function as it swaps an exact amount of AVAX for ERC-20 tokens. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |(amountIn)
msg.value
| uint | Sent as the msg.value, the exact amount of AVAX to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping AVAX to WAVAX, the first address must be WAVAX.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactTokensForETHSupportingFeeOnTransferTokens ``` function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The function `swapExactTokensForETHSupportingFeeOnTransferTokens`is similar to the `swapExactTokensForETH`function, as it swaps an exact amount of ERC-20 tokens for AVAX. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into AVAX. | | *amountOutMin* | uint | Sets the minimum amount of the AVAX to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ## Interface Code ``` interface IUnifiRouter01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUnifiRouter02 is IUnifiRouter01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } ``` # Binance Smart Chain Here you will find in-depth detail of the contracts that make up uTrade V2 on Binance Smart Chain. Each contract includes JSONs as well as Typescript files for integration into your project. Every effort is made to open-source all aspects of uTrade V2, but some do remain private. When a contract is available, you will find a link to the Github source code. # singleLiquidityWrapper.sol **Primary Uses -** Unique to uTrade, the Single Liquidity Wrapper allows BNB or any BEP-20 token to converted into a LP pool. For example, USDT can be added using the wrapper to supply liquidity for a BUSD / WBNB pair. The wrapper allows LP tokens to exit in a similar fashion. The functionality from this wrapper simplifies applications such as compounding or fee-on-transfer additions to liquidity pools. ## uTrade V2 Single Liquidity Wrapper Code / Interfaces | Type | Link | | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Single Liquidity Wrapper (Solidity) | [BscScan Verified](https://bscscan.com/address/0x9fa035D76636d3D2E4d029406492E6A5E0898e81#code) | | uTrade V2 Single Liquidity Wrapper Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiSingleLiquidityWrapper.json) | | uTrade V2 Single Liquidity Wrapper as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiSingleLiquidityWrapper.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Single Liquidity Wrapper Contract Addresses | Network | Address | | ------------ | ------------------------------------------------------------------------------------------------------------------------------------- | | BSC Main Net | `0x9fa035D76636d3D2E4d029406492E6A5E0898e81` ([Link](https://bscscan.com/address/0x9fa035D76636d3D2E4d029406492E6A5E0898e81)) | | BSC Test Net | `0xF68Dbc70C086e20063144a2153c0172Aa318F468` ([Link](https://testnet.bscscan.com/address/0xF68Dbc70C086e20063144a2153c0172Aa318F468)) | ### convertSingleAssetToLiquidity ``` function convertSingleAssetToLiquidity(address tokenA, address requireToken, uint amount, address to, uint minOut) external ; ``` The `convertSingleAssetToLiquidity`function converts one of the assets that a liquidity pool contains into a LP token. It does so by first converting the exact amount of one token required for an equal amount of the other asset that makes up the pool. Next, the two equal values of tokens are added to the liquidity pool. And lastly, the LP tokens are sent to the address provided. | Parameter | Type | Description | | -------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *tokenA* | address | The contract address of the provided token to be converted into the LP token. | | *requireToken* | address | The contract address of the other token in the liquidity pool. In other words, the asset that half of *tokenA* will be converted to that will be added to the liquidity pool. | | *amount* | uint | The amount of *tokenA* to be sent to the liquidity pool. | | *to* | address | The recipient of the LP tokens. | | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### convertSingleAssetToLiquidityEth ``` function convertSingleAssetToLiquidityEth(address requireToken, address to, uint minOut) payable external ; ``` The `convertSingleAssetToLiquidityETH`function converts BNB into a LP token. It does so by first converting the provided BNB into equal amounts of the two tokens that make up the liquidity pool. Next, the two equal values of tokens are added to the liquidity pool. And lastly, the LP tokens are sent to the address provided. The BNB value is sent as a msg.value parameter. One of the two assets can be WBNB. #### Parameter Breakdown | Parameter | Type | Description | | ------------------------------------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | |amountIn
(msg.value)
The pathway to change depositToken into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change the depositToken into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### convertSingleAssetToOtherLiquidityETH ``` function convertSingleAssetToOtherLiquidityETH( address requireTokenA,address requireTokenB , address to, address[] calldata path1, address[] calldata path2,uint minOut) payable external ; ``` The `convertSingleAssetToOtherLiquidityETH`function converts BNB to an uTrade V2 LP token made up of two different tokens. In other words, BNB will be converted to the two tokens that make up a liquidity pair, and then the two tokens are added to the liquidity pool. | Parameter | Type | Description | | ------------------------------------------------ | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |amountIn
(msg.value)
The pathway to change BNB into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address must be WBNB's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As BNB must be converted to WBNB, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change BNB into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address in the array must be WBNB's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As BNB must be converted to WBNB, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsSingleAsset ``` function withdrawSupplyAsSingleAsset( address receiveToken , address liquidityToken ,address tokenA,address tokenB, address payable to, uint amount, bool toReceiveWNative,uint minOut) external ; ``` The `withdrawSupplyAsSingleAsset` function withdraws a user's liquidity from a pool, and converts it to one of the two tokens that makes up the liquidity pool. In other words, it redeems an LP token for one of the two assets that make up an LP token. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native BNB. If true, the *receiveToken* address should be WBNB, as it will unwrap WBNB and send BNB. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsOtherSingleAsset ``` function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; ``` The `withdrawSupplyAsOtherSingleAsset`function withdraws a user's liquidity from a pool, and converts it to any other asset that is available on uTrade V2. In other words, it redeems an LP token for BNB or any BEP-20 token available. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *path1* | address |The pathway to change tokenA into the desired asset, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenA to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 must be the same as the last token contract address in path2.
| | *path2* | address |The pathway to change tokenB into the desired asset, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenB to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 must be the same as the last token contract address in path1.
| | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native BNB. If true, the *receiveToken* address should be WBNB, as it will unwrap WBNB and send BNB. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ## Interface Code ``` interface IUnifiSingleLiquidity { function convertSingleAssetToLiquidity(address tokenA, address requireToken, uint amount, address to, uint minOut) external ; function convertSingleAssetToLiquidityEth(address requireToken, address to, uint minOut) payable external ; function convertSingleAssetToOtherLiquidity(address depositToken, address requireTokenA, address requireTokenB, uint amount, address to, address[] calldata path1, address[] calldata path2, uint minOut) external ; function convertSingleAssetToOtherLiquidityETH(address requireTokenA, address requireTokenB, address to, address[] calldata path1, address[] calldata path2, uint minOut) payable external ; function withdrawSupplyAsSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, bool toReceiveWNative, uint minOut) external ; function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; } ``` # UnifiController.sol The Unifi Controller is a work in progress with minor tweaks here and there. Full documentation will be available once it is optimized! **Primary Uses -** The Unifi Controller is responsible for the setting the variables of UP minting on individual pairs as well as updating the redeem value of UP tokens globally. ## uTrade V2 Controller Code / Interfaces | | | | ------------------------------------------- | --------- | | uTrade V2 Controller (Solidity) | Link Here | | uTrade V2 Controller Interface as JSON | Link Here | | uTrade V2 Controller as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 Controller Contract Addresses | Network | Address | | ------------ | ------------------------------------------------------------------------------------------------------------------------------------- | | BSC Main Net | `0x5b80021bec729DF06438EcAD5edfC48C39F03e89` ([Link](https://bscscan.com/address/0x5b80021bec729DF06438EcAD5edfC48C39F03e89)) | | BSC Test Net | `0xac057d3A6d17F9819BAC2583445a2016E0442532` ([Link](https://testnet.bscscan.com/address/0xac057d3A6d17F9819BAC2583445a2016E0442532)) | ### SwapFeesUPminted ``` event SwapFeesUpminted(address indexed pool, uint amountUPMinted, address defaultPoolAddress, uint platforUPFees); ``` The `SwapFeeUpminted` event is emitted whenever UP is minted. In the majority of cases, this will occur any time a trade occurs. #### Parameter Breakdown | Parameter | Type | Description | | -------------------- | ------- | ----------------------------------------------------------------------------------------------- | | *pool* | address | The liquidity pool where the UP was minted. | | *amountUPMinted* | uint | The amount of UP minted during this event. | | *defaultPoolAddress* | address | The pool representing the 'Super Pair' reward for UNIFI holders. | | *platforUPFees* | uint | The amount of UP collected by the platform for increasing the redeem value and for Super Pairs. | ### UpdatePoolRewards ``` event UpdatePoolRewards(address indexed pool, uint rewards); ``` The UpdatePoolRewards event is emitted when the amount of UP claimable by the liquidity providers in the liquidity pool is updated. This event occurs when a trade occurs and results in UP being minted for liquidity providers, or a liquidity provider performs a claim UP transaction. #### Parameter Breakdown | Parameter | Type | Description | | --------- | ------- | -------------------------------------------------------------------------------- | | *pool* | address | The liquidity pool where the UP was minted. | | *rewards* | uint | The amount of UP available to be claimed by all liquidity providers in the pool. | ## Read-Only Functions #### feeSetter ``` function feeSetter() external view returns (address); ``` The `feeSetter` function returns the address of uTrade V2's Smart Contract which sets the fees for trading. ### WBNB ``` function WBNB() external view returns (address); ``` The `WBNB` function will return the address of WBNB on BSC. As this does not change, it will always return `0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c`. ### UNIFIUPVault ``` function UNIFIUPVault() external view returns (address); ``` The `UNIFIUPVault` function returns the address of the UPBnb vault. This vault contains the BNB that is redeemable for UP. ### nativeFeeTo ``` function nativeFeeTo() external view returns (address); ``` The `nativeFeeTo` function returns the address where, in the case of Unifi Protocol collecting native token fees, the fees would be sent to. # UnifiERC20.sol **Primary Uses -** UnifiERC20.sol essentially ports the properties of BEP-20 tokens on to Unifi LP Tokens, or uTokens. An example of this in practice would be the 'approve' transaction. ## uTrade V2 UnifiERC20 Code / Interfaces | | | | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | | uTrade V2 UnifiERC20 (Solidity) | [BscScan Verified Pair](https://bscscan.com/address/0x76AE2c33bcce5A45128eF2060C6280a452568396#code#F3#L1) (UNIFI / BNB) | | uTrade V2 UnifiERC20 Interface as JSON | Link Here | | uTrade V2 UnifiERC20 as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 UnifiERC20 Contract Addresses Each uTrade V2 Liquidity Pool uses the uTrade V2 ERC20 Interface in the contract. An example would be `0x76AE2c33bcce5A45128eF2060C6280a452568396` ([Link](https://bscscan.com/address/0x76AE2c33bcce5A45128eF2060C6280a452568396)) for the UNIFI / BNB pair. ## Events ### Approval ``` event Approval(address indexed owner, address indexed spender, uint value); ``` The `Approval` event is emitted anytime an `approve` or `permit` function is called. ### Transfer ``` event Transfer(address indexed from, address indexed to, uint value); ``` The `Transfer` event is emitted anytime a transfer of LP tokens occurs, by the `transfer`, `transferFrom`, `mint`, or `burn` functions. ## Read-Only Functions ### name ``` function name() external pure returns (string memory); ``` The `name` function will return "Unifi LPs" for all liquidity pool contracts. ### symbol ``` function symbol() external pure returns (string memory); ``` The `symbol` function will return "Unifi-LP" for all liquidity pool contracts. ### decimals ``` function decimals() external pure returns (uint8); ``` The `decimals` function returns "18" as a uint8 value, which is the precision for each uToken on uTrade V2. ### totalSupply ``` function totalSupply() external view returns (uint); ``` The `totalSupply` function returns the total amount uTokens for a pair. ### balanceOf ``` function balanceOf(address owner) external view returns (uint); ``` The `balanceOf` function returns the balance of uTokens for the provided address. ### allowance ``` function allowance(address owner, address spender) external view returns (uint); ``` The `allowance` function returns the amount of tokens an address is approved to transfer when using the `transferFrom` function. ### DOMAIN\_SEPARATOR ``` function DOMAIN_SEPARATOR() external view returns (bytes32); ``` The `DOMAIN_SEPARATOR` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in `permit` function. ### PERMIT\_TYPEHASH ``` function PERMIT_TYPEHASH() external view returns (bytes32); ``` The `PERMIT_TYPEHASH` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in the `permit` function. ### nonces ``` function nonces(address owner) external view returns (uint); ``` The `nonces` function is used in the permit function. It returns the current nonce of the *address* provided. ## State-Changing Functions ### approve ``` function approve(address spender, uint value) external returns (bool); ``` The `approve` function sets a *value* for the amount of LP tokens the *address* provided is allowed to transfer. Returns a boolean value and emits the `Approval` event. ### transfer ``` function transfer(address to, uint value) external returns (bool); ``` The `transfer` function lets an address send uTokens from one address to another, and returns a boolean value and emits a `Transfer` event. ### transferFrom ``` function transferFrom(address from, address to, uint value) external returns (bool); ``` The `transferFrom` function sends uTokens from one address to another. This requires the sending address to have approval to send uTokens. Returns a boolean value and emits a `Transfer`event. ### permit ``` function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; ``` The permit function allows a sender to use a signature in lieu of an approval transaction, and sets the allowance for an address to send. #### Function Parameter Breakdown | Parameter | Type | Description | | ---------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | *owner* | address | The owner of the address. | | *spender* | address | The spender of the uTokens. | | *value* | uint | The amount of uTokens to be transferred. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | | *v* | uint8 | The v value of the permit. This is one of the three values that makes up the approval signature. | | *r* | bytes32 | The r value of the permit. This is one of the three values that makes up the approval signature. | | *s* | bytes32 | The s value of the permit. This is one of the three values that makes up the approval signature. | ## Interface Code ``` interface IUnifiERC20 { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; } ``` # UnifiFactory.sol **Primary Uses** - The uTrade V2 Factory contract creates an LP token for any pairs listed on uTrade V2, and indexes them for easy retrieval. In addition, it can return the address of the LP token based on a call of the addresses of the two tokens that make up the liquidity pool. ## uTrade V2 Factory Code / Interfaces | | | | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Factory (Solidity) | [BscScan Verified](https://bscscan.com/address/0xA5Ba037Ec16c45f8ae09e013C1849554C01385f5#code) | | uTrade V2 Factory Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiFactory.json) | | uTrade V2 Factory Interface as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiFactory.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Factory Contract Addresses | Network | Address | | ------------ | ------------------------------------------------------------------------------------------------------------------------------------- | | BSC Main Net | `0xA5Ba037Ec16c45f8ae09e013C1849554C01385f5` ([Link](https://bscscan.com/address/0xA5Ba037Ec16c45f8ae09e013C1849554C01385f5)) | | BSC Test Net | `0xcAF0DFf51989Cee8f6437A7152001A42116170d5` ([Link](https://testnet.bscscan.com/address/0xac057d3A6d17F9819BAC2583445a2016E0442532)) | ### PairCreated ``` event PairCreated(address indexed token0, address indexed token1, address pair, uint); ``` Anytime a pair is created on uTrade V2 using the `createPair` function, a `PairCreated` event is emitted. Contracts can be deployed to listen for new pairs on the uTrade V2 BSC Factory address. * *token0* is the token address of the first asset in the token pair. * *token1* is the token address of the second asset in the token pair. * *pair* is the address of the newly created uTrade V2 liquidity pool. * *uint* refers to the index of this uTrade V2 Factory*.* For example, the first liquidity pool created on uTrade V2 is 1, the second liquidity pool is 2, and so on. This number can used with the `allPairs(uint)` to return the address. The current number, and therefore the total number of LP pools on uTrade V2 BSC, can be accessed using the `allPairsLength` function. ## Read-Only Functions ### getPair ``` function getPair(address tokenA, address tokenB) external view returns (address pair); ``` A call to the `getPair` function returns the address of the pair for *tokenA* and *tokenB*. * If the pair does not exist, the call will return *address(0)*. * The order of the tokens is irrelevant in this call. For example, a call for BNB, UNIFI will return the same pair address as UNIFI, BNB. ### allPairs ``` function allPairs(uint) external view returns (address pair); ``` A call to the `allPairs` function returns the address of a pair based on the indexed *uint* value assigned upon creation of the LP. * For example, `allPairs(0)` will return the first pair created on uTrade V2 BSC. * If the index number is too high, as in, there aren't enough pairs created yet, the function will return *address(0)*. ### allPairsLength ``` function allPairsLength() external view returns (uint); ``` A call to the `allPairsLength` function returns the current number of pairs. * For example, if there are 201 total liquidity pool pairs on uTrade V2 BSC, this call will return *200* as an uint value. ### feeTo ``` function feeTo() external view returns (address); ``` A call to the `feeTo` function returns the percentage of trading fees that Unifi Protocol receives. * Due to the nature of UP Token economics, this is set to zero, but is preserved for flexibility in the future. ### feeToSetter ``` function feeToSetter() external view returns (address); ``` A call to the `feeToSetter` function returns the address to which the `feeTo` would send trading fees, if trading fees were collected. ## State-Changing Functions ### createPair ``` function createPair(address tokenA, address tokenB) external returns (address pair); ``` Creates a liquidity pool pair for *tokenA* and *tokenB* if one does not currently exist. After the function is confirmed on chain, a `PairCreated` event is emitted. ## Interface Code ``` interface UnifiFactory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function createPair(address tokenA, address tokenB) external returns (address pair); } ``` ### ### # UnifiPair.sol **Primary Uses -** UnifiPair.sol is responsible for many of the functionalities of liquidity pool tokens and UP tokens. First, it is responsible for the issuing and burning of Liquidity Pool Tokens (uTokens). In addition, it allows for direct reads of the reserves and ratio of the liquidity pool, as well as swaps. Lastly, it is where UP claims are processed. ## uTrade V2 Pair Code / Interfaces | | | | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | | uTrade V2 Pair (Solidity) | [BscScan Verified Pair](https://bscscan.com/address/0x76AE2c33bcce5A45128eF2060C6280a452568396#code#F1#L1) (UNIFI / BNB) | | uTrade V2 Pair Interface as JSON | Link Here | | uTrade V2 Pair as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 Pair Contract Addresses Each uTrade V2 Liquidity Pool uses uTrade V2 Pair Solidity Contract. For instance, `0x76AE2c33bcce5A45128eF2060C6280a452568396` ([Link](https://bscscan.com/address/0x76AE2c33bcce5A45128eF2060C6280a452568396)) is the address for the UNIFI / BNB pair on Binance Smart Chain - Main Net. ## Events ### Mint ``` event Mint(address indexed sender, uint amount0, uint amount1); ``` The `Mint` event is emitted any time liquidity tokens are created via the `mint` function. In other words, when a user adds liquidity to a pair, then they will receive LP tokens, therefore the `Mint` event will be emitted. ### Burn ``` event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); ``` The `Burn` event is emitted any time liquidity tokens are burned via the `burn` function. In other words, when a user removes liquidity from a pair, their LP tokens will be burned, therefore the `Burn` event will be emitted. ### Swap ``` event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); ``` The `Swap` event is emitted any time the `swap` function is used. Under the hood, all trades on uTrade V2 are swaps. Therefore, any time somebody trades on the pair, the uTrade contract for that pair will emit a `Swap` event. ### Sync ``` event Sync(uint112 reserve0, uint112 reserve1); ``` The `Sync` event is emitted anytime a function occurs that may change the reserves of a token pair. In other words, anytime the amount of the two tokens within a liquidity pool may change. Therefore, whenever a`mint`, `burn`, `swap`, or `sync` function is called, the `Sync` event will be emitted. ## Read-Only Functions ### MINIMUM\_LIQUIDITY ``` function MINIMUM_LIQUIDITY() external pure returns (uint); ``` The `MINIMUM_LIQUIDITY`function will always return 1000. The function itself refers to the burning of initial LP tokens that occurs once when a pool is created. This burn of a tiny amount allows for cleaner LP token numbers therefore avoiding LP tokens being represented as very small decimals value. This allows the tick size to be more precise and prevents rounding errors. ### factory ``` function factory() external view returns (address); ``` The `factory` function will return the current factory address for uTrade V2. ### WBNB ``` function WBNB() external view returns (address); ``` The WBNB function will return the address of WBNB on BSC. As this does not change, it will always return `0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c`. ### token0 ``` function token0() external view returns (address); ``` The `token0` function will return the contract address of the first token that makes up the liquidity pair. In other words, if the liquidity pool is made up of USDT / USDC, it will return the contract address of USDT. ### token1 ``` function token1() external view returns (address); ``` The `token1` function will return the contract address of the first token that makes up the liquidity pair. In other words, if the liquidity pool is made up of USDT / USDC, it will return the contract address of USDC. ### getReserves ``` function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); ``` The `getReserves` function returns the reserves of the two tokens that make up the liquidity pool as *reserve0* and *reserve1*. These two values can be helpful in determining the current price of each asset. The function also returns a timestamp with the block number. ### price0CumulativeLast ``` function price0CumulativeLast() external view returns (uint); ``` The `price0CumulativeLast` function is for Oracle usage on uTrade V2. The value of *token0* is captured at the end of each block, and can be called using this function to feed into an Oracle to determine a more time-weighted 'average' price. ### price1CumulativeLast ``` function price1CumulativeLast() external view returns (uint); ``` The `price1CumulativeLast` function is for Oracle usage on uTrade V2. The value of *token1* is captured at the end of each block, and can be called using this function to feed into an Oracle to determine a more time-weighted 'average' price. ### kLast ``` function kLast() external view returns (uint); ``` The `kLast` function returns the value of *reserve0* \* *reserve1*, after any event that may have triggered a change in the liquidity. For example, the execution of a *swap* function or a *mint* function. ## State-Changing Functions ### mint ``` function mint(address to) external returns (uint liquidity); ``` The `mint` function creates the LP tokens that represent a user's tokens in a liquidity pool. For example, if a user provides 1 BNB and 300 USDT liquidity to a pool, the Unifi Pair Smart Contract will mint an amount of uBNBUSDT tokens. Will emit the `Mint`, `Sync`, and `Transfer` events. ### burn ``` function burn(address to) external returns (uint amount0, uint amount1); ``` The `burn` function destroys the LP tokens that represent a user's token in a liquidity pool. For example, if a user removes 1 BNB and 300 USDT liquidity to a pool, the Unifi Pair Smart Contract will burn an amount of uBNBUSDT tokens. Will emit the `Burn`, `Sync`, and `Transfer` events. ### claimUP ``` function claimUP(address to) external lock returns(uint) { ``` The `claimUP` function claims any UP earned from providing liquidity if any exists, and sends the UP to the address provided. ### swap ``` function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; ``` The `swap` function exchanges one token for another. Under the hood, all trades on uTrade V2 use this function. The *calldata* must be 0 during a normal swap, but must contain data if executing a flash loan. Emits the `Swap` and `Sync` events. ### skim ``` function skim(address to) external; ``` The `skim` function operates as a safeguard if the amount of tokens causes a data error due to too large of a number in the reserves pools. In this unusual circumstance, this will trigger failures in trades. The `skim` function can be called to return the overflowed tokens to the caller. ### sync ``` function sync() external; ``` The `sync` function operates as a safeguard in certain events where the token balance changes outside of normal trading. An example would be an algorithmic stablecoin re-balancing, therefore lowering or raising the amount of the algorithmic stablecoin in the pool. The `sync` function may be called to reset the price ratio to the new reserves. Emits the `Sync`event. ## Interface Code ``` interface IUnifiPair { event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } ``` # UnifiRouter.sol **Primary Uses** - The uTrade V2 Router is the 'brain' of uTrade. The router finds the optimal path for exchanging one token for another. Whenever a trade is made, your wallet sends funds to the router address. The router will then carry out as many transactions as necessary to acquire the desired token. The router also handles adding liquidity to liquidity pools, and sending the corresponding LP tokens to liquidity providers. ## uTrade V2 Router Code / Interfaces | | | | ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Router (Solidity) | [BscScan Verified](https://bscscan.com/address/0xBE930734eDAfc41676A76d2240f206Ed36dafbA2#code) | | uTrade V2 Router Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiRouter.json) | | uTrade V2 Router Interface as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiRouter.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Router Contract Addresses | Network | Address | | ------------ | ------------------------------------------------------------------------------------------------------------------------------------- | | BSC Main Net | `0xBE930734eDAfc41676A76d2240f206Ed36dafbA2`([Link](https://bscscan.com/address/0xBE930734eDAfc41676A76d2240f206Ed36dafbA2)) | | BSC Test Net | `0x8E07E90f7F5AD5EBaCCE04f020BD08D7572BB36E` ([Link](https://testnet.bscscan.com/address/0xac057d3A6d17F9819BAC2583445a2016E0442532)) | ### factory ``` function factory() external pure returns (address); ``` A call to the `factory` function returns the address of the current Factory used by uTrade v2. The current factory address for uTrade V2 on Binance Smart Chain is `0xA5Ba037Ec16c45f8ae09e013C1849554C01385f5` . ### WETH ``` function WETH() external pure returns (address); ``` A call to the `WETH` function returns the address of Wrapped BNB (WBNB) on Binance Smart Chain. As this address does not change, it will always return `0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c`. ### quote ``` function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); ``` A call to the `quote` function returns the amount of *tokenB* that will be received for an amount of *tokenA*. This can be used to calculate the exchange rate between two tokens without factoring in slippage or fees. By entering the amount of *tokenA,* the total amount of reserves of *tokenA* as *reserveA,* and the total amount of reserves of *tokenB* as *reserveB*, the call will return the equivalent amount of *tokenB*. ### getAmountOut ``` function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); ``` A call to the `getAmountOut`function with the amount of the token being sent will return the maximum amount of a token to be received, accounting for fees and the total amount of reserves. ### getAmountIn ``` function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); ``` A call to the `getAmountIn` function with the amount of the token you wish to receive will return the minimum amount required of the token you wish to send, accounting for fees and the total amount of reserves. ### getAmountsOut ``` function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); ``` A call to the `getAmountsOut` function with the amount of the token being sent will return the maximum amount to be received of multiple different tokens. By entering multiple LP addresses in the *address* array, the function will return the maximum amount of each token that will be received. A call to this function uses the `getReserves` function from [UnifiPair.sol](https://docs.unifiprotocol.com/utrade-v2/binance-smart-chain/unifipair.sol) to determine the reserves of the liquidity pool. Then, it calls the `getAmountOut` function to determine the amount of each token in the array that will be received for the *amountIn* value of a token. ### getAmountsIn ``` function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); ``` A call to the `getAmountsIn` function with the desired amount of the token to be received will return the minimum amount required to be sent of multiple tokens. By entering multiple LP addresses in the *address* array, the function will return the minimum amount of each token that will need to be sent to receive the desired amount of a token. A call to this function uses the `getReserves` function from [UnifiPair.sol](https://docs.unifiprotocol.com/utrade-v2/binance-smart-chain/unifipair.sol) to determine the reserves of the liquidity pool. Then, it calls the `getAmountIn` function to determine the amount of each token in the array that will need to be sent for the *amountOut* value of a token. ## State-Changing Functions - Liquidity ### addLiquidity ``` function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); ``` The `addLiquidity` function adds the two tokens that make up the liquidity pool - *tokenA* and *tokenB* - at the proper ratio based on the reserves of the pool. For example, if the pool contains 500 USDT / 2 BNB, a user's liquidity will be added at the ratio of 250 USDT to 1 BNB, provided there is no price movements in the pair between when the user broadcasts the transaction to when it is mined. In the event of a price movement, the *amountADesired*, *amountBDesired*, *amountAMin*, and *amountBMin* act as a security measure against an adverse price movement. After the liquidity is added, the function sends the corresponding LP tokens to the sender. In the case of a pool not existing for the two assets, one will be created using [UnifiFactory.sol](https://app.gitbook.com/@unifi-protocol/s/unifi-protocol/utrade-v2/binance-smart-chain/utrade-v2-factory) at the ratio of the assets supplied. #### Function Parameters Breakdown | Parameter | Type | Description | | ---------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *tokenA* | address | Token address of the first asset in the token pair. | | *tokenB* | address | Token address of the second asset in the token pair. | | *amountADesired* | uint | The amount of *tokenA* to be added to liquidity if the value of *tokenA* goes down in comparison to *tokenB*. | | *amountBDesired* | uint | The amount of *tokenB* to be added to liquidity if the value of *tokenB* goes down in comparison to *tokenA.* | | *amountAMin* | uint |Sets the minimum amount of tokenA that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of tokenB that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of the supplied token that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of BNB that can added to the pool before the transaction reverts. This acts as a safeguard.
The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactTokens ``` function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); ``` The `swapTokensForExactTokens` function sends the minimum amount of tokens for the exact amount of another token. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the desired tokens to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactETHForTokens ``` function swapExactETHForTokens( uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapExactETHForTokens` function sends an exact amount of BNB for a desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of BNB to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping BNB to WBNB, the first address must be WBNB.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of BNB sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactETH ``` function swapTokensForExactETH( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapTokensForExactETH` function sends an amount of tokens for an exact amount of BNB. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the BNB to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapExactTokensForETH ``` function swapExactTokensForETH( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapExactTokensForETH` function sends an exact amount of tokens for BNB. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into BNB. | | *amountOutMin* | uint | Sets the minimum amount of the BNB to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Parameter Return Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapETHForExactTokens ``` function swapETHForExactTokens( uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapETHForExactTokens` function swaps an exact amount of BNB for an amount of the desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of BNB to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping BNB to WBNB, the first address must be WBNB.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of BNB sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactTokensForTokensSupportingFeeOnTransferTokens ``` function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The `swapExactTokensForTokensSupportingFeeOnTransferTokens` function is similar to `swapExactTokensForTokens` as it swaps one BEP-20 token for another BEP-20 token. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Name | Type | | | -------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into BNB. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactETHForTokensSupportingFeeOnTransferTokens ``` function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; ``` The `swapExactETHForTokensSupportingFeeOnTransferTokens`function is similar to `swapExactETHForTokens` function as it swaps an exact amount of BNB for BEP-20 tokens. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the exact amount of BNB to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping BNB to WBNB, the first address must be WBNB.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactTokensForETHSupportingFeeOnTransferTokens ``` function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The function `swapExactTokensForETHSupportingFeeOnTransferTokens`is similar to the `swapExactTokensForETH`function, as it swaps an exact amount of BEP-20 tokens for BNB. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into BNB. | | *amountOutMin* | uint | Sets the minimum amount of the BNB to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ## Interface Code ``` interface IUnifiRouter01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUnifiRouter02 is IUnifiRouter01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } ``` # BitTorrent Chain Here you will find in-depth detail of the contracts that make up uTrade V2 on BitTorrent Chain. Each contract includes JSONs as well as Typescript files for integration into your project. Every effort is made to open-source all aspects of uTrade V2, but some do remain private. When a contract is available, you will find a link to the Github source code. # singleLiquidityWrapper.sol **Primary Uses -** Unique to uTrade, the Single Liquidity Wrapper allows BTT or any BRC-20 token on BTT to converted into a LP pool. For example, USDT can be added using the wrapper to supply liquidity for a USDT.t / WBTT pair. The wrapper allows LP tokens to exit in a similar fashion. The functionality from this wrapper simplifies applications such as compounding or fee-on-transfer additions to liquidity pools. ## uTrade V2 Single Liquidity Wrapper Code / Interfaces | | | | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Single Liquidity Wrapper (Solidity) | [GitHub](https://github.com/unifiprotocol/utrade-contracts/blob/main/BTT/SingleLiquidity/singleLiquidityWrapper.sol) | | uTrade V2 Single Liquidity Wrapper Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiSingleLiquidityWrapper.json) | | uTrade V2 Single Liquidity Wrapper as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiSingleLiquidityWrapper.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Single Liquidity Wrapper Contract Addresses | Network | Address | | ---------------- | ------------------------------------------------------------------------------------------------------------------------------- | | BitTorrent Chain | `0xb986284c89cc9ca5427582222f5e1af4ea0ef99c` ([Link](https://scan.bt.io/#/contract/0xb986284c89cc9ca5427582222f5e1af4ea0ef99c)) | ### ### convertSingleAssetToLiquidity ``` function convertSingleAssetToLiquidity(address tokenA, address requireToken, uint amount, address to, uint minOut) external ; ``` The `convertSingleAssetToLiquidity`function converts one of the assets that a liquidity pool contains into a LP token. It does so by first converting the exact amount of one token required for an equal amount of the other asset that makes up the pool. Next, the two equal values of tokens are added to the liquidity pool. And lastly, the LP tokens are sent to the address provided.| Parameter | Type | Description |
|---|---|---|
| Parameter | Type | Description |
| tokenA | address | The contract address of the provided token to be converted into the LP token. |
| requireToken | address | The contract address of the other token in the liquidity pool. In other words, the asset that half of tokenA will be converted to that will be added to the liquidity pool. |
| amount | uint | The amount of tokenA to be sent to the liquidity pool. |
| to | address | The recipient of the LP tokens. |
| minOut | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. |
| Parameter | Type | Description |
|---|---|---|
| Parameter | Type | Description |
| amountIn (msg.value) | uint | The amount of BTT to be converted to the two tokens that make up a liquidity pool. Sent as the message value. |
| requireToken | address | The address of the LP token token contract that is being supplied. |
| to | address | The recipient of the LP tokens. |
| minOut | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. |
The pathway to change depositToken into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change the depositToken into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### convertSingleAssetToOtherLiquidityETH ``` function convertSingleAssetToOtherLiquidityETH( address requireTokenA,address requireTokenB , address to, address[] calldata path1, address[] calldata path2,uint minOut) payable external ; ``` The `convertSingleAssetToOtherLiquidityETH`function converts BTT to an uTrade V2 LP token made up of two different tokens. In other words, BTT will be converted to the two tokens that make up a liquidity pair, and then the two tokens are added to the liquidity pool. | Parameter | Type | Description | | ------------------------------------------------ | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |amountIn
(msg.value)
The pathway to change AVAX into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address must be WBTT's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As AVAX must be converted to WBTT, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change BTT into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address in the array must be WBTT's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As BTT must be converted to WBTT, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsSingleAsset ``` function withdrawSupplyAsSingleAsset( address receiveToken , address liquidityToken ,address tokenA,address tokenB, address payable to, uint amount, bool toReceiveWNative,uint minOut) external ; ``` The `withdrawSupplyAsSingleAsset` function withdraws a user's liquidity from a pool, and converts it to one of the two tokens that makes up the liquidity pool. In other words, it redeems an LP token for one of the two assets that make up an LP token. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native BTT. If true, the *receiveToken* address should be WBTT, as it will unwrap WBTT and send BTT. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsOtherSingleAsset ``` function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; ``` The `withdrawSupplyAsOtherSingleAsset`function withdraws a user's liquidity from a pool, and converts it to any other asset that is available on uTrade V2. In other words, it redeems an LP token for BTT or any BRC-20 token available. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *path1* | address |The pathway to change tokenA into the desired asset, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenA to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 must be the same as the last token contract address in path2.
| | *path2* | address |The pathway to change tokenB into the desired asset, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenB to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 must be the same as the last token contract address in path1.
| | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native BTT. If true, the *receiveToken* address should be WBTT, as it will unwrap WBTT and send BTT. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ## Interface Code ``` interface IUnifiSingleLiquidity { function convertSingleAssetToLiquidity(address tokenA, address requireToken, uint amount, address to, uint minOut) external ; function convertSingleAssetToLiquidityEth(address requireToken, address to, uint minOut) payable external ; function convertSingleAssetToOtherLiquidity(address depositToken, address requireTokenA, address requireTokenB, uint amount, address to, address[] calldata path1, address[] calldata path2, uint minOut) external ; function convertSingleAssetToOtherLiquidityETH(address requireTokenA, address requireTokenB, address to, address[] calldata path1, address[] calldata path2, uint minOut) payable external ; function withdrawSupplyAsSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, bool toReceiveWNative, uint minOut) external ; function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; } ``` # UnifiERC20.sol **Primary Uses -** UnifiERC20.sol essentially ports the properties of BEP-20 tokens on to Unifi LP Tokens, or uTokens. An example of this in practice would be the 'approve' transaction. ## uTrade V2 UnifiERC20 Code / Interfaces | | | | ------------------------------------------- | ------------------------------------------------------------------------------------------------- | | uTrade V2 UnifiERC20 (Solidity) | [Github ](https://github.com/unifiprotocol/utrade-contracts/blob/main/BTT/Factory/UnifiERC20.sol) | | uTrade V2 BTT Interfaces in Solidity | [Github](https://github.com/unifiprotocol/utrade-contracts/blob/main/BTT/Factory/interfaces.sol) | | Import statement codeblock (when available) | | ## uTrade V2 UnifiERC20 Contract Addresses Each uTrade V2 Liquidity Pool uses the uTrade V2 ERC20 Interface in the contract. ## Events ### Approval ``` event Approval(address indexed owner, address indexed spender, uint value); ``` The `Approval` event is emitted anytime an `approve` or `permit` function is called. ### Transfer ``` event Transfer(address indexed from, address indexed to, uint value); ``` The `Transfer` event is emitted anytime a transfer of LP tokens occurs, by the `transfer`, `transferFrom`, `mint`, or `burn` functions. ## Read-Only Functions ### name ``` function name() external pure returns (string memory); ``` The `name` function will return "Unifi LPs" for all liquidity pool contracts. ### symbol ``` function symbol() external pure returns (string memory); ``` The `symbol` function will return "Unifi-LP" for all liquidity pool contracts. ### decimals ``` function decimals() external pure returns (uint8); ``` The `decimals` function returns "18" as a uint8 value, which is the precision for each uToken on uTrade V2. ### totalSupply ``` function totalSupply() external view returns (uint); ``` The `totalSupply` function returns the total amount uTokens for a pair. ### balanceOf ``` function balanceOf(address owner) external view returns (uint); ``` The `balanceOf` function returns the balance of uTokens for the provided address. ### allowance ``` function allowance(address owner, address spender) external view returns (uint); ``` The `allowance` function returns the amount of tokens an address is approved to transfer when using the `transferFrom` function. ### DOMAIN\_SEPARATOR ``` function DOMAIN_SEPARATOR() external view returns (bytes32); ``` The `DOMAIN_SEPARATOR` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in `permit` function. ### PERMIT\_TYPEHASH ``` function PERMIT_TYPEHASH() external view returns (bytes32); ``` The `PERMIT_TYPEHASH` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in the `permit` function. ### nonces ``` function nonces(address owner) external view returns (uint); ``` The `nonces` function is used in the permit function. It returns the current nonce of the *address* provided. ## State-Changing Functions ### approve ``` function approve(address spender, uint value) external returns (bool); ``` The `approve` function sets a *value* for the amount of LP tokens the *address* provided is allowed to transfer. Returns a boolean value and emits the `Approval` event. ### transfer ``` function transfer(address to, uint value) external returns (bool); ``` The `transfer` function lets an address send uTokens from one address to another, and returns a boolean value and emits a `Transfer` event. ### transferFrom ``` function transferFrom(address from, address to, uint value) external returns (bool); ``` The `transferFrom` function sends uTokens from one address to another. This requires the sending address to have approval to send uTokens. Returns a boolean value and emits a `Transfer`event. ### permit ``` function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; ``` The permit function allows a sender to use a signature in lieu of an approval transaction, and sets the allowance for an address to send. #### Function Parameter Breakdown | Parameter | Type | Description | | ---------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | *owner* | address | The owner of the address. | | *spender* | address | The spender of the uTokens. | | *value* | uint | The amount of uTokens to be transferred. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | | *v* | uint8 | The v value of the permit. This is one of the three values that makes up the approval signature. | | *r* | bytes32 | The r value of the permit. This is one of the three values that makes up the approval signature. | | *s* | bytes32 | The s value of the permit. This is one of the three values that makes up the approval signature. | ## Interface Code ``` interface IUnifiERC20 { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; } ``` # UnifiFactory.sol **Primary Uses** - The uTrade V2 Factory contract creates an LP token for any pairs listed on uTrade V2, and indexes them for easy retrieval. In addition, it can return the address of the LP token based on a call of the addresses of the two tokens that make up the liquidity pool. ## uTrade V2 Factory Code / Interfaces| uTrade V2 Factory (Solidity) | GitHub |
| uTrade V2 Factory Interface as JSON | GitHub |
| uTrade V2 Factory Interface as Typescript | GitHub |
| Import statement codeblock (when available) |
Sets the minimum amount of tokenA that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of tokenB that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of the supplied token that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of BTT that can added to the pool before the transaction reverts. This acts as a safeguard.
The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactTokens ``` function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); ``` The `swapTokensForExactTokens` function sends the minimum amount of tokens for the exact amount of another token. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the desired tokens to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactETHForTokens ``` function swapExactETHForTokens( uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapExactETHForTokens` function sends an exact amount of BTT for a desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of BTT to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping BTT to WBTT, the first address must be WBTT.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of BTT sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactETH ``` function swapTokensForExactETH( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapTokensForExactETH` function sends an amount of tokens for an exact amount of BTT. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the BTT to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapExactTokensForETH ``` function swapExactTokensForETH( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapExactTokensForETH` function sends an exact amount of tokens for BTT. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into BTT. | | *amountOutMin* | uint | Sets the minimum amount of the BTT to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Parameter Return Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapETHForExactTokens ``` function swapETHForExactTokens( uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapETHForExactTokens` function swaps an exact amount of BTT for an amount of the desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of BTT to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping BTT to WBTT, the first address must be WBTT.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of BTT sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactTokensForTokensSupportingFeeOnTransferTokens ``` function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The `swapExactTokensForTokensSupportingFeeOnTransferTokens` function is similar to `swapExactTokensForTokens` as it swaps one BRC-20 token for another BRC-20 token. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Name | Type | | | -------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into BTT. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactETHForTokensSupportingFeeOnTransferTokens ``` function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; ``` The `swapExactETHForTokensSupportingFeeOnTransferTokens`function is similar to `swapExactETHForTokens` function as it swaps an exact amount of BTT for BRC-20 tokens. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the exact amount of BTT to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping BTT to WBTT, the first address must be WBTT.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactTokensForETHSupportingFeeOnTransferTokens ``` function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The function `swapExactTokensForETHSupportingFeeOnTransferTokens`is similar to the `swapExactTokensForETH`function, as it swaps an exact amount of BRC-20 tokens for BTT. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into BTT. | | *amountOutMin* | uint | Sets the minimum amount of the BTT to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ## Interface Code ``` interface IUnifiRouter01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUnifiRouter02 is IUnifiRouter01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } ``` # Ethereum Here you will find in-depth detail of the contracts that make up uTrade V2 on Ethereum. Each contract includes JSONs as well as Typescript files for integration into your project. Every effort is made to open-source all aspects of uTrade V2, but some do remain private. When a contract is available, you will find a link to the Github source code. # singleLiquidityWrapper.sol **Primary Uses -** Unique to uTrade, the Single Liquidity Wrapper allows ETH or any ERC-20 token to converted into a LP pool. For example, USDT can be added using the wrapper to supply liquidity for a BUSD / WETH pair. The wrapper allows LP tokens to exit in a similar fashion. The functionality from this wrapper simplifies applications such as compounding or fee-on-transfer additions to liquidity pools. ## uTrade V2 Single Liquidity Wrapper Code / Interfaces | | | | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Single Liquidity Wrapper (Solidity) | [Etherscan Verified](https://etherscan.io/address/0x791ca4e3b1ddf69bb7635684e1fb50f0bc0fc917#code) | | uTrade V2 Single Liquidity Wrapper Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiSingleLiquidityWrapper.json) | | uTrade V2 Single Liquidity Wrapper as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiSingleLiquidityWrapper.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Single Liquidity Wrapper Contract Addresses | Network | Address | | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | | ETH Main Net | `0x791CA4e3B1DDf69bB7635684E1FB50F0Bc0fc917`([Link](https://etherscan.io/address/0x791ca4e3b1ddf69bb7635684e1fb50f0bc0fc917)) | | ETH Ropsten Test Net | `0xD1bb0bb882Eb112b82D625c4b2c3BF943CC2bF67` ([Link](https://ropsten.etherscan.io/address/0xD1bb0bb882Eb112b82D625c4b2c3BF943CC2bF67)) | ### convertSingleAssetToLiquidity ``` function convertSingleAssetToLiquidity(address tokenA, address requireToken, uint amount, address to, uint minOut) external ; ``` The `convertSingleAssetToLiquidity`function converts one of the assets that a liquidity pool contains into a LP token. It does so by first converting the exact amount of one token required for an equal amount of the other asset that makes up the pool. Next, the two equal values of tokens are added to the liquidity pool. And lastly, the LP tokens are sent to the address provided. | Parameter | Type | Description | | -------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *tokenA* | address | The contract address of the provided token to be converted into the LP token. | | *requireToken* | address | The contract address of the other token in the liquidity pool. In other words, the asset that half of *tokenA* will be converted to that will be added to the liquidity pool. | | *amount* | uint | The amount of *tokenA* to be sent to the liquidity pool. | | *to* | address | The recipient of the LP tokens. | | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### convertSingleAssetToLiquidityEth ``` function convertSingleAssetToLiquidityEth(address requireToken, address to, uint minOut) payable external ; ``` The `convertSingleAssetToLiquidityETH`function converts ETH into a LP token. It does so by first converting the provided ETH into equal amounts of the two tokens that make up the liquidity pool. Next, the two equal values of tokens are added to the liquidity pool. And lastly, the LP tokens are sent to the address provided. The ETH value is sent as a msg.value parameter. One of the two assets can be WETH. #### Parameter Breakdown | Parameter | Type | Description | | ------------------------------------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | |amountIn
(msg.value)
The pathway to change depositToken into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change the depositToken into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### convertSingleAssetToOtherLiquidityETH ``` function convertSingleAssetToOtherLiquidityETH( address requireTokenA,address requireTokenB , address to, address[] calldata path1, address[] calldata path2,uint minOut) payable external ; ``` The `convertSingleAssetToOtherLiquidityETH`function converts ETH to an uTrade V2 LP token made up of two different tokens. In other words, ETH will be converted to the two tokens that make up a liquidity pair, and then the two tokens are added to the liquidity pool. | Parameter | Type | Description | | ------------------------------------------------ | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |amountIn
(msg.value)
The pathway to change ETH into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address must be WETH's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As ETH must be converted to WETH, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change ETH into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address in the array must be WETH's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As ETH must be converted to WETH, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsSingleAsset ``` function withdrawSupplyAsSingleAsset( address receiveToken , address liquidityToken ,address tokenA,address tokenB, address payable to, uint amount, bool toReceiveWNative,uint minOut) external ; ``` The `withdrawSupplyAsSingleAsset` function withdraws a user's liquidity from a pool, and converts it to one of the two tokens that makes up the liquidity pool. In other words, it redeems an LP token for one of the two assets that make up an LP token. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native ETH. If true, the *receiveToken* address should be WETH, as it will unwrap WETH and send ETH. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsOtherSingleAsset ``` function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; ``` The `withdrawSupplyAsOtherSingleAsset`function withdraws a user's liquidity from a pool, and converts it to any other asset that is available on uTrade V2. In other words, it redeems an LP token for ETH or any ERC-20 token available. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *path1* | address |The pathway to change tokenA into the desired asset, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenA to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 must be the same as the last token contract address in path2.
| | *path2* | address |The pathway to change tokenB into the desired asset, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenB to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 must be the same as the last token contract address in path1.
| | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native ETH. If true, the *receiveToken* address should be WETH, as it will unwrap WETH and send ETH. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ## Interface Code ``` interface IUnifiSingleLiquidity { function convertSingleAssetToLiquidity(address tokenA, address requireToken, uint amount, address to, uint minOut) external ; function convertSingleAssetToLiquidityEth(address requireToken, address to, uint minOut) payable external ; function convertSingleAssetToOtherLiquidity(address depositToken, address requireTokenA, address requireTokenB, uint amount, address to, address[] calldata path1, address[] calldata path2, uint minOut) external ; function convertSingleAssetToOtherLiquidityETH(address requireTokenA, address requireTokenB, address to, address[] calldata path1, address[] calldata path2, uint minOut) payable external ; function withdrawSupplyAsSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, bool toReceiveWNative, uint minOut) external ; function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; } ``` # UnifiController.sol The Unifi Controller is a work in progress with minor tweaks here and there. Full documentation will be available once it is optimized! **Primary Uses -** The Unifi Controller is responsible for the setting the variables of UP minting on individual pairs as well as updating the redeem value of UP tokens globally. ## uTrade V2 Controller Code / Interfaces | | | | ------------------------------------------- | --------- | | uTrade V2 Controller (Solidity) | Link Here | | uTrade V2 Controller Interface as JSON | Link Here | | uTrade V2 Controller as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 Controller Contract Addresses | Network | Address | | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | | ETH Main Net | `0xCE17B79C9Ccf709528F120f66Fd3498B33D4F72F` ([Link](https://etherscan.io/address/0xCE17B79C9Ccf709528F120f66Fd3498B33D4F72F)) | | ETH Ropsten Test Net | `0x4F916649463F4A74c536F3B6C599f66BBB94e4fc` ([Link](https://ropsten.etherscan.io/address/0x4F916649463F4A74c536F3B6C599f66BBB94e4fc)) | ## Events ### SwapFeesUPminted ``` event SwapFeesUpminted(address indexed pool, uint amountUPMinted, address defaultPoolAddress, uint platforUPFees); ``` The `SwapFeeUpminted` event is emitted whenever UP is minted. In the majority of cases, this will occur any time a trade occurs. #### Parameter Breakdown | Parameter | Type | Description | | -------------------- | ------- | ----------------------------------------------------------------------------------------------- | | *pool* | address | The liquidity pool where the UP was minted. | | *amountUPMinted* | uint | The amount of UP minted during this event. | | *defaultPoolAddress* | address | The pool representing the 'Super Pair' reward for UNIFI holders. | | *platforUPFees* | uint | The amount of UP collected by the platform for increasing the redeem value and for Super Pairs. | ### UpdatePoolRewards ``` event UpdatePoolRewards(address indexed pool, uint rewards); ``` The `UpdatePoolRewards` event is emitted when the amount of UP claimable by the liquidity providers in the liquidity pool is updated. This event occurs when a trade occurs and results in UP being minted for liquidity providers, or a liquidity provider performs a claim UP transaction. #### Parameter Breakdown | Parameter | Type | Description | | --------- | ------- | -------------------------------------------------------------------------------- | | *pool* | address | The liquidity pool where the UP was minted. | | *rewards* | uint | The amount of UP available to be claimed by all liquidity providers in the pool. | ## Read-Only Functions #### feeSetter ``` function feeSetter() external view returns (address); ``` The `feeSetter` function returns the address of uTrade V2's Smart Contract which sets the fees for trading. ### WBNB ``` function WETH() external view returns (address); ``` The `WETH` function will return the address of WETH on Ethereum. As this does not change, it will always return `0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2`. ### UNIFIUPVault ``` function UNIFIUPVault() external view returns (address); ``` The `UNIFIUPVault` function returns the address of the UPEth vault. This vault contains the ETH that is redeemable for UP. ### nativeFeeTo ``` function nativeFeeTo() external view returns (address); ``` The `nativeFeeTo` function returns the address where, in the case of Unifi Protocol collecting native token fees, the fees would be sent to. # UnifiERC20.sol **Primary Uses -** UnifiERC20.sol essentially ports the properties of ERC-20 tokens on to Unifi LP Tokens, or uTokens. An example of this in practice would be the 'approve' transaction. ## uTrade V2 UnifiERC20 Code / Interfaces | | | | ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 UnifiERC20 (Solidity) | [Etherscan Verified Pair (UNIFI / ETH)](https://etherscan.io/address/0x96351b805fb389b761c1318b43a7dc0c679bed5e#code#F2#L1) | | uTrade V2 UnifiERC20 Interface as JSON | Link Here | | uTrade V2 UnifiERC20 as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 UnifiERC20 Contract Addresses Each uTrade V2 Liquidity Pool uses the uTrade V2 ERC20 Interface in the contract. An example would be `0x96351b805FB389B761c1318B43a7dC0C679BEd5E` ([Link](https://etherscan.io/address/0x96351b805fb389b761c1318b43a7dc0c679bed5e)) for the UNIFI / ETH pair. ## Events ### Approval ``` event Approval(address indexed owner, address indexed spender, uint value); ``` The `Approval` event is emitted anytime an `approve` or `permit` function is called. ### Transfer ``` event Transfer(address indexed from, address indexed to, uint value); ``` The `Transfer` event is emitted anytime a transfer of LP tokens occurs, by the `transfer`, `transferFrom`, `mint`, or `burn` functions. ## Read-Only Functions ### name ``` function name() external pure returns (string memory); ``` The `name` function will return "Unifi LPs" for all liquidity pool contracts. ### symbol ``` function symbol() external pure returns (string memory); ``` The `symbol` function will return "Unifi-LP" for all liquidity pool contracts. ### decimals ``` function decimals() external pure returns (uint8); ``` The `decimals` function returns "18" as a uint8 value, which is the precision for each uToken on uTrade V2. ### totalSupply ``` function totalSupply() external view returns (uint); ``` The `totalSupply` function returns the total amount uTokens for a pair. ### balanceOf ``` function balanceOf(address owner) external view returns (uint); ``` The `balanceOf` function returns the balance of uTokens for the provided address. ### allowance ``` function allowance(address owner, address spender) external view returns (uint); ``` The `allowance` function returns the amount of tokens an address is approved to transfer when using the `transferFrom` function. ### DOMAIN\_SEPARATOR ``` function DOMAIN_SEPARATOR() external view returns (bytes32); ``` The `DOMAIN_SEPARATOR` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in `permit` function. ### PERMIT\_TYPEHASH ``` function PERMIT_TYPEHASH() external view returns (bytes32); ``` The `PERMIT_TYPEHASH` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in the `permit` function. ### nonces ``` function nonces(address owner) external view returns (uint); ``` The `nonces` function is used in the permit function. It returns the current nonce of the *address* provided. ## State-Changing Functions ### approve ``` function approve(address spender, uint value) external returns (bool); ``` The `approve` function sets a *value* for the amount of LP tokens the *address* provided is allowed to transfer. Returns a boolean value and emits the `Approval` event. ### transfer ``` function transfer(address to, uint value) external returns (bool); ``` The `transfer` function lets an address send uTokens from one address to another, and returns a boolean value and emits a `Transfer` event. ### transferFrom ``` function transferFrom(address from, address to, uint value) external returns (bool); ``` The `transferFrom` function sends uTokens from one address to another. This requires the sending address to have approval to send uTokens. Returns a boolean value and emits a `Transfer`event. ### permit ``` function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; ``` The permit function allows a sender to use a signature in lieu of an approval transaction, and sets the allowance for an address to send. #### Function Parameter Breakdown | Parameter | Type | Description | | ---------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | *owner* | address | The owner of the address. | | *spender* | address | The spender of the uTokens. | | *value* | uint | The amount of uTokens to be transferred. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | | *v* | uint8 | The v value of the permit. This is one of the three values that makes up the approval signature. | | *r* | bytes32 | The r value of the permit. This is one of the three values that makes up the approval signature. | | *s* | bytes32 | The s value of the permit. This is one of the three values that makes up the approval signature. | ## Interface Code ``` interface IUnifiERC20 { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; } ``` # UnifiFactory.sol **Primary Uses** - The uTrade V2 Factory contract creates an LP token for any pairs listed on uTrade V2, and indexes them for easy retrieval. In addition, it can return the address of the LP token based on a call of the addresses of the two tokens that make up the liquidity pool. ## uTrade V2 Factory Code / Interfaces | | | | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Factory (Solidity) | Link Here | | uTrade V2 Factory Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiFactory.json) | | uTrade V2 Factory Interface as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiFactory.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Factory Contract Addresses | Network | Address | | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | | ETH Main Net | `0x08e7974CacF66C5a92a37c221A15D3c30C7d97e0`([Link](https://etherscan.io/address/0x08e7974CacF66C5a92a37c221A15D3c30C7d97e0)) | | ETH Ropsten Test Net | `0x4F916649463F4A74c536F3B6C599f66BBB94e4fc` ([Link](https://ropsten.etherscan.io/address/0x4F916649463F4A74c536F3B6C599f66BBB94e4fc)) | ## Events ### PairCreated ``` event PairCreated(address indexed token0, address indexed token1, address pair, uint); ``` Anytime a pair is created on uTrade V2 using the `createPair` function, a `PairCreated` event is emitted. Contracts can be deployed to listen for new pairs on the uTrade V2 ETH Factory address. * *token0* is the token address of the first asset in the token pair. * *token1* is the token address of the second asset in the token pair. * *pair* is the address of the newly created uTrade V2 liquidity pool. * *uint* refers to the index of this uTrade V2 Factory*.* For example, the first liquidity pool created on uTrade V2 is 1, the second liquidity pool is 2, and so on. This number can used with the `allPairs(uint)` to return the address. The current number, and therefore the total number of LP pools on uTrade V2 ETH, can be accessed using the `allPairsLength` function. ## Read-Only Functions ### getPair ``` function getPair(address tokenA, address tokenB) external view returns (address pair); ``` A call to the `getPair` function returns the address of the pair for *tokenA* and *tokenB*. * If the pair does not exist, the call will return *address(0)*. * The order of the tokens is irrelevant in this call. For example, a call for ETH, UNIFI will return the same pair address as UNIFI, ETH. ### allPairs ``` function allPairs(uint) external view returns (address pair); ``` A call to the `allPairs` function returns the address of a pair based on the indexed *uint* value assigned upon creation of the LP. * For example, `allPairs(0)` will return the first pair created on uTrade V2 ETH. * If the index number is too high, as in, there aren't enough pairs created yet, the function will return *address(0)*. ### allPairsLength ``` function allPairsLength() external view returns (uint); ``` A call to the `allPairsLength` function returns the current number of pairs. * For example, if there are 201 total liquidity pool pairs on uTrade V2 ETH, this call will return *200* as an uint value. ### feeTo ``` function feeTo() external view returns (address); ``` A call to the `feeTo` function returns the percentage of trading fees that Unifi Protocol receives. * Due to the nature of UP Token economics, this is set to zero, but is preserved for flexibility in the future. ### feeToSetter ``` function feeToSetter() external view returns (address); ``` A call to the `feeToSetter` function returns the address to which the `feeTo` would send trading fees, if trading fees were collected. ## State-Changing Functions ### createPair ``` function createPair(address tokenA, address tokenB) external returns (address pair); ``` Creates a liquidity pool pair for *tokenA* and *tokenB* if one does not currently exist. After the function is confirmed on chain, a `PairCreated` event is emitted. ## Interface Code ``` interface UnifiFactory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function createPair(address tokenA, address tokenB) external returns (address pair); } ``` ### ### # UnifiPair.sol **Primary Uses -** UnifiPair.sol is responsible for many of the functionalities of liquidity pool tokens and UP tokens. First, it is responsible for the issuing and burning of Liquidity Pool Tokens (uTokens). In addition, it allows for direct reads of the reserves and ratio of the liquidity pool, as well as swaps. Lastly, it is where UP claims are processed. ## uTrade V2 Pair Code / Interfaces | | | | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Pair (Solidity) | [Etherscan Verified Pair (UNIFI / ETH) ](https://etherscan.io/address/0x96351b805fb389b761c1318b43a7dc0c679bed5e#code#F3#L1) | | uTrade V2 Pair Interface as JSON | Link Here | | uTrade V2 Pair as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 Pair Contract Addresses Each uTrade V2 Liquidity Pool uses the uTrade V2 ERC20 Interface in the contract. An example would be `0x96351b805FB389B761c1318B43a7dC0C679BEd5E` ([Link](https://etherscan.io/address/0x96351b805fb389b761c1318b43a7dc0c679bed5e)) for the UNIFI / ETH pair on Ethereum Main Net. ## Events ### Mint ``` event Mint(address indexed sender, uint amount0, uint amount1); ``` The `Mint` event is emitted any time liquidity tokens are created via the `mint` function. In other words, when a user adds liquidity to a pair, then they will receive LP tokens, therefore the `Mint` event will be emitted. ### Burn ``` event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); ``` The `Burn` event is emitted any time liquidity tokens are burned via the `burn` function. In other words, when a user removes liquidity from a pair, their LP tokens will be burned, therefore the `Burn` event will be emitted. ### Swap ``` event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); ``` The `Swap` event is emitted any time the `swap` function is used. Under the hood, all trades on uTrade V2 are swaps. Therefore, any time somebody trades on the pair, the uTrade contract for that pair will emit a `Swap` event. ### Sync ``` event Sync(uint112 reserve0, uint112 reserve1); ``` The `Sync` event is emitted anytime a function occurs that may change the reserves of a token pair. In other words, anytime the amount of the two tokens within a liquidity pool may change. Therefore, whenever a`mint`, `burn`, `swap`, or `sync` function is called, the `Sync` event will be emitted. ## Read-Only Functions ### MINIMUM\_LIQUIDITY ``` function MINIMUM_LIQUIDITY() external pure returns (uint); ``` The `MINIMUM_LIQUIDITY`function will always return 1000. The function itself refers to the burning of initial LP tokens that occurs once when a pool is created. This burn of a tiny amount allows for cleaner LP token numbers therefore avoiding LP tokens being represented as very small decimals value. This allows the tick size to be more precise and prevents rounding errors. ### factory ``` function factory() external view returns (address); ``` The `factory` function will return the current factory address for uTrade V2. ### WBNB ``` function WETH() external view returns (address); ``` The `WETH`function will return the address of WETH on Ethereum. As this does not change, it will always return `0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2`. ### token0 ``` function token0() external view returns (address); ``` The `token0` function will return the contract address of the first token that makes up the liquidity pair. In other words, if the liquidity pool is made up of USDT / USDC, it will return the contract address of USDT. ### token1 ``` function token1() external view returns (address); ``` The `token1` function will return the contract address of the first token that makes up the liquidity pair. In other words, if the liquidity pool is made up of USDT / USDC, it will return the contract address of USDC. ### getReserves ``` function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); ``` The `getReserves` function returns the reserves of the two tokens that make up the liquidity pool as *reserve0* and *reserve1*. These two values can be helpful in determining the current price of each asset. The function also returns a timestamp with the block number. ### price0CumulativeLast ``` function price0CumulativeLast() external view returns (uint); ``` The `price0CumulativeLast` function is for Oracle usage on uTrade V2. The value of *token0* is captured at the end of each block, and can be called using this function to feed into an Oracle to determine a more time-weighted 'average' price. ### price1CumulativeLast ``` function price1CumulativeLast() external view returns (uint); ``` The `price1CumulativeLast` function is for Oracle usage on uTrade V2. The value of *token1* is captured at the end of each block, and can be called using this function to feed into an Oracle to determine a more time-weighted 'average' price. ### kLast ``` function kLast() external view returns (uint); ``` The `kLast` function returns the value of *reserve0* \* *reserve1*, after any event that may have triggered a change in the liquidity. For example, the execution of a *swap* function or a *mint* function. ## State-Changing Functions ### mint ``` function mint(address to) external returns (uint liquidity); ``` The `mint` function creates the LP tokens that represent a user's tokens in a liquidity pool. For example, if a user provides 1 ETH and 2000 USDT liquidity to a pool, the Unifi Pair Smart Contract will mint an amount of uUSDT tokens. Will emit the `Mint`, `Sync`, and `Transfer` events. ### burn ``` function burn(address to) external returns (uint amount0, uint amount1); ``` The `burn` function destroys the LP tokens that represent a user's token in a liquidity pool. For example, if a user removes 1 ETH and 2000 USDT liquidity to a pool, the Unifi Pair Smart Contract will burn an amount of uUSDT tokens. Will emit the `Burn`, `Sync`, and `Transfer` events. ### claimUP ``` function claimUP(address to) external lock returns(uint) { ``` The `claimUP` function claims any UP earned from providing liquidity if any exists, and sends the UP to the address provided. ### swap ``` function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; ``` The `swap` function exchanges one token for another. Under the hood, all trades on uTrade V2 use this function. The *calldata* must be 0 during a normal swap, but must contain data if executing a flash loan. Emits the `Swap` and `Sync` events. ### skim ``` function skim(address to) external; ``` The `skim` function operates as a safeguard if the amount of tokens causes a data error due to too large of a number in the reserves pools. In this unusual circumstance, this will trigger failures in trades. The `skim` function can be called to return the overflowed tokens to the caller. ### sync ``` function sync() external; ``` The `sync` function operates as a safeguard in certain events where the token balance changes outside of normal trading. An example would be an algorithmic stablecoin re-balancing, therefore lowering or raising the amount of the algorithmic stablecoin in the pool. The `sync` function may be called to reset the price ratio to the new reserves. Emits the `Sync`event. ## Interface Code ``` interface IUnifiPair { event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } ``` # UnifiRouter.sol **Primary Uses** - The uTrade V2 Router is the 'brain' of uTrade. The router finds the optimal path for exchanging one token for another. Whenever a trade is made, your wallet sends funds to the router address. The router will then carry out as many transactions as necessary to acquire the desired token. The router also handles adding liquidity to liquidity pools, and sending the corresponding LP tokens to liquidity providers. ## uTrade V2 Router Code / Interfaces | | | | ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Router (Solidity) | [Etherscan Verified](https://etherscan.io/address/0x79F12D68631eC6396aAB3CdF31F07C90D0023c9A#code) | | uTrade V2 Router Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiRouter.json) | | uTrade V2 Router Interface as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiRouter.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Router Contract Addresses | Network | Address | | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | | ETH Main Net | `0x79F12D68631eC6396aAB3CdF31F07C90D0023c9A`([Link](https://etherscan.io/address/0x79F12D68631eC6396aAB3CdF31F07C90D0023c9A)) | | ETH Ropsten Test Net | `0x2521aaB15347C4C0D7658B5e18e31955Cb496d3B` ([Link](https://ropsten.etherscan.io/address/0x2521aaB15347C4C0D7658B5e18e31955Cb496d3B)) | ## Read-Only Functions ### factory ``` function factory() external pure returns (address); ``` A call to the `factory` function returns the address of the current Factory used by uTrade v2. The current factory address for uTrade V2 on Ethereum is `0x08e7974CacF66C5a92a37c221A15D3c30C7d97e0`. ### WETH ``` function WETH() external pure returns (address); ``` A call to the `WETH` function returns the address of Wrapped ETH (WETH) on Ethereum. As this address does not change, it will always return `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2`. ### quote ``` function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); ``` A call to the `quote` function returns the amount of *tokenB* that will be received for an amount of *tokenA*. This can be used to calculate the exchange rate between two tokens without factoring in slippage or fees. By entering the amount of *tokenA,* the total amount of reserves of *tokenA* as *reserveA,* and the total amount of reserves of *tokenB* as *reserveB*, the call will return the equivalent amount of *tokenB*. ### getAmountOut ``` function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); ``` A call to the `getAmountOut`function with the amount of the token being sent will return the maximum amount of a token to be received, accounting for fees and the total amount of reserves. ### getAmountIn ``` function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); ``` A call to the `getAmountIn` function with the amount of the token you wish to receive will return the minimum amount required of the token you wish to send, accounting for fees and the total amount of reserves. ### getAmountsOut ``` function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); ``` A call to the `getAmountsOut` function with the amount of the token being sent will return the maximum amount to be received of multiple different tokens. By entering multiple LP addresses in the *address* array, the function will return the maximum amount of each token that will be received. A call to this function uses the `getReserves` function from [UnifiPair.sol](https://docs.unifiprotocol.com/utrade-v2/ethereum/unifipair.sol) to determine the reserves of the liquidity pool. Then, it calls the `getAmountOut` function to determine the amount of each token in the array that will be received for the *amountIn* value of a token. ### getAmountsIn ``` function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); ``` A call to the `getAmountsIn` function with the desired amount of the token to be received will return the minimum amount required to be sent of multiple tokens. By entering multiple LP addresses in the *address* array, the function will return the minimum amount of each token that will need to be sent to receive the desired amount of a token. A call to this function uses the `getReserves` function from [UnifiPair.sol](https://docs.unifiprotocol.com/utrade-v2/ethereum/unifipair.sol) to determine the reserves of the liquidity pool. Then, it calls the `getAmountIn` function to determine the amount of each token in the array that will need to be sent for the *amountOut* value of a token. ## State-Changing Functions - Liquidity ### addLiquidity ``` function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); ``` The `addLiquidity` function adds the two tokens that make up the liquidity pool - *tokenA* and *tokenB* - at the proper ratio based on the reserves of the pool. For example, if the pool contains 3000 USDT / 2 ETH, a user's liquidity will be added at the ratio of 1500 USDT to 1 ETH, provided there is no price movements in the pair between when the user broadcasts the transaction to when it is mined. In the event of a price movement, the *amountADesired*, *amountBDesired*, *amountAMin*, and *amountBMin* act as a security measure against an adverse price movement. After the liquidity is added, the function sends the corresponding LP tokens to the sender. In the case of a pool not existing for the two assets, one will be created using [UnifiFactory.sol](https://docs.unifiprotocol.com/utrade-v2/ethereum/unififactory.sol) at the ratio of the assets supplied. #### Function Parameters Breakdown | Parameter | Type | Description | | ---------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *tokenA* | address | Token address of the first asset in the token pair. | | *tokenB* | address | Token address of the second asset in the token pair. | | *amountADesired* | uint | The amount of *tokenA* to be added to liquidity if the value of *tokenA* goes down in comparison to *tokenB*. | | *amountBDesired* | uint | The amount of *tokenB* to be added to liquidity if the value of *tokenB* goes down in comparison to *tokenA.* | | *amountAMin* | uint |Sets the minimum amount of tokenA that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of tokenB that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of the supplied token that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of ETH that can added to the pool before the transaction reverts. This acts as a safeguard.
The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactTokens ``` function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); ``` The `swapTokensForExactTokens` function sends the minimum amount of tokens for the exact amount of another token. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the desired tokens to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactETHForTokens ``` function swapExactETHForTokens( uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapExactETHForTokens` function sends an exact amount of ETH for a desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of ETH to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping ETH to WETH, the first address must be WETH.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of ETH sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactETH ``` function swapTokensForExactETH( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapTokensForExactETH` function sends an amount of tokens for an exact amount of ETH. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the ETH to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapExactTokensForETH ``` function swapExactTokensForETH( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapExactTokensForETH` function sends an exact amount of tokens for ETH. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into ETH. | | *amountOutMin* | uint | Sets the minimum amount of the ETH to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Parameter Return Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapETHForExactTokens ``` function swapETHForExactTokens( uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapETHForExactTokens` function swaps an exact amount of ETH for an amount of the desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of ETH to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping ETH to WETH, the first address must be WETH.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of ETH sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactTokensForTokensSupportingFeeOnTransferTokens ``` function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The `swapExactTokensForTokensSupportingFeeOnTransferTokens` function is similar to `swapExactTokensForTokens` as it swaps one ERC-20 token for another ERC-20 token. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Name | Type | | | -------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into another token. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactETHForTokensSupportingFeeOnTransferTokens ``` function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; ``` The `swapExactETHForTokensSupportingFeeOnTransferTokens`function is similar to `swapExactETHForTokens` function as it swaps an exact amount of ETH for ERC-20 tokens. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the exact amount of ETH to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping ETH to WETH, the first address must be WETH.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactTokensForETHSupportingFeeOnTransferTokens ``` function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The function `swapExactTokensForETHSupportingFeeOnTransferTokens`is similar to the `swapExactTokensForETH`function, as it swaps an exact amount of ERC-20 tokens for ETH. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into ETH. | | *amountOutMin* | uint | Sets the minimum amount of the ETH to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ## Interface Code ``` interface IUnifiRouter01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUnifiRouter02 is IUnifiRouter01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } ``` # Harmony Here you will find in-depth detail of the contracts that make up uTrade V2 on Harmony. Each contract includes JSONs as well as Typescript files for integration into your project. Every effort is made to open-source all aspects of uTrade V2, but some do remain private. When a contract is available, you will find a link to the Github source code. # singleLiquidityWrapper.sol **Primary Uses -** Unique to uTrade, the Single Liquidity Wrapper allows ONE or any HRC-20 token to converted into a LP pool. For example, USDT can be added using the wrapper to supply liquidity for a BUSD / WONE pair. The wrapper allows LP tokens to exit in a similar fashion. The functionality from this wrapper simplifies applications such as compounding or fee-on-transfer additions to liquidity pools. ## uTrade V2 Single Liquidity Wrapper Code / Interfaces | | | | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Single Liquidity Wrapper (Solidity) | Link Here | | uTrade V2 Single Liquidity Wrapper Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiSingleLiquidityWrapper.json) | | uTrade V2 Single Liquidity Wrapper as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiSingleLiquidityWrapper.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Single Liquidity Wrapper Contract Addresses | Network | Address | | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Harmony Main Net |0x: 0xa529de1949ddb797de0d7f2b3fcf8b17a94af51d
One:one1555aux2fmkme0hsd0u4nlnutz7554agasnuyuf (Link)
amountIn
(msg.value)
The pathway to change depositToken into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change the depositToken into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### convertSingleAssetToOtherLiquidityETH ``` function convertSingleAssetToOtherLiquidityETH(address requireTokenA, address requireTokenB, address to, address[] calldata path1, address[] calldata path2, uint minOut) payable external ; ``` The `convertSingleAssetToOtherLiquidityETH`function converts ONE to an uTrade V2 LP token made up of two different tokens. In other words, ONE will be converted to the two tokens that make up a liquidity pair, and then the two tokens are added to the liquidity pool. | Parameter | Type | Description | | ------------------------------------------------ | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |amountIn
(msg.value)
The pathway to change ONE into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address must be WONE's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As ONE must be converted to WONE multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change ONE into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address in the array must be WONE's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As ONE must be converted to WONE, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsSingleAsset ``` function withdrawSupplyAsSingleAsset( address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, bool toReceiveWNative, uint minOut) external ; ``` The `withdrawSupplyAsSingleAsset` function withdraws a user's liquidity from a pool, and converts it to one of the two tokens that makes up the liquidity pool. In other words, it redeems an LP token for one of the two assets that make up an LP token. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native ONE. If true, the *receiveToken* address should be WONE, as it will unwrap WONE and send ONE. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsOtherSingleAsset ``` function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; ``` The `withdrawSupplyAsOtherSingleAsset`function withdraws a user's liquidity from a pool, and converts it to any other asset that is available on uTrade V2. In other words, it redeems an LP token for ONE or any HRC-20 token available. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *path1* | address |The pathway to change tokenA into the desired asset, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenA to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 must be the same as the last token contract address in path2.
| | *path2* | address |The pathway to change tokenB into the desired asset, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenB to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 must be the same as the last token contract address in path1.
| | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native ONE. If true, the *receiveToken* address should be WONE, as it will unwrap WONE and send ONE. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ## Interface Code ``` interface IUnifiSingleLiquidity { function convertSingleAssetToLiquidity(address tokenA, address requireToken, uint amount, address to, uint minOut) external ; function convertSingleAssetToLiquidityEth(address requireToken, address to, uint minOut) payable external ; function convertSingleAssetToOtherLiquidity(address depositToken, address requireTokenA, address requireTokenB, uint amount, address to, address[] calldata path1, address[] calldata path2, uint minOut) external ; function convertSingleAssetToOtherLiquidityETH(address requireTokenA, address requireTokenB, address to, address[] calldata path1, address[] calldata path2, uint minOut) payable external ; function withdrawSupplyAsSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, bool toReceiveWNative, uint minOut) external ; function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; } ``` # UnifiERC20.sol **Primary Uses -** UnifiERC20.sol essentially ports the properties of HRC-20 tokens on to Unifi LP Tokens, or uTokens. An example of this in practice would be the 'approve' transaction. ## uTrade V2 UnifiERC20 Code / Interfaces | | | | ------------------------------------------- | --------- | | uTrade V2 UnifiERC20 (Solidity) | Link Here | | uTrade V2 UnifiERC20 Interface as JSON | Link Here | | uTrade V2 UnifiERC20 as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 UnifiERC20 Contract Addresses Each uTrade V2 Liquidity Pool uses the uTrade V2 ERC20 Interface in the contract. An example would be `one1suatku23s9ll76a683lmzffqn8ppp29sdtn6xj` or `0x873abb7151817fff6bba3c7fb1252099c210a8b0` ([Link](https://explorer.harmony.one/address/0x873aBB7151817fFf6bBA3C7Fb1252099C210a8b0)) for the UP / WONE pair. ## Events ### Approval ``` event Approval(address indexed owner, address indexed spender, uint value); ``` The `Approval` event is emitted anytime an `approve` or `permit` function is called. ### Transfer ``` event Transfer(address indexed from, address indexed to, uint value); ``` The `Transfer` event is emitted anytime a transfer of LP tokens occurs, by the `transfer`, `transferFrom`, `mint`, or `burn` functions. ## Read-Only Functions ### name ``` function name() external pure returns (string memory); ``` The `name` function will return "Unifi LPs" for all liquidity pool contracts. ### symbol ``` function symbol() external pure returns (string memory); ``` The `symbol` function will return "Unifi-LP" for all liquidity pool contracts. ### decimals ``` function decimals() external pure returns (uint8); ``` The `decimals` function returns "18" as a uint8 value, which is the precision for each uToken on uTrade V2. ### totalSupply ``` function totalSupply() external view returns (uint); ``` The `totalSupply` function returns the total amount uTokens for a pair. ### balanceOf ``` function balanceOf(address owner) external view returns (uint); ``` The `balanceOf` function returns the balance of uTokens for the provided address. ### allowance ``` function allowance(address owner, address spender) external view returns (uint); ``` The `allowance` function returns the amount of tokens an address is approved to transfer when using the `transferFrom` function. ### DOMAIN\_SEPARATOR ``` function DOMAIN_SEPARATOR() external view returns (bytes32); ``` The `DOMAIN_SEPARATOR` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in `permit` function. ### PERMIT\_TYPEHASH ``` function PERMIT_TYPEHASH() external view returns (bytes32); ``` The `PERMIT_TYPEHASH` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in the `permit` function. ### nonces ``` function nonces(address owner) external view returns (uint); ``` The `nonces` function is used in the permit function. It returns the current nonce of the *address* provided. ## State-Changing Functions ### approve ``` function approve(address spender, uint value) external returns (bool); ``` The `approve` function sets a *value* for the amount of LP tokens the *address* provided is allowed to transfer. Returns a boolean value and emits the `Approval` event. ### transfer ``` function transfer(address to, uint value) external returns (bool); ``` The `transfer` function lets an address send uTokens from one address to another, and returns a boolean value and emits a `Transfer` event. ### transferFrom ``` function transferFrom(address from, address to, uint value) external returns (bool); ``` The `transferFrom` function sends uTokens from one address to another. This requires the sending address to have approval to send uTokens. Returns a boolean value and emits a `Transfer`event. ### permit ``` function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; ``` The permit function allows a sender to use a signature in lieu of an approval transaction, and sets the allowance for an address to send. #### Function Parameter Breakdown | Parameter | Type | Description | | ---------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | *owner* | address | The owner of the address. | | *spender* | address | The spender of the uTokens. | | *value* | uint | The amount of uTokens to be transferred. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | | *v* | uint8 | The v value of the permit. This is one of the three values that makes up the approval signature. | | *r* | bytes32 | The r value of the permit. This is one of the three values that makes up the approval signature. | | *s* | bytes32 | The s value of the permit. This is one of the three values that makes up the approval signature. | ## Interface Code ``` interface IUnifiERC20 { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; } ``` # UnifiFactory.sol **Primary Uses** - The uTrade V2 Factory contract creates an LP token for any pairs listed on uTrade V2, and indexes them for easy retrieval. In addition, it can return the address of the LP token based on a call of the addresses of the two tokens that make up the liquidity pool. ## uTrade V2 Factory Code / Interfaces | | | | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Factory (Solidity) | Link Here | | uTrade V2 Factory Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiFactory.json) | | uTrade V2 Factory Interface as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiFactory.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Factory Contract Addresses | Network | Address | | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Harmony |0x: 0x7aB6ef0cE51a2aDc5B673Bad7218C01AE9B04695
one: one1suatku23s9ll76a683lmzffqn8ppp29sdtn6xj (Link)
0x: 0xbfd48577e368322966cfda94c0a63078ce2f0402
one: 0xbfd48577e368322966cfda94c0a63078ce2f0402 (Link)
Sets the minimum amount of tokenA that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of tokenB that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of the supplied token that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of ONE that can added to the pool before the transaction reverts. This acts as a safeguard.
The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactTokens ``` function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); ``` The `swapTokensForExactTokens` function sends the minimum amount of tokens for the exact amount of another token. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the desired tokens to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactETHForTokens ``` function swapExactETHForTokens( uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapExactETHForTokens` function sends an exact amount of ONE for a desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of ONE to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping ONE to WONE, the first address must be WONE.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of ONE sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactETH ``` function swapTokensForExactETH( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapTokensForExactETH` function sends an amount of tokens for an exact amount of ONE. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the ONE to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapExactTokensForETH ``` function swapExactTokensForETH( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapExactTokensForETH` function sends an exact amount of tokens for ONE. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into ONE. | | *amountOutMin* | uint | Sets the minimum amount of the ONE to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Parameter Return Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapETHForExactTokens ``` function swapETHForExactTokens( uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapETHForExactTokens` function swaps an exact amount of ONE for an amount of the desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of ONE to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping ONE to WONE, the first address must be WONE.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of ONE sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactTokensForTokensSupportingFeeOnTransferTokens ``` function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The `swapExactTokensForTokensSupportingFeeOnTransferTokens` function is similar to `swapExactTokensForTokens` as it swaps one HRC-20 token for another HRC-20 token. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Name | Type | | | -------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into ONE. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactETHForTokensSupportingFeeOnTransferTokens ``` function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; ``` The `swapExactETHForTokensSupportingFeeOnTransferTokens`function is similar to `swapExactETHForTokens` function as it swaps an exact amount of ONE for HRC-20 tokens. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the exact amount of ONE to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping ONE to WONE, the first address must be WONE.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactTokensForETHSupportingFeeOnTransferTokens ``` function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The function `swapExactTokensForETHSupportingFeeOnTransferTokens`is similar to the `swapExactTokensForETH`function, as it swaps an exact amount of HRC-20 tokens for ONE. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into ONE. | | *amountOutMin* | uint | Sets the minimum amount of the ONE to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ## Interface Code ``` interface IUnifiRouter01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUnifiRouter02 is IUnifiRouter01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } ``` # IoTeX Here you will find in-depth detail of the contracts that make up uTrade V2 on IoTeX. Each contract includes JSONs as well as Typescript files for integration into your project. Every effort is made to open-source all aspects of uTrade V2, but some do remain private. When a contract is available, you will find a link to the Github source code. # UnifiERC20.sol **Primary Uses -** UnifiERC20.sol essentially ports the properties of XRC-20 tokens on to Unifi LP Tokens, or uTokens. An example of this in practice would be the 'approve' transaction. ## uTrade V2 UnifiERC20 Code / Interfaces | | | | ------------------------------------------- | --------- | | uTrade V2 UnifiERC20 (Solidity) | Link Here | | uTrade V2 UnifiERC20 Interface as JSON | Link Here | | uTrade V2 UnifiERC20 as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 UnifiERC20 Contract Addresses Each uTrade V2 Liquidity Pool uses the uTrade V2 XRC20 Interface in the contract. An example would be `0xBd99494A8EEa8425F5B83D7608b1b198763a97F8` ([Link](https://iotexscan.io/address/0xBd99494A8EEa8425F5B83D7608b1b198763a97F8)) for the WIOTX / UPIotx pair. ## Events ### Approval ``` event Approval(address indexed owner, address indexed spender, uint value); ``` The `Approval` event is emitted anytime an `approve` or `permit` function is called. ### Transfer ``` event Transfer(address indexed from, address indexed to, uint value); ``` The `Transfer` event is emitted anytime a transfer of LP tokens occurs, by the `transfer`, `transferFrom`, `mint`, or `burn` functions. ## Read-Only Functions ### name ``` function name() external pure returns (string memory); ``` The `name` function will return "Unifi LPs" for all liquidity pool contracts. ### symbol ``` function symbol() external pure returns (string memory); ``` The `symbol` function will return "Unifi-LP" for all liquidity pool contracts. ### decimals ``` function decimals() external pure returns (uint8); ``` The `decimals` function returns "18" as a uint8 value, which is the precision for each uToken on uTrade V2. ### totalSupply ``` function totalSupply() external view returns (uint); ``` The `totalSupply` function returns the total amount uTokens for a pair. ### balanceOf ``` function balanceOf(address owner) external view returns (uint); ``` The `balanceOf` function returns the balance of uTokens for the provided address. ### allowance ``` function allowance(address owner, address spender) external view returns (uint); ``` The `allowance` function returns the amount of tokens an address is approved to transfer when using the `transferFrom` function. ### DOMAIN\_SEPARATOR ``` function DOMAIN_SEPARATOR() external view returns (bytes32); ``` The `DOMAIN_SEPARATOR` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in `permit` function. ### PERMIT\_TYPEHASH ``` function PERMIT_TYPEHASH() external view returns (bytes32); ``` The `PERMIT_TYPEHASH` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in the `permit` function. ### nonces ``` function nonces(address owner) external view returns (uint); ``` The `nonces` function is used in the permit function. It returns the current nonce of the *address* provided. ## State-Changing Functions ### approve ``` function approve(address spender, uint value) external returns (bool); ``` The `approve` function sets a *value* for the amount of LP tokens the *address* provided is allowed to transfer. Returns a boolean value and emits the `Approval` event. ### transfer ``` function transfer(address to, uint value) external returns (bool); ``` The `transfer` function lets an address send uTokens from one address to another, and returns a boolean value and emits a `Transfer` event. ### transferFrom ``` function transferFrom(address from, address to, uint value) external returns (bool); ``` The `transferFrom` function sends uTokens from one address to another. This requires the sending address to have approval to send uTokens. Returns a boolean value and emits a `Transfer`event. ### permit ``` function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; ``` The permit function allows a sender to use a signature in lieu of an approval transaction, and sets the allowance for an address to send. #### Function Parameter Breakdown | Parameter | Type | Description | | ---------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | *owner* | address | The owner of the address. | | *spender* | address | The spender of the uTokens. | | *value* | uint | The amount of uTokens to be transferred. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | | *v* | uint8 | The v value of the permit. This is one of the three values that makes up the approval signature. | | *r* | bytes32 | The r value of the permit. This is one of the three values that makes up the approval signature. | | *s* | bytes32 | The s value of the permit. This is one of the three values that makes up the approval signature. | ## Interface Code ``` interface IUnifiERC20 { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; } ``` # UnifiFactory.sol **Primary Uses** - The uTrade V2 Factory contract creates an LP token for any pairs listed on uTrade V2, and indexes them for easy retrieval. In addition, it can return the address of the LP token based on a call of the addresses of the two tokens that make up the liquidity pool. ## uTrade V2 Factory Code / Interfaces | | | | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Factory (Solidity) | | | uTrade V2 Factory Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiFactory.json) | | uTrade V2 Factory Interface as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiFactory.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Factory Contract Addresses | Network | Address | | -------------- | ------------------------------------------------------------------------------------------------------------------------------ | | IoTeX Main Net | `0x839547067bc885db205F5fA42dcFeEcDFf5A8530` ([Link](https://iotexscan.io/address/0x839547067bc885db205F5fA42dcFeEcDFf5A8530)) | ## Events ### PairCreated ``` event PairCreated(address indexed token0, address indexed token1, address pair, uint); ``` Anytime a pair is created on uTrade V2 using the `createPair` function, a `PairCreated`event is emitted. Contracts can be deployed to listen for new pairs on the uTrade V2 IoTeX Factory address. * *token0* is the token address of the first asset in the token pair. * *token1* is the token address of the second asset in the token pair. * *pair* is the address of the newly created uTrade V2 liquidity pool. * *uint* refers to the index of this uTrade V2 Factory*.* For example, the first liquidity pool created on uTrade V2 is 1, the second liquidity pool is 2, and so on. This number can used with the `allPairs(uint)` to return the address. The current number, and therefore the total number of LP pools on uTrade V2 ETH, can be accessed using the `allPairsLength` function. ## Read-Only Functions ### getPair ``` function getPair(address tokenA, address tokenB) external view returns (address pair); ``` A call to the `getPair` function returns the address of the pair for *tokenA* and *tokenB*. * If the pair does not exist, the call will return *address(0)*. * The order of the tokens is irrelevant in this call. For example, a call for IOTX, UP will return the same pair address as UP, IOTX. ### allPairs ``` function allPairs(uint) external view returns (address pair); ``` A call to the `allPairs` function returns the address of a pair based on the indexed *uint* value assigned upon creation of the LP. * For example, `allPairs(0)` will return the first pair created on uTrade V2 IoTeX. * If the index number is too high, as in, there aren't enough pairs created yet, the function will return *address(0)*. ### allPairsLength ``` function allPairsLength() external view returns (uint); ``` A call to the `allPairsLength` function returns the current number of pairs. * For example, if there are 201 total liquidity pool pairs on uTrade V2 IoTeX, this call will return *200* as an uint value. ### feeTo ``` function feeTo() external view returns (address); ``` A call to the `feeTo` function returns the percentage of trading fees that Unifi Protocol receives. * Due to the nature of UP Token economics, this is set to zero, but is preserved for flexibility in the future. ### feeToSetter ``` function feeToSetter() external view returns (address); ``` A call to the `feeToSetter` function returns the address to which the `feeTo` would send trading fees, if trading fees were collected. ## State-Changing Functions ### createPair ``` function createPair(address tokenA, address tokenB) external returns (address pair); ``` Creates a liquidity pool pair for *tokenA* and *tokenB* if one does not currently exist. After the function is confirmed on chain, a `PairCreated` event is emitted. ## Interface Code ``` interface UnifiFactory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function createPair(address tokenA, address tokenB) external returns (address pair); } ``` ### ### # UnifiRouter.sol **Primary Uses** - The uTrade V2 Router is the 'brain' of uTrade. The router finds the optimal path for exchanging one token for another. Whenever a trade is made, your wallet sends funds to the router address. The router will then carry out as many transactions as necessary to acquire the desired token. The router also handles adding liquidity to liquidity pools, and sending the corresponding LP tokens to liquidity providers. ## uTrade V2 Router Code / Interfaces | | | | ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Router (Solidity) | | | uTrade V2 Router Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiRouter.json) | | uTrade V2 Router Interface as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiRouter.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Router Contract Addresses | Network | Address | | -------------- | ------------------------------------------------------------------------------------------------------------------------------ | | IoTeX Main Net | `0xBd562d5cF2c62Da3143D862aF39eDb6dF59A4679` ([Link](https://iotexscan.io/address/0xBd562d5cF2c62Da3143D862aF39eDb6dF59A4679)) | ## Read-Only Functions ### factory ``` function factory() external pure returns (address); ``` A call to the `factory` function returns the address of the current Factory used by uTrade v2. The current factory address for uTrade V2 on IoTeX is `0x839547067bc885db205F5fA42dcFeEcDFf5A8530`. ### WETH ``` function WETH() external pure returns (address); ``` A call to the `WETH` function returns the address of Wrapped IoTeX (WIOTX) on IoTeX. As this address does not change, it will always return `0xa00744882684c3e4747faefd68d283ea44099d03`. ### quote ``` function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); ``` A call to the `quote` function returns the amount of *tokenB* that will be received for an amount of *tokenA*. This can be used to calculate the exchange rate between two tokens without factoring in slippage or fees. By entering the amount of *tokenA,* the total amount of reserves of *tokenA* as *reserveA,* and the total amount of reserves of *tokenB* as *reserveB*, the call will return the equivalent amount of *tokenB*. ### getAmountOut ``` function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); ``` A call to the `getAmountOut`function with the amount of the token being sent will return the maximum amount of a token to be received, accounting for fees and the total amount of reserves. ### getAmountIn ``` function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); ``` A call to the `getAmountIn` function with the amount of the token you wish to receive will return the minimum amount required of the token you wish to send, accounting for fees and the total amount of reserves. ### getAmountsOut ``` function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); ``` A call to the `getAmountsOut` function with the amount of the token being sent will return the maximum amount to be received of multiple different tokens. By entering multiple LP addresses in the *address* array, the function will return the maximum amount of each token that will be received. A call to this function uses the `getReserves` function from [UnifiPair.sol](https://docs.unifiprotocol.com/utrade-v2/iotex/unifipair.sol) to determine the reserves of the liquidity pool. Then, it calls the `getAmountOut` function to determine the amount of each token in the array that will be received for the *amountIn* value of a token. ### getAmountsIn ``` function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); ``` A call to the `getAmountsIn` function with the desired amount of the token to be received will return the minimum amount required to be sent of multiple tokens. By entering multiple LP addresses in the *address* array, the function will return the minimum amount of each token that will need to be sent to receive the desired amount of a token. A call to this function uses the `getReserves` function from [UnifiPair.sol](https://docs.unifiprotocol.com/utrade-v2/iotex/unifipair.sol) to determine the reserves of the liquidity pool. Then, it calls the `getAmountIn` function to determine the amount of each token in the array that will need to be sent for the *amountOut* value of a token. ## State-Changing Functions - Liquidity ### addLiquidity ``` function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); ``` The `addLiquidity` function adds the two tokens that make up the liquidity pool - *tokenA* and *tokenB* - at the proper ratio based on the reserves of the pool. For example, if the pool contains 3000 USDT / 20000 IOTX, a user's liquidity will be added at the ratio of 0.15 USDT to 1 IOTX, provided there is no price movements in the pair between when the user broadcasts the transaction to when it is mined. In the event of a price movement, the *amountADesired*, *amountBDesired*, *amountAMin*, and *amountBMin* act as a security measure against an adverse price movement. After the liquidity is added, the function sends the corresponding LP tokens to the sender. In the case of a pool not existing for the two assets, one will be created using [UnifiFactory.sol](https://docs.unifiprotocol.com/utrade-v2/iotex/unififactory.sol) at the ratio of the assets supplied. #### Function Parameters Breakdown | Parameter | Type | Description | | ---------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *tokenA* | address | Token address of the first asset in the token pair. | | *tokenB* | address | Token address of the second asset in the token pair. | | *amountADesired* | uint | The amount of *tokenA* to be added to liquidity if the value of *tokenA* goes down in comparison to *tokenB*. | | *amountBDesired* | uint | The amount of *tokenB* to be added to liquidity if the value of *tokenB* goes down in comparison to *tokenA.* | | *amountAMin* | uint |Sets the minimum amount of tokenA that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of tokenB that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of the supplied token that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of IOTX that can added to the pool before the transaction reverts. This acts as a safeguard.
The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactTokens ``` function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); ``` The `swapTokensForExactTokens` function sends the minimum amount of tokens for the exact amount of another token. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the desired tokens to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactETHForTokens ``` function swapExactETHForTokens( uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapExactETHForTokens` function sends an exact amount of IOTX for a desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of IOTX to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping IOTX to WIOTX, the first address must be WETH.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | -------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of IOTX sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactETH ``` function swapTokensForExactETH( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapTokensForExactETH` function sends an amount of tokens for an exact amount of IOTX. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the IOTX to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapExactTokensForETH ``` function swapExactTokensForETH( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapExactTokensForETH` function sends an exact amount of tokens for IOTX. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into IOTX. | | *amountOutMin* | uint | Sets the minimum amount of the IOTX to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Parameter Return Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapETHForExactTokens ``` function swapETHForExactTokens( uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapETHForExactTokens` function swaps an exact amount of IOTX for an amount of the desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of IOTX to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping IOTX to WIOTX, the first address must be WIOTX.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of ETH sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactTokensForTokensSupportingFeeOnTransferTokens ``` function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The `swapExactTokensForTokensSupportingFeeOnTransferTokens` function is similar to `swapExactTokensForTokens` as it swaps one XRC-20 token for another XRC-20 token. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Name | Type | | | -------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into another token. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactETHForTokensSupportingFeeOnTransferTokens ``` function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; ``` The `swapExactETHForTokensSupportingFeeOnTransferTokens`function is similar to `swapExactETHForTokens` function as it swaps an exact amount of IOTX for XRC-20 tokens. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |(amountIn)
msg.value
| uint | Sent as the msg.value, the exact amount of IOTX to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping IOTX to WIOTX, the first address must be WIOTX.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactTokensForETHSupportingFeeOnTransferTokens ``` function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The function `swapExactTokensForETHSupportingFeeOnTransferTokens`is similar to the `swapExactTokensForETH`function, as it swaps an exact amount of XRC-20 tokens for IOTX. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into IOTX. | | *amountOutMin* | uint | Sets the minimum amount of the IOTX to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ## Interface Code ``` interface IUnifiRouter01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUnifiRouter02 is IUnifiRouter01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } ``` # UnifiPair.sol **Primary Uses -** UnifiPair.sol is responsible for many of the functionalities of liquidity pool tokens and UP tokens. First, it is responsible for the issuing and burning of Liquidity Pool Tokens (uTokens). In addition, it allows for direct reads of the reserves and ratio of the liquidity pool, as well as swaps. Lastly, it is where UP claims are processed. ## uTrade V2 Pair Code / Interfaces | | | | ------------------------------------------- | --------- | | uTrade V2 Pair (Solidity) | | | uTrade V2 Pair Interface as JSON | Link Here | | uTrade V2 Pair as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 Pair Contract Addresses Each uTrade V2 Liquidity Pool uses the uTrade V2 XRC20 Interface in the contract. An example would be `0xBd99494A8EEa8425F5B83D7608b1b198763a97F8` ([Link](https://iotexscan.io/address/0xBd99494A8EEa8425F5B83D7608b1b198763a97F8)) for the WIOTX / UPIotx pair on the IoTeX Main Net. ## Events ### Mint ``` event Mint(address indexed sender, uint amount0, uint amount1); ``` The `Mint` event is emitted any time liquidity tokens are created via the `mint` function. In other words, when a user adds liquidity to a pair, then they will receive LP tokens, therefore the `Mint` event will be emitted. ### Burn ``` event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); ``` The `Burn` event is emitted any time liquidity tokens are burned via the `burn` function. In other words, when a user removes liquidity from a pair, their LP tokens will be burned, therefore the `Burn` event will be emitted. ### Swap ``` event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); ``` The `Swap` event is emitted any time the `swap` function is used. Under the hood, all trades on uTrade V2 are swaps. Therefore, any time somebody trades on the pair, the uTrade contract for that pair will emit a `Swap` event. ### Sync ``` event Sync(uint112 reserve0, uint112 reserve1); ``` The `Sync` event is emitted anytime a function occurs that may change the reserves of a token pair. In other words, anytime the amount of the two tokens within a liquidity pool may change. Therefore, whenever a`mint`, `burn`, `swap`, or `sync` function is called, the `Sync` event will be emitted. ## Read-Only Functions ### MINIMUM\_LIQUIDITY ``` function MINIMUM_LIQUIDITY() external pure returns (uint); ``` The `MINIMUM_LIQUIDITY`function will always return 1000. The function itself refers to the burning of initial LP tokens that occurs once when a pool is created. This burn of a tiny amount allows for cleaner LP token numbers therefore avoiding LP tokens being represented as very small decimals value. This allows the tick size to be more precise and prevents rounding errors. ### factory ``` function factory() external view returns (address); ``` The `factory` function will return the current factory address for uTrade V2. ### WBNB ``` function WETH() external view returns (address); ``` The `WETH`function will return the address of WIOTX on IoTeX. As this does not change, it will always return `0xa00744882684c3e4747faefd68d283ea44099d03`. ### token0 ``` function token0() external view returns (address); ``` The `token0` function will return the contract address of the first token that makes up the liquidity pair. In other words, if the liquidity pool is made up of USDT / USDC, it will return the contract address of USDT. ### token1 ``` function token1() external view returns (address); ``` The `token1` function will return the contract address of the first token that makes up the liquidity pair. In other words, if the liquidity pool is made up of USDT / USDC, it will return the contract address of USDC. ### getReserves ``` function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); ``` The `getReserves` function returns the reserves of the two tokens that make up the liquidity pool as *reserve0* and *reserve1*. These two values can be helpful in determining the current price of each asset. The function also returns a timestamp with the block number. ### price0CumulativeLast ``` function price0CumulativeLast() external view returns (uint); ``` The `price0CumulativeLast`function is for Oracle usage on uTrade V2. The value of *token0* is captured at the end of each block, and can be called using this function to feed into an Oracle to determine a more time-weighted 'average' price. ### price1CumulativeLast ``` function price1CumulativeLast() external view returns (uint); ``` The `price1CumulativeLast` function is for Oracle usage on uTrade V2. The value of *token1* is captured at the end of each block, and can be called using this function to feed into an Oracle to determine a more time-weighted 'average' price. ### kLast ``` function kLast() external view returns (uint); ``` The `kLast` function returns the value of *reserve0* \* *reserve1*, after any event that may have triggered a change in the liquidity. For example, the execution of a *swap* function or a *mint* function. ## State-Changing Functions ### mint ``` function mint(address to) external returns (uint liquidity); ``` The `mint` function creates the LP tokens that represent a user's tokens in a liquidity pool. For example, if a user provides 20,000 IOTX and 2000 USDT liquidity to a pool, the Unifi Pair Smart Contract will mint an amount of uUSDT tokens. Will emit the `Mint`, `Sync`, and `Transfer` events. ### burn ``` function burn(address to) external returns (uint amount0, uint amount1); ``` The `burn` function destroys the LP tokens that represent a user's token in a liquidity pool. For example, if a user removes 20,000 IOTX and 2000 USDT liquidity to a pool, the Unifi Pair Smart Contract will burn an amount of uUSDT tokens. Will emit the `Burn`, `Sync`, and `Transfer` events. ### claimUP ``` function claimUP(address to) external lock returns(uint) { ``` The `claimUP` function claims any UP earned from providing liquidity if any exists, and sends the UP to the address provided. ### swap ``` function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; ``` The `swap` function exchanges one token for another. Under the hood, all trades on uTrade V2 use this function. The *calldata* must be 0 during a normal swap, but must contain data if executing a flash loan. Emits the `Swap` and `Sync` events. ### skim ``` function skim(address to) external; ``` The `skim` function operates as a safeguard if the amount of tokens causes a data error due to too large of a number in the reserves pools. In this unusual circumstance, this will trigger failures in trades. The `skim` function can be called to return the overflowed tokens to the caller. ### sync ``` function sync() external; ``` The `sync` function operates as a safeguard in certain events where the token balance changes outside of normal trading. An example would be an algorithmic stablecoin re-balancing, therefore lowering or raising the amount of the algorithmic stablecoin in the pool. The `sync` function may be called to reset the price ratio to the new reserves. Emits the `Sync`event. ## Interface Code ``` interface IUnifiPair { event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } ``` # Polygon Here you will find in-depth detail of the contracts that make up uTrade V2 on Polygon. Each contract includes JSONs as well as Typescript files for integration into your project. Every effort is made to open-source all aspects of uTrade V2, but some do remain private. When a contract is available, you will find a link to the Github source code. # singleLiquidityWrapper.sol **Primary Uses -** Unique to uTrade, the Single Liquidity Wrapper allows MATIC or any ERC-20 token on Matic to be converted into a LP pool. For example, MATIC can be added using the wrapper to supply liquidity for a BUSD / WMATIC pair. The wrapper allows LP tokens to exit in a similar fashion. The functionality from this wrapper simplifies applications such as compounding or fee-on-transfer additions to liquidity pools. ## uTrade V2 Single Liquidity Wrapper Code / Interfaces | | | | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Single Liquidity Wrapper (Solidity) | [PolygonScan Verified](https://polygonscan.com/address/0x692F3360166fb7654026a89801DdE9F684F8F8b0#code) | | uTrade V2 Single Liquidity Wrapper Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiSingleLiquidityWrapper.json) | | uTrade V2 Single Liquidity Wrapper as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiSingleLiquidityWrapper.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Single Liquidity Wrapper Contract Addresses | Network | Address | | ---------------- | --------------------------------------------------------------------------------------------------------------------------------- | | Polygon Main Net | `0x692F3360166fb7654026a89801DdE9F684F8F8b0` ([Link](https://polygonscan.com/address/0x692F3360166fb7654026a89801DdE9F684F8F8b0)) | ### convertSingleAssetToLiquidity ``` function convertSingleAssetToLiquidity(address tokenA, address requireToken, uint amount, address to, uint minOut) external ; ``` The `convertSingleAssetToLiquidity`function converts one of the assets that a liquidity pool contains into a LP token. It does so by first converting the exact amount of one token required for an equal amount of the other asset that makes up the pool. Next, the two equal values of tokens are added to the liquidity pool. And lastly, the LP tokens are sent to the address provided. | Parameter | Type | Description | | -------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *tokenA* | address | The contract address of the provided token to be converted into the LP token. | | *requireToken* | address | The contract address of the other token in the liquidity pool. In other words, the asset that half of *tokenA* will be converted to that will be added to the liquidity pool. | | *amount* | uint | The amount of *tokenA* to be sent to the liquidity pool. | | *to* | address | The recipient of the LP tokens. | | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### convertSingleAssetToLiquidityEth ``` function convertSingleAssetToLiquidityEth(address requireToken, address to, uint minOut) payable external ; ``` The `convertSingleAssetToLiquidityETH`function converts MATIC into a LP token. It does so by first converting the provided MATIC into equal amounts of the two tokens that make up the liquidity pool. Next, the two equal values of tokens are added to the liquidity pool. And lastly, the LP tokens are sent to the address provided. The MATIC value is sent as a msg.value parameter. One of the two assets can be WMATIC. #### Parameter Breakdown | Parameter | Type | Description | | ------------------------------------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | |amountIn
(msg.value)
The pathway to change depositToken into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change the depositToken into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### convertSingleAssetToOtherLiquidityETH ``` function convertSingleAssetToOtherLiquidityETH( address requireTokenA,address requireTokenB , address to, address[] calldata path1, address[] calldata path2,uint minOut) payable external ; ``` The `convertSingleAssetToOtherLiquidityETH`function converts MATIC to an uTrade V2 LP token made up of two different tokens. In other words, MATIC will be converted to the two tokens that make up a liquidity pair, and then the two tokens are added to the liquidity pool. | Parameter | Type | Description | | ------------------------------------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |amountIn
(msg.value)
The pathway to change MATIC into requireTokenA, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address must be WMATIC's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As MATIC must be converted to WMATIC, multiple addresses will be required. The last token contract address in path1 will be the first token in the liquidity pair.
| | *path2* | address |The pathway to change MATIC into requireTokenB, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity. The first address in the array must be WMATIC's contract address.
In other words, the path represents the pathway from the token you are providing to the first token that makes up the liquidity pool you are adding to. As MATIC must be converted to WMATIC, multiple addresses will be required. The last token contract address in path2 will be the second token in the liquidity pair.
| | *minOut* | uint | The minimum amount of the received LP tokens that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsSingleAsset ``` function withdrawSupplyAsSingleAsset( address receiveToken , address liquidityToken ,address tokenA,address tokenB, address payable to, uint amount, bool toReceiveWNative,uint minOut) external ; ``` The `withdrawSupplyAsSingleAsset` function withdraws a user's liquidity from a pool, and converts it to one of the two tokens that makes up the liquidity pool. In other words, it redeems an LP token for one of the two assets that make up an LP token. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native BNB. If true, the *receiveToken* address should be WBNB, as it will unwrap WMATIC and send MATIC. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ### withdrawSupplyAsOtherSingleAsset ``` function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; ``` The `withdrawSupplyAsOtherSingleAsset`function withdraws a user's liquidity from a pool, and converts it to any other asset that is available on uTrade V2. In other words, it redeems an LP token for MATIC or any ERC-20 token available. #### Parameter Breakdown | Parameter | Type | Description | | ------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *receiveToken* | address | The address of the token contract of the preferred token to be withdrawn. This determines which of the two tokens the LP will be converted to. | | *liquidityToken* | address | The address of the token contract for the LP token to be converted. | | *tokenA* | address | The address of the token contract for the first token in the liquidity pool. | | *tokenB* | address | The address of the token contract for the second token in the liquidity pool. | | *to* | address | The address to where the single asset will be sent. | | *amount* | uint | The amount of LP tokens to be removed. | | *path1* | address |The pathway to change tokenA into the desired asset, consisting of an array of token addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenA to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path1 must be the same as the last token contract address in path2.
| | *path2* | address |The pathway to change tokenB into the desired asset, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
In other words, the path represents the pathway from tokenB to the withdraw token. If there is no direct pair, multiple addresses will be required. The last token contract address in path2 must be the same as the last token contract address in path1.
| | *toReceiveWNative* | bool | A true/false value if one of the assets to be received is native MATIC. If true, the *receiveToken* address should be WMATIC, as it will unwrap WMATIC and send MATIC. | | *minOut* | uint | The minimum amount of the received asset that is acceptable. If the amount to be received is below this number, this transaction will revert. | ## Interface Code ``` interface IUnifiSingleLiquidity { function convertSingleAssetToLiquidity(address tokenA, address requireToken, uint amount, address to, uint minOut) external ; function convertSingleAssetToLiquidityEth(address requireToken, address to, uint minOut) payable external ; function convertSingleAssetToOtherLiquidity(address depositToken, address requireTokenA, address requireTokenB, uint amount, address to, address[] calldata path1, address[] calldata path2, uint minOut) external ; function convertSingleAssetToOtherLiquidityETH(address requireTokenA, address requireTokenB, address to, address[] calldata path1, address[] calldata path2, uint minOut) payable external ; function withdrawSupplyAsSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, bool toReceiveWNative, uint minOut) external ; function withdrawSupplyAsOtherSingleAsset(address receiveToken, address liquidityToken, address tokenA, address tokenB, address payable to, uint amount, address[] calldata path1, address[] calldata path2, bool toReceiveWNative, uint minOut) external ; } ``` # UnifiController.sol The Unifi Controller is a work in progress with minor tweaks here and there. Full documentation will be available once it is optimized! **Primary Uses -** The Unifi Controller is responsible for the setting the variables of UP minting on individual pairs as well as updating the redeem value of UP tokens globally. ## uTrade V2 Controller Code / Interfaces | | | | ------------------------------------------- | --------- | | uTrade V2 Controller (Solidity) | Link Here | | uTrade V2 Controller Interface as JSON | Link Here | | uTrade V2 Controller as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 Controller Contract Addresses | Network | Address | | ---------------- | -------------------------------------------------------------------------------------------------------------------------------- | | Polygon Main Net | `0x90D861c4A115346A09C0b33E441A9FC32333Cb33`([Link](https://polygonscan.com/address/0x90D861c4A115346A09C0b33E441A9FC32333Cb33)) | ## Events ### SwapFeesUPminted ``` event SwapFeesUpminted(address indexed pool, uint amountUPMinted, address defaultPoolAddress, uint platforUPFees); ``` The `SwapFeeUpminted` event is emitted whenever UP is minted. In the majority of cases, this will occur any time a trade occurs. #### Parameter Breakdown | Parameter | Type | Description | | -------------------- | ------- | ----------------------------------------------------------------------------------------------- | | *pool* | address | The liquidity pool where the UP was minted. | | *amountUPMinted* | uint | The amount of UP minted during this event. | | *defaultPoolAddress* | address | The pool representing the 'Super Pair' reward for UNIFI holders. | | *platforUPFees* | uint | The amount of UP collected by the platform for increasing the redeem value and for Super Pairs. | ### UpdatePoolRewards ``` event UpdatePoolRewards(address indexed pool, uint rewards); ``` The `UpdatePoolRewards` event is emitted when the amount of UP claimable by the liquidity providers in the liquidity pool is updated. This event occurs when a trade occurs and results in UP being minted for liquidity providers, or a liquidity provider performs a claim UP transaction. #### Parameter Breakdown | Parameter | Type | Description | | --------- | ------- | -------------------------------------------------------------------------------- | | *pool* | address | The liquidity pool where the UP was minted. | | *rewards* | uint | The amount of UP available to be claimed by all liquidity providers in the pool. | ## Read-Only Functions #### feeSetter ``` function feeSetter() external view returns (address); ``` The `feeSetter` function returns the address of uTrade V2's Smart Contract which sets the fees for trading. ### WETH ``` function WETH() external view returns (address); ``` The `WETH` function will return the address of WMATIC on Polygon. As this does not change, it will always return `0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270`. ### UNIFIUPVault ``` function UNIFIUPVault() external view returns (address); ``` The `UNIFIUPVault` function returns the address of the UPMatic vault. This vault contains the MATIC that is redeemable for UP. ### nativeFeeTo ``` function nativeFeeTo() external view returns (address); ``` The `nativeFeeTo` function returns the address where, in the case of Unifi Protocol collecting native token fees, the fees would be sent to. # UnifiERC20.sol **Primary Uses -** UnifiERC20.sol essentially ports the properties of ERC-20 tokens on to Unifi LP Tokens, or uTokens. An example of this in practice would be the 'approve' transaction. ## uTrade V2 UnifiERC20 Code / Interfaces | | | | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 UnifiERC20 (Solidity) | [PolygonScan Verified Pair (WMATIC / UPMatic)](https://polygonscan.com/address/0x2c3f16c99cb288c79200bc380831018ee1d65c5e#code) | | uTrade V2 UnifiERC20 Interface as JSON | Link Here | | uTrade V2 UnifiERC20 as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 UnifiERC20 Contract Addresses Each uTrade V2 Liquidity Pool uses the uTrade V2 ERC20 Interface in the contract. An example would be `0x2C3F16C99CB288C79200BC380831018ee1d65C5E` ([Link](https://polygonscan.com/address/0x2c3f16c99cb288c79200bc380831018ee1d65c5e)) for the WMATIC / UPMatic pair. ## Events ### Approval ``` event Approval(address indexed owner, address indexed spender, uint value); ``` The `Approval` event is emitted anytime an `approve` or `permit` function is called. ### Transfer ``` event Transfer(address indexed from, address indexed to, uint value); ``` The `Transfer` event is emitted anytime a transfer of LP tokens occurs, by the `transfer`, `transferFrom`, `mint`, or `burn` functions. ## Read-Only Functions ### name ``` function name() external pure returns (string memory); ``` The `name` function will return "Unifi LPs" for all liquidity pool contracts. ### symbol ``` function symbol() external pure returns (string memory); ``` The `symbol` function will return "Unifi-LP" for all liquidity pool contracts. ### decimals ``` function decimals() external pure returns (uint8); ``` The `decimals` function returns "18" as a uint8 value, which is the precision for each uToken on uTrade V2. ### totalSupply ``` function totalSupply() external view returns (uint); ``` The `totalSupply` function returns the total amount uTokens for a pair. ### balanceOf ``` function balanceOf(address owner) external view returns (uint); ``` The `balanceOf` function returns the balance of uTokens for the provided address. ### allowance ``` function allowance(address owner, address spender) external view returns (uint); ``` The `allowance` function returns the amount of tokens an address is approved to transfer when using the `transferFrom` function. ### DOMAIN\_SEPARATOR ``` function DOMAIN_SEPARATOR() external view returns (bytes32); ``` The `DOMAIN_SEPARATOR` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in `permit` function. ### PERMIT\_TYPEHASH ``` function PERMIT_TYPEHASH() external view returns (bytes32); ``` The `PERMIT_TYPEHASH` function is used in the `permit` function, and is one of the components that allows transactions to get through without a prior approve transaction. Calling a read function returns the bytes32 data that is required for use in the `permit` function. ### nonces ``` function nonces(address owner) external view returns (uint); ``` The `nonces` function is used in the permit function. It returns the current nonce of the *address* provided. ## State-Changing Functions ### approve ``` function approve(address spender, uint value) external returns (bool); ``` The `approve` function sets a *value* for the amount of LP tokens the *address* provided is allowed to transfer. Returns a boolean value and emits the `Approval` event. ### transfer ``` function transfer(address to, uint value) external returns (bool); ``` The `transfer` function lets an address send uTokens from one address to another, and returns a boolean value and emits a `Transfer` event. ### transferFrom ``` function transferFrom(address from, address to, uint value) external returns (bool); ``` The `transferFrom` function sends uTokens from one address to another. This requires the sending address to have approval to send uTokens. Returns a boolean value and emits a `Transfer`event. ### permit ``` function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; ``` The permit function allows a sender to use a signature in lieu of an approval transaction, and sets the allowance for an address to send. #### Function Parameter Breakdown | Parameter | Type | Description | | ---------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | *owner* | address | The owner of the address. | | *spender* | address | The spender of the uTokens. | | *value* | uint | The amount of uTokens to be transferred. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | | *v* | uint8 | The v value of the permit. This is one of the three values that makes up the approval signature. | | *r* | bytes32 | The r value of the permit. This is one of the three values that makes up the approval signature. | | *s* | bytes32 | The s value of the permit. This is one of the three values that makes up the approval signature. | ## Interface Code ``` interface IUnifiERC20 { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; } ``` # UnifiFactory.sol **Primary Uses** - The uTrade V2 Factory contract creates an LP token for any pairs listed on uTrade V2, and indexes them for easy retrieval. In addition, it can return the address of the LP token based on a call of the addresses of the two tokens that make up the liquidity pool. ## uTrade V2 Factory Code / Interfaces | | | | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Factory (Solidity) | [PolygonScan Verified](https://polygonscan.com/address/0x4FEE52912f81B78C3CdcB723728926ED6a893D27#code) | | uTrade V2 Factory Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiFactory.json) | | uTrade V2 Factory Interface as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiFactory.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Factory Contract Addresses | Network | Address | | ---------------- | --------------------------------------------------------------------------------------------------------------------------------- | | Polygon Main Net | `0x4FEE52912f81B78C3CdcB723728926ED6a893D27` ([Link](https://polygonscan.com/address/0x4FEE52912f81B78C3CdcB723728926ED6a893D27)) | ## Events ### PairCreated ``` event PairCreated(address indexed token0, address indexed token1, address pair, uint); ``` Anytime a pair is created on uTrade V2 using the `createPair` function, a `PairCreated` event is emitted. Contracts can be deployed to listen for new pairs on the uTrade V2 Polygon Factory address. * *token0* is the token address of the first asset in the token pair. * *token1* is the token address of the second asset in the token pair. * *pair* is the address of the newly created uTrade V2 liquidity pool. * *uint* refers to the index of this uTrade V2 Factory*.* For example, the first liquidity pool created on uTrade V2 is 1, the second liquidity pool is 2, and so on. This number can used with the `allPairs(uint)` to return the address. The current number, and therefore the total number of LP pools on uTrade V2 Polygon, can be accessed using the `allPairsLength` function. ## Read-Only Functions ### getPair ``` function getPair(address tokenA, address tokenB) external view returns (address pair); ``` A call to the `getPair` function returns the address of the pair for *tokenA* and *tokenB*. * If the pair does not exist, the call will return *address(0)*. * The order of the tokens is irrelevant in this call. For example, a call for WMATIC, UNIFI will return the same pair address as UNIFI, WMATIC. ### allPairs ``` function allPairs(uint) external view returns (address pair); ``` A call to the `allPairs` function returns the address of a pair based on the indexed *uint* value assigned upon creation of the LP. * For example, `allPairs(0)` will return the first pair created on uTrade V2 Polygon. * If the index number is too high, as in, there aren't enough pairs created yet, the function will return *address(0)*. ### allPairsLength ``` function allPairsLength() external view returns (uint); ``` A call to the `allPairsLength` function returns the current number of pairs. * For example, if there are 201 total liquidity pool pairs on uTrade V2 Polygon, this call will return *200* as an uint value. ### feeTo ``` function feeTo() external view returns (address); ``` A call to the `feeTo` function returns the percentage of trading fees that Unifi Protocol receives. * Due to the nature of UP Token economics, this is set to zero, but is preserved for flexibility in the future. ### feeToSetter ``` function feeToSetter() external view returns (address); ``` A call to the `feeToSetter` function returns the address to which the `feeTo` would send trading fees, if trading fees were collected. ## State-Changing Functions ### createPair ``` function createPair(address tokenA, address tokenB) external returns (address pair); ``` Creates a liquidity pool pair for *tokenA* and *tokenB* if one does not currently exist. After the function is confirmed on chain, a `PairCreated` event is emitted. ## Interface Code ``` interface UnifiFactory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function createPair(address tokenA, address tokenB) external returns (address pair); } ``` ### ### # UnifiPair.sol **Primary Uses -** UnifiPair.sol is responsible for many of the functionalities of liquidity pool tokens and UP tokens. First, it is responsible for the issuing and burning of Liquidity Pool Tokens (uTokens). In addition, it allows for direct reads of the reserves and ratio of the liquidity pool, as well as swaps. Lastly, it is where UP claims are processed. ## uTrade V2 Pair Code / Interfaces | | | | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Pair (Solidity) | [PolygonScan Verified Pair (WMATIC / UPMatic)](https://polygonscan.com/address/0x2c3f16c99cb288c79200bc380831018ee1d65c5e#code) | | uTrade V2 Pair Interface as JSON | Link Here | | uTrade V2 Pair as Typescript | Link Here | | Import statement codeblock (when available) | | ## uTrade V2 Pair Contract Addresses Each uTrade V2 Liquidity Pool uses the uTrade V2 UnifiPair Interface in the contract. An example would be `0x2C3F16C99CB288C79200BC380831018ee1d65C5E` ([Link](https://polygonscan.com/address/0x2c3f16c99cb288c79200bc380831018ee1d65c5e)) for the WMATIC / UPMatic pair. ## Events ### Mint ``` event Mint(address indexed sender, uint amount0, uint amount1); ``` The `Mint` event is emitted any time liquidity tokens are created via the `mint` function. In other words, when a user adds liquidity to a pair, then they will receive LP tokens, therefore the `Mint` event will be emitted. ### Burn ``` event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); ``` The `Burn` event is emitted any time liquidity tokens are burned via the `burn` function. In other words, when a user removes liquidity from a pair, their LP tokens will be burned, therefore the `Burn` event will be emitted. ### Swap ``` event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); ``` The `Swap` event is emitted any time the `swap` function is used. Under the hood, all trades on uTrade V2 are swaps. Therefore, any time somebody trades on the pair, the uTrade contract for that pair will emit a `Swap` event. ### Sync ``` event Sync(uint112 reserve0, uint112 reserve1); ``` The `Sync` event is emitted anytime a function occurs that may change the reserves of a token pair. In other words, anytime the amount of the two tokens within a liquidity pool may change. Therefore, whenever a`mint`, `burn`, `swap`, or `sync` function is called, the `Sync` event will be emitted. ## Read-Only Functions ### MINIMUM\_LIQUIDITY ``` function MINIMUM_LIQUIDITY() external pure returns (uint); ``` The `MINIMUM_LIQUIDITY`function will always return 1000. The function itself refers to the burning of initial LP tokens that occurs once when a pool is created. This burn of a tiny amount allows for cleaner LP token numbers therefore avoiding LP tokens being represented as very small decimals value. This allows the tick size to be more precise and prevents rounding errors. ### factory ``` function factory() external view returns (address); ``` The `factory` function will return the current factory address for uTrade V2. ### WBNB ``` function WETH() external view returns (address); ``` The `WETH` function will return the address of WMATIC on Polygon. As this does not change, it will always return `0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270`. ### token0 ``` function token0() external view returns (address); ``` The `token0` function will return the contract address of the first token that makes up the liquidity pair. In other words, if the liquidity pool is made up of USDT / USDC, it will return the contract address of USDT. ### token1 ``` function token1() external view returns (address); ``` The `token1` function will return the contract address of the first token that makes up the liquidity pair. In other words, if the liquidity pool is made up of USDT / USDC, it will return the contract address of USDC. ### getReserves ``` function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); ``` The `getReserves` function returns the reserves of the two tokens that make up the liquidity pool as *reserve0* and *reserve1*. These two values can be helpful in determining the current price of each asset. The function also returns a timestamp with the block number. ### price0CumulativeLast ``` function price0CumulativeLast() external view returns (uint); ``` The `price0CumulativeLast` function is for Oracle usage on uTrade V2. The value of *token0* is captured at the end of each block, and can be called using this function to feed into an Oracle to determine a more time-weighted 'average' price. ### price1CumulativeLast ``` function price1CumulativeLast() external view returns (uint); ``` The `price1CumulativeLast` function is for Oracle usage on uTrade V2. The value of *token1* is captured at the end of each block, and can be called using this function to feed into an Oracle to determine a more time-weighted 'average' price. ### kLast ``` function kLast() external view returns (uint); ``` The `kLast` function returns the value of *reserve0* \* *reserve1*, after any event that may have triggered a change in the liquidity. For example, the execution of a *swap* function or a *mint* function. ## State-Changing Functions ### mint ``` function mint(address to) external returns (uint liquidity); ``` The `mint` function creates the LP tokens that represent a user's tokens in a liquidity pool. For example, if a user provides 100 MATIC and 200 USDT liquidity to a pool, the Unifi Pair Smart Contract will mint an amount of uUSDT tokens. Will emit the `Mint`, `Sync`, and `Transfer` events. ### burn ``` function burn(address to) external returns (uint amount0, uint amount1); ``` The `burn` function destroys the LP tokens that represent a user's token in a liquidity pool. For example, if a user removes 100 MATIC and 200 USDT liquidity to a pool, the Unifi Pair Smart Contract will burn an amount of uUSDT tokens. Will emit the `Burn`, `Sync`, and `Transfer` events. ### claimUP ``` function claimUP(address to) external lock returns(uint) { ``` The `claimUP` function claims any UP earned from providing liquidity if any exists, and sends the UP to the address provided. ### swap ``` function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; ``` The `swap` function exchanges one token for another. Under the hood, all trades on uTrade V2 use this function. The *calldata* must be 0 during a normal swap, but must contain data if executing a flash loan. Emits the `Swap` and `Sync` events. ### skim ``` function skim(address to) external; ``` The `skim` function operates as a safeguard if the amount of tokens causes a data error due to too large of a number in the reserves pools. In this unusual circumstance, this will trigger failures in trades. The `skim` function can be called to return the overflowed tokens to the caller. ### sync ``` function sync() external; ``` The `sync` function operates as a safeguard in certain events where the token balance changes outside of normal trading. An example would be an algorithmic stablecoin re-balancing, therefore lowering or raising the amount of the algorithmic stablecoin in the pool. The `sync` function may be called to reset the price ratio to the new reserves. Emits the `Sync`event. ## Interface Code ``` interface IUnifiPair { event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } ``` # UnifiRouter.sol **Primary Uses** - The uTrade V2 Router is the 'brain' of uTrade. The router finds the optimal path for exchanging one token for another. Whenever a trade is made, your wallet sends funds to the router address. The router will then carry out as many transactions as necessary to acquire the desired token. The router also handles adding liquidity to liquidity pools, and sending the corresponding LP tokens to liquidity providers. ## uTrade V2 Router Code / Interfaces | | | | ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | | uTrade V2 Router (Solidity) | [PolygonScan Verified](https://polygonscan.com/address/0x03105929e82B1b8Fb6Eb76266CBd14C16a19D1f2#code) | | uTrade V2 Router Interface as JSON | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/JSON/IUnifiRouter.json) | | uTrade V2 Router Interface as Typescript | [GitHub](https://github.com/unifiprotocol/uTradeV2-core/blob/52d66be2a472b9697a577757a0446076b6c32001/ABI/TS/IUnifiRouter.ts) | | Import statement codeblock (when available) | | ## uTrade V2 Router Contract Addresses | Network | Address | | ---------------- | -------------------------------------------------------------------------------------------------------------------------------- | | Polygon Main Net | `0x03105929e82B1b8Fb6Eb76266CBd14C16a19D1f2`([Link](https://polygonscan.com/address/0x03105929e82B1b8Fb6Eb76266CBd14C16a19D1f2)) | ### factory ``` function factory() external pure returns (address); ``` A call to the `factory` function returns the address of the current Factory used by uTrade v2. The current factory address for uTrade V2 on Polygon is `0x4FEE52912f81B78C3CdcB723728926ED6a893D27`. ### WETH ``` function WETH() external pure returns (address); ``` A call to the `WETH` function returns the address of Wrapped Matic (WMATIC) on Polygon. As this address does not change, it will always return `0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270`. ### quote ``` function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); ``` A call to the `quote` function returns the amount of *tokenB* that will be received for an amount of *tokenA*. This can be used to calculate the exchange rate between two tokens without factoring in slippage or fees. By entering the amount of *tokenA,* the total amount of reserves of *tokenA* as *reserveA,* and the total amount of reserves of *tokenB* as *reserveB*, the call will return the equivalent amount of *tokenB*. ### getAmountOut ``` function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); ``` A call to the `getAmountOut`function with the amount of the token being sent will return the maximum amount of a token to be received, accounting for fees and the total amount of reserves. ### getAmountIn ``` function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); ``` A call to the `getAmountIn` function with the amount of the token you wish to receive will return the minimum amount required of the token you wish to send, accounting for fees and the total amount of reserves. ### getAmountsOut ``` function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); ``` A call to the `getAmountsOut` function with the amount of the token being sent will return the maximum amount to be received of multiple different tokens. By entering multiple LP addresses in the *address* array, the function will return the maximum amount of each token that will be received. A call to this function uses the `getReserves` function from [UnifiPair.sol](https://docs.unifiprotocol.com/utrade-v2/polygon/unifipair.sol) to determine the reserves of the liquidity pool. Then, it calls the `getAmountOut` function to determine the amount of each token in the array that will be received for the *amountIn* value of a token. ### getAmountsIn ``` function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); ``` A call to the `getAmountsIn` function with the desired amount of the token to be received will return the minimum amount required to be sent of multiple tokens. By entering multiple LP addresses in the *address* array, the function will return the minimum amount of each token that will need to be sent to receive the desired amount of a token. A call to this function uses the `getReserves` function from [UnifiPair.sol](https://docs.unifiprotocol.com/utrade-v2/polygon/unifipair.sol) to determine the reserves of the liquidity pool. Then, it calls the `getAmountIn` function to determine the amount of each token in the array that will need to be sent for the *amountOut* value of a token. ## State-Changing Functions - Liquidity ### addLiquidity ``` function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); ``` The `addLiquidity` function adds the two tokens that make up the liquidity pool - *tokenA* and *tokenB* - at the proper ratio based on the reserves of the pool. For example, if the pool contains 200 USDT / 100 WMATIC, a user's liquidity will be added at the ratio of 2 USDT to 1 WMATIC, provided there is no price movements in the pair between when the user broadcasts the transaction to when it is mined. In the event of a price movement, the *amountADesired*, *amountBDesired*, *amountAMin*, and *amountBMin* act as a security measure against an adverse price movement. After the liquidity is added, the function sends the corresponding LP tokens to the sender. In the case of a pool not existing for the two assets, one will be created using [UnifiFactory.sol](https://docs.unifiprotocol.com/utrade-v2/polygon/unififactory.sol) at the ratio of the assets supplied. #### Function Parameters Breakdown | Parameter | Type | Description | | ---------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *tokenA* | address | Token address of the first asset in the token pair. | | *tokenB* | address | Token address of the second asset in the token pair. | | *amountADesired* | uint | The amount of *tokenA* to be added to liquidity if the value of *tokenA* goes down in comparison to *tokenB*. | | *amountBDesired* | uint | The amount of *tokenB* to be added to liquidity if the value of *tokenB* goes down in comparison to *tokenA.* | | *amountAMin* | uint |Sets the minimum amount of tokenA that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of tokenB that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of the supplied token that can added to the pool before the transaction reverts. This acts as a safeguard.
Sets the minimum amount of MATIC that can added to the pool before the transaction reverts. This acts as a safeguard.
The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactTokens ``` function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); ``` The `swapTokensForExactTokens` function sends the minimum amount of tokens for the exact amount of another token. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the desired tokens to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | ---------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactETHForTokens ``` function swapExactETHForTokens( uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapExactETHForTokens` function sends an exact amount of MATIC for a desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of MATIC to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping MATIC to WMATIC, the first address must be WMATIC.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of MATIC sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapTokensForExactETH ``` function swapTokensForExactETH( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapTokensForExactETH` function sends an amount of tokens for an exact amount of MATIC. #### Function Parameter Breakdown | Parameter | Type | Description | | ------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountOut* | uint | The exact amount of the MATIC to be received. | | *amountInMax* | uint | Sets the maximum amount of token to be sent in. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be sent rises above this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapExactTokensForETH ``` function swapExactTokensForETH( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); ``` The `swapExactTokensForETH` function sends an exact amount of tokens for MATIC. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into MATIC. | | *amountOutMin* | uint | Sets the minimum amount of the MATIC to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Parameter Return Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of tokens sent into the swap, as well as the exact amount of all subsequent swaps. | ### swapETHForExactTokens ``` function swapETHForExactTokens( uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); ``` The `swapETHForExactTokens` function swaps an exact amount of MATIC for an amount of the desired token. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the amount of MATIC to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping MATIC to WMATIC, the first address must be WMATIC.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | #### Function Return Parameter Breakdown | Parameter | Type | Description | | --------- | -------------- | --------------------------------------------------------------------------------------------------------- | | *amounts* | uint\[] memory | The exact amount of MATIC sent into the swap, as well as the exact return amount of all subsequent swaps. | ### swapExactTokensForTokensSupportingFeeOnTransferTokens ``` function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The `swapExactTokensForTokensSupportingFeeOnTransferTokens` function is similar to `swapExactTokensForTokens` as it swaps one ERC-20 token for another ERC-20 token. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Name | Type | | | -------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into another token. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactETHForTokensSupportingFeeOnTransferTokens ``` function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; ``` The `swapExactETHForTokensSupportingFeeOnTransferTokens`function is similar to `swapExactETHForTokens` function as it swaps an exact amount of MATIC for ERC-20 tokens. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | --------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |(amountIn)
msg.value
| uint | Sent as the msg.value, the exact amount of MATIC to be swapped. | | *amountOutMin* | uint | Sets the minimum amount of the desired token to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
As the first swap is swapping MATIC to WMATIC, the first address must be WMATIC.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ### swapExactTokensForETHSupportingFeeOnTransferTokens ``` function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; ``` The function `swapExactTokensForETHSupportingFeeOnTransferTokens`is similar to the `swapExactTokensForETH`function, as it swaps an exact amount of ERC-20 tokens for MATIC. In addition, this function allows for fee on transfer tokens, such as PAXG, to be used on uTrade. #### Function Parameter Breakdown | Parameter | Type | Description | | -------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | *amountIn* | uint | The amount of tokens being sent to swap into MATIC. | | *amountOutMin* | uint | Sets the minimum amount of the MATIC to receive. This acts as a safeguard against removing liquidity during a spike in value. If the amount to be received falls below this value, the transaction reverts. | | *path* | address\[] calldata |The pathway to change one token to another, consisting of an array of addresses. Each token must have an existing liquidity pool, as well as have liquidity.
The path represents the pathway from one token to another. If a pair exists for the two tokens you wish to exchange, this will contain two values inside of an array. However, if there is no direct pair, multiple addresses may be required.
| | *to* | address | The address to where the desired token will be sent. | | *deadline* | uint | The UNIX timestamp for which this transaction must be completed. If the transaction is mined after this deadline, the transaction will revert. | ## Interface Code ``` interface IUnifiRouter01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut, uint fee) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUnifiRouter02 is IUnifiRouter01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } ``` # Unifi.Report API Docs Documentation for Unifi Report public API endpoints. New API endpoints will be added here as they are developed. \ \ All Unifi Report API endpoints should be called using the url: `https://data.unifi.report` # Graphs API endpoints for the various charts and graphs displayed on Unifi Report. ## # Account Page Graph data The amount of unique and total accounts that have interacted with the Unifi Protocol over a given time period. All Unifi Report API endpoints should be called using the url: `https://data.unifi.report` Endpoint `GET /api/account-page-graph/` | Parameter | Description | | ---------- | --------------- | | blockchain | Blockchain name | Example API call: `curl -X GET -H 'Accept: application/json; indent=4' https://data.unifi.report/api/account-page-graph/?blockchain=Tron`\ Response: ``` [ { "date": "2021-01-04", "blockchain": "Tron", "blockchain_active_traders": "69", "blockchain_total_traders": "989" }, { "date": "2021-01-05", "blockchain": "Tron", "blockchain_active_traders": "53", "blockchain_total_traders": "991" }, { "date": "2021-01-06", "blockchain": "Tron", "blockchain_active_traders": "53", "blockchain_total_traders": "997" }, { "date": "2021-01-07", "blockchain": "Tron", "blockchain_active_traders": "60", "blockchain_total_traders": "1005" }, { "date": "2021-01-08", "blockchain": "Tron", "blockchain_active_traders": "67", "blockchain_total_traders": "1009" }, { "date": "2021-01-09", "blockchain": "Tron", "blockchain_active_traders": "65", "blockchain_total_traders": "1013" }, { "date": "2021-01-10", "blockchain": "Tron", "blockchain_active_traders": "53", "blockchain_total_traders": "1016" }, { "date": "2021-01-11", "blockchain": "Tron", "blockchain_active_traders": "52", "blockchain_total_traders": "1020" }, { "date": "2021-01-12", "blockchain": "Tron", "blockchain_active_traders": "56", "blockchain_total_traders": "1026" }, { "date": "2021-01-13", "blockchain": "Tron", "blockchain_active_traders": "49", "blockchain_total_traders": "1027" }, { "date": "2021-01-14", "blockchain": "Tron", "blockchain_active_traders": "43", "blockchain_total_traders": "1031" } ] ``` # Details Page Graphs Details regarding specific uPairs on uTrade, including USD value of liquidity. All Unifi Report API endpoints should be called using the url: `https://data.unifi.report` Endpoint `GET /api/liquidity-graph-info/`