# Elastic Periphery Core Contracts ## Router[](https://docs.kyberswap.com/explanation/periphery-core-contracts#router) The Router contract to handle swapping. ### Struct: ExactInputSingleParams[](https://docs.kyberswap.com/explanation/periphery-core-contracts#struct-exactinputsingleparams) Contains data for swap exact input with a single pool. ``` ExactInputSingleParams address tokenIn; // source token to swap address tokenOut; // dest token to receive uint16 fee; // fee of the pool to swap address recipient; // the recipient of tokenOut uint256 deadline; // deadline for the transaction uint256 amountIn; // the amount of tokenIn to swap uint256 minAmountOut;// min acceptable amount of tokenOut uint160 limitSqrtP; // the limit of sqrt price, partial swap if price reaches the limitation ``` ### Struct: ExactInputParams[](https://docs.kyberswap.com/explanation/periphery-core-contracts#struct-exactinputparams) Contains data for swap exact input with one or multiple pools. ``` ExactInputParams bytes path; // contains data to identify list of pools to use for the swap address recipient; // the recipient of token out uint256 deadline; // deadline for the transaction uint256 amountIn; // the amount of token in to swap uint256 minAmountOut; // the min acceptable amount of token out ``` ### Struct: ExactOutputSingleParams[](https://docs.kyberswap.com/explanation/periphery-core-contracts#struct-exactoutputsingleparams) Contains data for swap to an exact amount out of token out, using only one pool. ``` ExactOutputSingleParams: address tokenIn; // source token to swap address tokenOut; // dest token to receive uint16 fee; // fee of the pool address recipient; // the recipient of tokenOut uint256 deadline; // deadline for the transaction uint256 amountOut; // the amount of tokenOut to expect uint256 maxAmountIn;// the max amount of tokenIn that is allowed to use uint160 limitSqrtP; // the limit of sqrt price, partial swap if price reaches the limitation ``` ### Struct: ExactOutputParams[](https://docs.kyberswap.com/explanation/periphery-core-contracts#struct-exactoutputparams) Contains data for swap to an exact amount out of token out using one or multiple pools. ``` ExactOutputParams bytes path; address recipient; uint256 deadline; uint256 amountOut; uint256 maxAmountIn; ``` ### `swapCallback()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#swapcallback) ``` Params: int256 deltaQty0 int256 deltaQty1 bytes data ``` Callback function that is be triggerred by the pool when swapping tokens. Either **deltaQty0** or **deltaQty1** must be positive. Positive value means the pool (also the caller) is expecting to receive that amount of token. ### `swapExactInputSingle()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#swapexactinputsingle) ``` Params: ExactInputSingleParams params Returns: uint256 amountOut ``` Given the **params** of **ExactInputSingleParams**, it uses only one pool to swap exact an **amountIn** of **tokenIn** to **tokenOut** and return the amount of **tokenOut** from the swap. It calls the **swap** function in the pool contract, the pool will transfer the **tokenOut** to the **Router**, and expect to receive the corresponding **tokenIn** in the swap callback function. ### `swapExactInput()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#swapexactinput) ``` Params: ExactInputParams params Returns: uint256 amountOut ``` Given the **params** of **ExactInputParams**, it uses only one or multiple pools that can be decoded from the **path**. It calls the **swap** function in each pool contract that is decoded from the **path** param, and uses callback to handle transferring tokens. Flow: * Swap path: *tokenIn -> token0 -> token1 -> ... -> tokenOut*. * Call the first pool to borrow **token0** to the **Router**, then transfer **tokenIn** from user's wallet to the first pool. * Call the second pool to borrow **token1** to the **Router**, then transfer **token0** from the **Router** to the second pool. * Repeat the action until the last pool, and transfer **tokenOut** directly to the **recipient**. ### `swapExactOutputSingle()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#swapexactoutputsingle) ``` Params: ExactOutputSingleParams params Returns: uint256 amountIn ``` Given the **params** of **ExactOutputSingleParams**, it uses only one pool to swap to get exact **amountOut** of **tokenOut** (or stop if price limit reaches). * Call the **swap** function in the pool contract. * The pool transfers the **tokenOut** to the **recipient**, and make the swap callback. * The **Router** transfer the corresponding **tokenIn** from user's wallet to the pool. The required amount of **tokenIn** should not be greater than **maxAmountIn**. ### `swapExactOutput()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#swapexactoutput) ``` Params: ExactOutputParams params Returns: uint256 amountIn ``` Given the **params** of **ExactOutputParams**, it uses one or multiple pools that can be decoded from the **path**. It calls the **swap** function in each pool contract that is decoded from the **path** param, and uses callback to handle transferring tokens. The list of pools in the **path** params should be in the reverse order, i.e the last pool first since we don't know the exact amount of token in to be used. Flow: * Origial swap path: *tokenIn -> token0 -> token1 -> ... -> tokenN -> tokenOut*. * Reverse swap path: *tokenOut -> tokenN -> ... -> token1 -> token0 -> tokenIn*. * Consider as we are swapping from **amountOut** of **tokenOut** to **tokenIn**. ## BasePositionManager[](https://docs.kyberswap.com/explanation/periphery-core-contracts#basepositionmanager) Inherit from an ERC721 contract, it stores all positions of all liquidity providers and mint corresponding NFT. Users can use the **PositionManager** to create & unlock pool, mint new position, add/remove liquidity to/from an existing position and burn their reinvestment tokens to receive back the LP fees. It also inherits from **Multicall** contract, thus, users can make multiple function/method calls to the **PositionManager** in a single transaction. All reinvestment tokens will be held in the contract, thus, it blocks anyone from transferring reinvestment tokens out. As a result, the contract can not support pools with any reinvestment tokens. ### Struct: MintParams[](https://docs.kyberswap.com/explanation/periphery-core-contracts#struct-mintparams) Params for the first time adding liquidity, mint new nft to sender ``` MintParams address token0; // the token0 of the pool address token1; // token1 of the pool, must make sure that token0 < token1 uint16 fee; // the pool's fee in bps int24 tickLower; // the position's lower tick int24 tickUpper; // the position's upper tick int24[2] ticksPrevious; // the nearest tick that has been initialized and lower than or equal to the tickLower and tickUpper, use to help insert the tickLower and tickUpper if haven't initialized uint256 amount0Desired; // the desired amount for token0 uint256 amount1Desired; // the desired amount for token1 uint256 amount0Min; // min amount of token 0 to add uint256 amount1Min; // min amount of token 1 to add address recipient; // the owner of the position uint256 deadline; // time that the transaction will be expired ``` ### Struct: IncreaseLiquidityParams[](https://docs.kyberswap.com/explanation/periphery-core-contracts#struct-increaseliquidityparams) Params for adding liquidity to the existing position ``` IncreaseLiquidityParams uint256 tokenId // id of the position to increase its liquidity uint256 amount0Desired // the desired amount for token0 uint256 amount1Desired // the desired amount for token1 uint256 amount0Min // min amount of token 0 to add uint256 amount1Min // min amount of token 1 to add uint256 deadline // time that the transaction will be expired ``` ### Struct: RemoveLiquidityParams[](https://docs.kyberswap.com/explanation/periphery-core-contracts#struct-removeliquidityparams) Params for remove liquidity from the existing position ``` RemoveLiquidityParams uint256 tokenId // id of the position to remove its liquidity uint256 amount0Min // min amount of token 0 to receive uint256 amount1Min // min amount of token 1 to receive uint256 deadline // time that the transaction will be expired ``` ### Struct: BurnRTokenParams[](https://docs.kyberswap.com/explanation/periphery-core-contracts#struct-burnrtokenparams) Burn the rTokens to get back token0 + token1 as fees ``` BurnRTokenParams uint256 tokenId // id of the position to burn r token uint256 amount0Min // min amount of token 0 to receive uint256 amount1Min // min amount of token 1 to receive uint256 deadline // time that the transaction will be expired ``` ### `createAndUnlockPoolIfNecessary()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#createandunlockpoolifnecessary) ``` Params: address token0; address token1; uint16 fee; uint160 currentSqrtP Returns: address pool // deployed pool given the set of params ``` Use this function to create & unlock a pool if needed given (**token0**, **token1**, **fee**) params and the initial sqrt price. Required: **token0 < token1** ### `mint()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#mint) ``` Params: MintParams params Returns: uint256 tokenId; uint128 liquidity, uint256 amount0, uint256 amount1 ``` Call the **\_addLiquidity** function in the **LiquidityHelper** contract with the data from \**params*. It mints a new NFT token represents the position to the recipient, stores the position data and pool information. ### `addLiquidity()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#addliquidity) ``` Params: IncreaseLiquidityParams params Returns: uint128 liquidity, uint256 amount0, uint256 amount1, uint256 additionalRTokenOwed ``` Call the **\_addLiquidity** function in the **LiquidityHelper** contract with the data from **params** to add more liquidity to a given position (i.e **tokenId**). Calculate and update the additional reinvestment tokens that the position should have earned. ### `removeLiquidity()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#removeliquidity) ``` Params: RemoveLiquidityParams params Returns: uint256 amount0, uint256 amount1, uint256 additionalRTokenOwed ``` Call the **burn** function in the pool contract with the data from **params** to remove liquidity and get back 2 tokens. Calculate and update the additional reinvestment tokens that the position should have earned. ### `burnRTokens()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#burnrtokens) ``` Params: BurnRTokenParams params Returns: uint256 rTokenQty, uint256 amount0, uint256 amount1 ``` Call the **burnRTokens** function in the pool contract to burn all reinvestment tokens from the position and get back 2 tokens. Return the amount of reinvestment tokens to burn and expected amounts of 2 tokens to receive #### Functions: `tokenURI()`, `getApproved()`, `_approve()`, `_getAndIncrementNonce()`[](https://docs.kyberswap.com/explanation/periphery-core-contracts#functions-tokenuri-getapproved-_approve-_getandincrementnonce) Overriding functions for the inherited ERC721 and permit contracts. ## AntiSnipAttackPositionManager[](https://docs.kyberswap.com/explanation/periphery-core-contracts#antisnipattackpositionmanager) Inherits **BasePositionManager** and adds the anti-sniping attack feature into **addLiquidity** and **removeLiquidity** functions. Reinvestment tokens of a position will be locked and vested to prevent LPs from adding then removing liquidity within a small period of time. The motivation, mechanism and formula for Anti-Sniping Attack can be found [here](https://docs.google.com/document/d/1F50RWQRRyaNxnW5RvKgw09fN2FofIVLVccijgcOt-Iw/edit#heading=h.trv8zmis8u4c). The [AntiSnipingAttack library](https://docs.kyberswap.com/explanation/periphery-core-contracts#AntiSnipingAttack) will be of interest as well. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.kyberswap.com/reference/legacy/kyberswap-elastic/contracts/elastic-periphery-core-contracts.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.