Router

Because routers are stateless and do not hold token balances, they can be replaced safely and trustlessly, if necessary. This may happen if more efficient smart contract patterns are discovered, or if additional functionality is desired.

Code#

PegasysRouter.sol

Address#

0x017dAd2578372CAEE5c6CddfE35eEDB3728544C4

Read-Only Functions#

factory#

function factory() external pure returns (address);

Returns factory address.

WSYS#

function WSYS() external pure returns (address);

Returns the 0xd3e822f3ef011Ca5f17D82C956D952D8d7C3A1BB.

quote#

See quote.

getAmountOut#

See getAmountOut.

getAmountIn#

See getAmountIn.

getAmountsOut#

function getAmountsOut(uint amountIn, address[] memory path) public view returns (uint[] memory amounts);

See getAmountsOut.

getAmountsIn#

function getAmountsIn(uint amountOut, address[] memory path) public view returns (uint[] memory amounts);

See getAmountsIn.

State-Changing Functions#

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);

Adds liquidity to an ERC-20⇄ERC-20 pool.

To cover all possible scenarios, msg.sender should have already given the router an allowance of at least amountADesired/amountBDesired on tokenA/tokenB.
Always adds assets at the ideal ratio, according to the price when the transaction is executed.
If a pool for the passed tokens does not exists, one is created automatically, and exactly amountADesired/amountBDesired tokens are added.

Name	Type
tokenA	`address`	A pool token.
tokenB	`address`	A pool token.
amountADesired	`uint`	The amount of tokenA to add as liquidity if the B/A price is <= amountBDesired/amountADesired (A depreciates).
amountBDesired	`uint`	The amount of tokenB to add as liquidity if the A/B price is <= amountADesired/amountBDesired (B depreciates).
amountAMin	`uint`	Bounds the extent to which the B/A price can go up before the transaction reverts. Must be <= amountADesired.
amountBMin	`uint`	Bounds the extent to which the A/B price can go up before the transaction reverts. Must be <= amountBDesired.
to	`address`	Recipient of the liquidity tokens.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amountA	`uint`	The amount of tokenA sent to the pool.
amountB	`uint`	The amount of tokenB sent to the pool.
liquidity	`uint`	The amount of liquidity tokens minted.

addLiquiditySYS#

function addLiquiditySYS(
  address token,
  uint amountTokenDesired,
  uint amountTokenMin,
  uint amountSYSMin,
  address to,
  uint deadline
) external payable returns (uint amountToken, uint amountSYS, uint liquidity);

Adds liquidity to an ERC-20⇄WSYS pool with SYS.

To cover all possible scenarios, msg.sender should have already given the router an allowance of at least amountTokenDesired on token.
Always adds assets at the ideal ratio, according to the price when the transaction is executed.
msg.value is treated as a amountSYSDesired.
Leftover SYS, if any, is returned to msg.sender.
If a pool for the passed token and WSYS does not exists, one is created automatically, and exactly amountTokenDesired/msg.value tokens are added.

Name	Type
token	`address`	A pool token.
amountTokenDesired	`uint`	The amount of token to add as liquidity if the WSYS/token price is <= `msg.value`/amountTokenDesired (token depreciates).
`msg.value` (amountSYSDesired)	`uint`	The amount of SYS to add as liquidity if the token/WSYS price is <= amountTokenDesired/`msg.value` (WSYS depreciates).
amountTokenMin	`uint`	Bounds the extent to which the WSYS/token price can go up before the transaction reverts. Must be <= amountTokenDesired.
amountSYSMin	`uint`	Bounds the extent to which the token/WSYS price can go up before the transaction reverts. Must be <= `msg.value`.
to	`address`	Recipient of the liquidity tokens.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amountToken	`uint`	The amount of token sent to the pool.
amountSYS	`uint`	The amount of SYS converted to WSYS and sent to the pool.
liquidity	`uint`	The amount of liquidity tokens minted.

removeLiquidity#

function removeLiquidity(
  address tokenA,
  address tokenB,
  uint liquidity,
  uint amountAMin,
  uint amountBMin,
  address to,
  uint deadline
) external returns (uint amountA, uint amountB);

Removes liquidity from an ERC-20⇄ERC-20 pool.

msg.sender should have already given the router an allowance of at least liquidity on the pool.

Name	Type
tokenA	`address`	A pool token.
tokenB	`address`	A pool token.
liquidity	`uint`	The amount of liquidity tokens to remove.
amountAMin	`uint`	The minimum amount of tokenA that must be received for the transaction not to revert.
amountBMin	`uint`	The minimum amount of tokenB that must be received for the transaction not to revert.
to	`address`	Recipient of the underlying assets.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amountA	`uint`	The amount of tokenA received.
amountB	`uint`	The amount of tokenB received.

removeLiquiditySYS#

function removeLiquiditySYS(
  address token,
  uint liquidity,
  uint amountTokenMin,
  uint amountSYSMin,
  address to,
  uint deadline
) external returns (uint amountToken, uint amountSYS);

Removes liquidity from an ERC-20⇄WSYS pool and receive SYS.

msg.sender should have already given the router an allowance of at least liquidity on the pool.

Name	Type
token	`address`	A pool token.
liquidity	`uint`	The amount of liquidity tokens to remove.
amountTokenMin	`uint`	The minimum amount of token that must be received for the transaction not to revert.
amountSYSMin	`uint`	The minimum amount of SYS that must be received for the transaction not to revert.
to	`address`	Recipient of the underlying assets.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amountToken	`uint`	The amount of token received.
amountSYS	`uint`	The amount of SYS received.

removeLiquidityWithPermit#

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);

Removes liquidity from an ERC-20⇄ERC-20 pool without pre-approval, thanks to permit.

Name	Type
tokenA	`address`	A pool token.
tokenB	`address`	A pool token.
liquidity	`uint`	The amount of liquidity tokens to remove.
amountAMin	`uint`	The minimum amount of tokenA that must be received for the transaction not to revert.
amountBMin	`uint`	The minimum amount of tokenB that must be received for the transaction not to revert.
to	`address`	Recipient of the underlying assets.
deadline	`uint`	Unix timestamp after which the transaction will revert.
approveMax	`bool`	Whether or not the approval amount in the signature is for liquidity or `uint(-1)`.
v	`uint8`	The v component of the permit signature.
r	`bytes32`	The r component of the permit signature.
s	`bytes32`	The s component of the permit signature.

amountA	`uint`	The amount of tokenA received.
amountB	`uint`	The amount of tokenB received.

removeLiquiditySYSWithPermit#

function removeLiquiditySYSWithPermit(
  address token,
  uint liquidity,
  uint amountTokenMin,
  uint amountSYSMin,
  address to,
  uint deadline,
  bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountSYS);

Removes liquidity from an ERC-20⇄WETTH pool and receive SYS without pre-approval, thanks to permit.

Name	Type
token	`address`	A pool token.
liquidity	`uint`	The amount of liquidity tokens to remove.
amountTokenMin	`uint`	The minimum amount of token that must be received for the transaction not to revert.
amountSYSMin	`uint`	The minimum amount of SYS that must be received for the transaction not to revert.
to	`address`	Recipient of the underlying assets.
deadline	`uint`	Unix timestamp after which the transaction will revert.
approveMax	`bool`	Whether or not the approval amount in the signature is for liquidity or `uint(-1)`.
v	`uint8`	The v component of the permit signature.
r	`bytes32`	The r component of the permit signature.
s	`bytes32`	The s component of the permit signature.

amountToken	`uint`	The amount of token received.
amountSYS	`uint`	The amount of SYS received.

removeLiquiditySYSSupportingFeeOnTransferTokens#

function removeLiquiditySYSSupportingFeeOnTransferTokens(
  address token,
  uint liquidity,
  uint amountTokenMin,
  uint amountSYSMin,
  address to,
  uint deadline
) external returns (uint amountSYS);

Identical to removeLiquiditySYS, but succeeds for tokens that take a fee on transfer.

msg.sender should have already given the router an allowance of at least liquidity on the pool.

Name	Type
token	`address`	A pool token.
liquidity	`uint`	The amount of liquidity tokens to remove.
amountTokenMin	`uint`	The minimum amount of token that must be received for the transaction not to revert.
amountSYSMin	`uint`	The minimum amount of SYS that must be received for the transaction not to revert.
to	`address`	Recipient of the underlying assets.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amountSYS	`uint`	The amount of SYS received.

removeLiquiditySYSWithPermitSupportingFeeOnTransferTokens#

function removeLiquiditySYSWithPermitSupportingFeeOnTransferTokens(
  address token,
  uint liquidity,
  uint amountTokenMin,
  uint amountSYSMin,
  address to,
  uint deadline,
  bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountSYS);

Identical to removeLiquiditySYSWithPermit, but succeeds for tokens that take a fee on transfer.

Name	Type
token	`address`	A pool token.
liquidity	`uint`	The amount of liquidity tokens to remove.
amountTokenMin	`uint`	The minimum amount of token that must be received for the transaction not to revert.
amountSYSMin	`uint`	The minimum amount of SYS that must be received for the transaction not to revert.
to	`address`	Recipient of the underlying assets.
deadline	`uint`	Unix timestamp after which the transaction will revert.
approveMax	`bool`	Whether or not the approval amount in the signature is for liquidity or `uint(-1)`.
v	`uint8`	The v component of the permit signature.
r	`bytes32`	The r component of the permit signature.
s	`bytes32`	The s component of the permit signature.

amountSYS	`uint`	The amount of SYS received.

swapExactTokensForTokens#

function swapExactTokensForTokens(
  uint amountIn,
  uint amountOutMin,
  address[] calldata path,
  address to,
  uint deadline
) external returns (uint[] memory amounts);

Swaps an exact amount of input tokens for as many output tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).

msg.sender should have already given the router an allowance of at least amountIn on the input token.

Name	Type
amountIn	`uint`	The amount of input tokens to send.
amountOutMin	`uint`	The minimum amount of output tokens that must be received for the transaction not to revert.
path	`address[] calldata`	An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.
to	`address`	Recipient of the output tokens.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amounts	`uint[] memory`	The input token amount and all subsequent output token amounts.

swapTokensForExactTokens#

function swapTokensForExactTokens(
  uint amountOut,
  uint amountInMax,
  address[] calldata path,
  address to,
  uint deadline
) external returns (uint[] memory amounts);

Receive an exact amount of output tokens for as few input tokens as possible, along the route determined by the path. The first element of path is the input token, the last is the output token, and any intermediate elements represent intermediate tokens to trade through (if, for example, a direct pair does not exist).

msg.sender should have already given the router an allowance of at least amountInMax on the input token.

Name	Type
amountOut	`uint`	The amount of output tokens to receive.
amountInMax	`uint`	The maximum amount of input tokens that can be required before the transaction reverts.
path	`address[] calldata`	An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.
to	`address`	Recipient of the output tokens.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amounts	`uint[] memory`	The input token amount and all subsequent output token amounts.

swapExactSYSForTokens#

function swapExactSYSForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
  external
  payable
  returns (uint[] memory amounts);

Swaps an exact amount of SYS for as many output tokens as possible, along the route determined by the path. The first element of path must be WSYS, the last is the output token, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).

Name	Type
`msg.value` (amountIn)	`uint`	The amount of SYS to send.
amountOutMin	`uint`	The minimum amount of output tokens that must be received for the transaction not to revert.
path	`address[] calldata`	An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.
to	`address`	Recipient of the output tokens.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amounts	`uint[] memory`	The input token amount and all subsequent output token amounts.

swapTokensForExactSYS#

function swapTokensForExactSYS(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
  external
  returns (uint[] memory amounts);

Receive an exact amount of SYS for as few input tokens as possible, along the route determined by the path. The first element of path is the input token, the last must be WSYS, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).

msg.sender should have already given the router an allowance of at least amountInMax on the input token.
If the to address is a smart contract, it must have the ability to receive SYS.

Name	Type
amountOut	`uint`	The amount of SYS to receive.
amountInMax	`uint`	The maximum amount of input tokens that can be required before the transaction reverts.
path	`address[] calldata`	An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.
to	`address`	Recipient of SYS.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amounts	`uint[] memory`	The input token amount and all subsequent output token amounts.

swapExactTokensForSYS#

function swapExactTokensForSYS(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
  external
  returns (uint[] memory amounts);

Swaps an exact amount of tokens for as much SYS as possible, along the route determined by the path. The first element of path is the input token, the last must be WSYS, and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).

If the to address is a smart contract, it must have the ability to receive SYS.

Name	Type
amountIn	`uint`	The amount of input tokens to send.
amountOutMin	`uint`	The minimum amount of output tokens that must be received for the transaction not to revert.
path	`address[] calldata`	An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.
to	`address`	Recipient of the SYS.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amounts	`uint[] memory`	The input token amount and all subsequent output token amounts.

swapSYSForExactTokens#

function swapSYSForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
  external
  payable
  returns (uint[] memory amounts);

Receive an exact amount of tokens for as little SYS as possible, along the route determined by the path. The first element of path must be WSYS, the last is the output token and any intermediate elements represent intermediate pairs to trade through (if, for example, a direct pair does not exist).

Leftover SYS, if any, is returned to msg.sender.

Name	Type
amountOut	`uint`	The amount of tokens to receive.
`msg.value` (amountInMax)	`uint`	The maximum amount of SYS that can be required before the transaction reverts.
path	`address[] calldata`	An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.
to	`address`	Recipient of the output tokens.
deadline	`uint`	Unix timestamp after which the transaction will revert.

amounts	`uint[] memory`	The input token amount and all subsequent output token amounts.

swapExactTokensForTokensSupportingFeeOnTransferTokens#

function swapExactTokensForTokensSupportingFeeOnTransferTokens(
  uint amountIn,
  uint amountOutMin,
  address[] calldata path,
  address to,
  uint deadline
) external;

Identical to swapExactTokensForTokens, but succeeds for tokens that take a fee on transfer.

msg.sender should have already given the router an allowance of at least amountIn on the input token.

Name	Type
amountIn	`uint`	The amount of input tokens to send.
amountOutMin	`uint`	The minimum amount of output tokens that must be received for the transaction not to revert.
path	`address[] calldata`	An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.
to	`address`	Recipient of the output tokens.
deadline	`uint`	Unix timestamp after which the transaction will revert.

swapExactSYSForTokensSupportingFeeOnTransferTokens#

function swapExactSYSForTokensSupportingFeeOnTransferTokens(
  uint amountOutMin,
  address[] calldata path,
  address to,
  uint deadline
) external payable;

Identical to swapExactSYSForTokens, but succeeds for tokens that take a fee on transfer.

Name	Type
`msg.value` (amountIn)	`uint`	The amount of SYS to send.
amountOutMin	`uint`	The minimum amount of output tokens that must be received for the transaction not to revert.
path	`address[] calldata`	An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.
to	`address`	Recipient of the output tokens.
deadline	`uint`	Unix timestamp after which the transaction will revert.

swapExactTokensForSYSSupportingFeeOnTransferTokens#

function swapExactTokensForSYSSupportingFeeOnTransferTokens(
  uint amountIn,
  uint amountOutMin,
  address[] calldata path,
  address to,
  uint deadline
) external;

Identical to swapExactTokensForSYS, but succeeds for tokens that take a fee on transfer.

If the to address is a smart contract, it must have the ability to receive SYS.

Name	Type
amountIn	`uint`	The amount of input tokens to send.
amountOutMin	`uint`	The minimum amount of output tokens that must be received for the transaction not to revert.
path	`address[] calldata`	An array of token addresses. `path.length` must be >= 2. Pools for each consecutive pair of addresses must exist and have liquidity.
to	`address`	Recipient of the SYS.
deadline	`uint`	Unix timestamp after which the transaction will revert.

Interface#

import '@pollum-io/pegasys-protocol/contracts/pegasys-periphery/contracts/interfaces/IPegasysRouter.sol';

// SPDX-License-Identifier: GNU
pragma solidity >=0.6.2;

interface IPegasysRouter {
    function factory() external pure returns (address);

    function WSYS() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquiditySYS(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountSYSMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountSYS,
            uint256 liquidity
        );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquiditySYS(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountSYSMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountSYS);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquiditySYSWithPermit(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountSYSMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountSYS);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactSYSForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactSYS(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForSYS(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapSYSForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) external pure returns (uint256 amountB);

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function removeLiquiditySYSSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountSYSMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountSYS);

    function removeLiquiditySYSWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountSYSMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountSYS);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactSYSForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForSYSSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

ABI#

import IPegasysRouter from "@pollum-io/pegasys-protocol/artifacts/contracts/pegasys-periphery/interfaces/IPegasysRouter.sol/IPegasysRouter.json";

@pollum-io/pegasys-protocol