Skip to main content

Overview

Example of interacting with Pool contracts‚Äč

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import '@sushiswap/trident/contracts/interfaces/Ipool.sol'
import '@sushiswap/bentobox/contracts/interfaces/IBentoBoxV1.sol'
import 'solmate/src/tokens/ERC20.sol'

contract SimpleSwap {
// using Optimism addresses as example
IBentoBoxV1 public constant bentobox = IBentoBoxV1(0xc35DADB65012eC5796536bD9864eD8773aBc74C4);
IPool public constant constant_product_pair = IPool(0x7086622E6Db990385B102D79CB1218947fb549a9); // ETH-USDC (0.05%)
IPool public constant stable_product_pair = IPool(0xB059CF6320B29780C39817c42aF1a032bf821D90); // USDC-USDT (0.01%)
ERC20 public constant ETH = ERC20(0x4200000000000000000000000000000000000006);
ERC20 public constant USDC = ERC20(0x7F5c764cBc14f9669B88837ca1490cCa17c31607);
ERC20 public constant USDT = ERC20(0x94b008aA00579c1307B0EF2c499aD98a8ce58e58);

error SlippageProtection();

contructor() {}

// Example swapping between tokens on a constant-product pool
function swapETHForUSDC(uint256 amount) external returns (uint256 amountOut) {
// Transfer the specified amount of ETH to BentoBox
ETH.transferFrom(msg.sender, address(bentobox), amount);

// Deposit the specified amount of ETH into BentoBox
bentobox.deposit(address(ETH), address(bentobox), address(constant_product_pair), amount, 0);

// Encode call data to make the swap
bytes memory swapData = abi.encode(address(ETH), msg.sender, true);

uint256 minOut = /* Calculate min output */ 0;

// Execute the Swap
amountOut = constant_product_pair.swap(swapData);

// Check minOut to prevent slippage (example of using 0 for minOut has no slippage protection)
if (amountOut < minOut) revert SlippageProtection();
}

// Example of swapping between tokens on a stable-product pool (same process as constant product)
function swapUSDCForUSDT(uint256 amount) external returns (uint256 amountOut) {
// Transfer the specified amount of USDC to BentoBox
USDC.transferFrom(msg.sender, address(bentobox), amount);

// Deposit the specified amount of USDC into BentoBox
bentobox.deposit(address(USDC), address(bentobox), address(stable_product_pair), amount, 0);

// Encode call data to make the swap
bytes memory swapData = abi.encode(address(USDC), msg.sender, true);

uint256 minOut = /* Calculate min output */ 0;

// Execute the Swap
amountOut = constant_product_pair.swap(swapData);

// Check minOut to prevent slippage (example of using 0 for minOut has no slippage protection)
if (amountOut < minOut) revert SlippageProtection();
}

// Example of minting an LP position or adding liquidity to an existing LP position
function mintConstantProductPool(uint256 ethAmount, uint256 usdcAmount) external returns (uint256 liquidity) {
// Transfer the specified amount of ETH & USDC to BentoBox
ETH.transferFrom(msg.sender, address(bentobox), ethAmount);
USDC.transferFrom(msg.sender, address(bentobox), usdcAmount);

// Deposit the specified amount of ETH & USDC into BentoBox
bentobox.deposit(address(ETH), address(bentobox), address(constant_product_pair), ethAmount, 0);
bentobox.deposit(address(USDC), address(bentobox), address(constant_product_pair), usdcAmount, 0);

// Encode call data to perform the mint
bytes memory mintData = abi.encode(msg.sender)

uint256 minLiquidity = /* Calculate min liquidity */ 0;

// Execute the mint
liquidity = constant_product_pair.mint(mintData);

// Check minLiquidity to prevent slippage, mints will automatically rebalance the mint
if (liquidity < minLiquidity) revert SlippageProtection();
}

// Example of burning ETH-USDC liquidity position into ETH
function burnSingleConstantProductPool(uint256 liquidity) external returns (uint256 amountOut) {
// Transfer the specified amount of constant product pool tokens to the pair contract
constant_product_pair.transferFrom(msg.sender, address(constant_product_pair), liquidity);

// Encode call data to perform the burnSingle keeping ETH
bytes memory burnSingleData = abi.encode(address(ETH), msg.sender, true);

uint256 minETHOut = /* Calculate min ETH to receive */ 0;

// Execute the burnSingle
amountOut = constant_product_pair.burnSingle(burnSingleData);

// Check minETHOut to prevent slippage
if (amountOut < minETHOut) revert SlippageProtection();
}

// Example of burning ETH-USDC liquidity into ETH & USDC
function burnConstantProductPool(uint256 liquidity) external returns (IPool.TokenAmount[] memory withdrawnAmounts) {
// Transfer the specified amount of constant product pool tokens to the pair contract
constant_product_pair.transferFrom(msg.sender, address(constant_product_pair), liquidity);

// Encode call data to perform the burn keeping ETH & USDC
bytes memory burnData = abi.encode(msg.sender, true);

uint256 minOut0 = /* Calculate min token0 out */ 0;
uint256 minOut1 = /* Calculate min token1 out */ 0;

// Execute the burn
withdrawnAmounts = constant_product_pair.burn(burnData);

// Check minOuts to prevent slippage
if (withdrawnAmounts[0].amount < minOut0) reverts SlippageProtection();
if (withdrawnAmounts[1].amount < minOut1) reverts SlippageProtection();
}
}