Feature Tip: Add private address tag to any address under My Name Tag !
More Info
Private Name Tags
ContractCreator
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block |
From
|
To
|
|||
---|---|---|---|---|---|---|
21465032 | 20 secs ago | 0.159 ETH | ||||
21465032 | 20 secs ago | 0.159 ETH | ||||
21464734 | 1 hr ago | 0.025 ETH | ||||
21464734 | 1 hr ago | 0.025 ETH | ||||
21464701 | 1 hr ago | 0.00591035 ETH | ||||
21464701 | 1 hr ago | 0.00591035 ETH | ||||
21464683 | 1 hr ago | 0.0597 ETH | ||||
21464683 | 1 hr ago | 0.0597 ETH | ||||
21464502 | 1 hr ago | 0.04482825 ETH | ||||
21464502 | 1 hr ago | 0.04482825 ETH | ||||
21464348 | 2 hrs ago | 0.0046988 ETH | ||||
21464348 | 2 hrs ago | 0.0046988 ETH | ||||
21464308 | 2 hrs ago | 0.02509027 ETH | ||||
21464308 | 2 hrs ago | 0.02509027 ETH | ||||
21464170 | 2 hrs ago | 0.01540001 ETH | ||||
21464170 | 2 hrs ago | 0.01540001 ETH | ||||
21464160 | 2 hrs ago | 0.12 ETH | ||||
21464160 | 2 hrs ago | 0.12 ETH | ||||
21464092 | 3 hrs ago | 0.194 ETH | ||||
21464092 | 3 hrs ago | 0.194 ETH | ||||
21464024 | 3 hrs ago | 0.04454817 ETH | ||||
21464024 | 3 hrs ago | 0.04454817 ETH | ||||
21463830 | 4 hrs ago | 1 ETH | ||||
21463830 | 4 hrs ago | 1 ETH | ||||
21463737 | 4 hrs ago | 0.60705039 ETH |
Loading...
Loading
Contract Name:
LiFiDEXAggregator
Compiler Version
v0.8.17+commit.8df45f5f
Optimization Enabled:
Yes with 1000000 runs
Other Settings:
london EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.17; import { SafeERC20, IERC20, IERC20Permit } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol"; address constant NATIVE_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; address constant IMPOSSIBLE_POOL_ADDRESS = 0x0000000000000000000000000000000000000001; address constant INTERNAL_INPUT_SOURCE = 0x0000000000000000000000000000000000000000; uint8 constant LOCKED = 2; uint8 constant NOT_LOCKED = 1; uint8 constant PAUSED = 2; uint8 constant NOT_PAUSED = 1; /// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK) uint160 constant MIN_SQRT_RATIO = 4295128739; /// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK) uint160 constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342; /// @title LiFi DEX Aggregator /// @author Ilya Lyalin (contract copied from: https://github.com/sushiswap/sushiswap/blob/c8c80dec821003eb72eb77c7e0446ddde8ca9e1e/protocols/route-processor/contracts/RouteProcessor4.sol) /// @notice Processes calldata to swap using various DEXs /// @custom:version 1.0.0 contract LiFiDEXAggregator is Ownable { using SafeERC20 for IERC20; using Approve for IERC20; using SafeERC20 for IERC20Permit; using InputStream for uint256; event Route( address indexed from, address to, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOutMin, uint256 amountOut ); error MinimalOutputBalanceViolation(uint256 amountOut); IBentoBoxMinimal public immutable bentoBox; mapping(address => bool) public priviledgedUsers; address private lastCalledPool; uint8 private unlocked = NOT_LOCKED; uint8 private paused = NOT_PAUSED; modifier lock() { require(unlocked == NOT_LOCKED, "RouteProcessor is locked"); require(paused == NOT_PAUSED, "RouteProcessor is paused"); unlocked = LOCKED; _; unlocked = NOT_LOCKED; } modifier onlyOwnerOrPriviledgedUser() { require( msg.sender == owner() || priviledgedUsers[msg.sender], "RP: caller is not the owner or a privileged user" ); _; } constructor(address _bentoBox, address[] memory priviledgedUserList) { bentoBox = IBentoBoxMinimal(_bentoBox); lastCalledPool = IMPOSSIBLE_POOL_ADDRESS; for (uint256 i = 0; i < priviledgedUserList.length; i++) { priviledgedUsers[priviledgedUserList[i]] = true; } } function setPriviledge(address user, bool priviledge) external onlyOwner { priviledgedUsers[user] = priviledge; } function pause() external onlyOwnerOrPriviledgedUser { paused = PAUSED; } function resume() external onlyOwnerOrPriviledgedUser { paused = NOT_PAUSED; } /// @notice For native unwrapping receive() external payable {} /// @notice Processes the route generated off-chain. Has a lock /// @param tokenIn Address of the input token /// @param amountIn Amount of the input token /// @param tokenOut Address of the output token /// @param amountOutMin Minimum amount of the output token /// @return amountOut Actual amount of the output token function processRoute( address tokenIn, uint256 amountIn, address tokenOut, uint256 amountOutMin, address to, bytes memory route ) external payable lock returns (uint256 amountOut) { return processRouteInternal( tokenIn, amountIn, tokenOut, amountOutMin, to, route ); } /// @notice Transfers some value to <transferValueTo> and then processes the route /// @param transferValueTo Address where the value should be transferred /// @param amountValueTransfer How much value to transfer /// @param tokenIn Address of the input token /// @param amountIn Amount of the input token /// @param tokenOut Address of the output token /// @param amountOutMin Minimum amount of the output token /// @return amountOut Actual amount of the output token function transferValueAndprocessRoute( address payable transferValueTo, uint256 amountValueTransfer, address tokenIn, uint256 amountIn, address tokenOut, uint256 amountOutMin, address to, bytes memory route ) external payable lock returns (uint256 amountOut) { (bool success, bytes memory returnBytes) = transferValueTo.call{ value: amountValueTransfer }(""); if (!success) { assembly { revert(add(32, returnBytes), mload(returnBytes)) } } return processRouteInternal( tokenIn, amountIn, tokenOut, amountOutMin, to, route ); } /// @notice Processes the route generated off-chain /// @param tokenIn Address of the input token /// @param amountIn Amount of the input token /// @param tokenOut Address of the output token /// @param amountOutMin Minimum amount of the output token /// @return amountOut Actual amount of the output token function processRouteInternal( address tokenIn, uint256 amountIn, address tokenOut, uint256 amountOutMin, address to, bytes memory route ) private returns (uint256 amountOut) { uint256 balanceInInitial = tokenIn == NATIVE_ADDRESS ? 0 : IERC20(tokenIn).balanceOf(msg.sender); uint256 balanceOutInitial = tokenOut == NATIVE_ADDRESS ? address(to).balance : IERC20(tokenOut).balanceOf(to); uint256 realAmountIn = amountIn; { uint256 step = 0; uint256 stream = InputStream.createStream(route); while (stream.isNotEmpty()) { uint8 commandCode = stream.readUint8(); if (commandCode == 1) { uint256 usedAmount = processMyERC20(stream); if (step == 0) realAmountIn = usedAmount; } else if (commandCode == 2) processUserERC20(stream, amountIn); else if (commandCode == 3) { uint256 usedAmount = processNative(stream); if (step == 0) realAmountIn = usedAmount; } else if (commandCode == 4) processOnePool(stream); else if (commandCode == 5) processInsideBento(stream); else if (commandCode == 6) applyPermit(tokenIn, stream); else revert("RouteProcessor: Unknown command code"); ++step; } } uint256 balanceInFinal = tokenIn == NATIVE_ADDRESS ? 0 : IERC20(tokenIn).balanceOf(msg.sender); require( balanceInFinal + amountIn >= balanceInInitial, "RouteProcessor: Minimal input balance violation" ); uint256 balanceOutFinal = tokenOut == NATIVE_ADDRESS ? address(to).balance : IERC20(tokenOut).balanceOf(to); if (balanceOutFinal < balanceOutInitial + amountOutMin) revert MinimalOutputBalanceViolation( balanceOutFinal - balanceOutInitial ); amountOut = balanceOutFinal - balanceOutInitial; emit Route( msg.sender, to, tokenIn, tokenOut, realAmountIn, amountOutMin, amountOut ); } /// @notice Applies ERC-2612 permit /// @param tokenIn permitted token /// @param stream Streamed program function applyPermit(address tokenIn, uint256 stream) private { uint256 value = stream.readUint(); uint256 deadline = stream.readUint(); uint8 v = stream.readUint8(); bytes32 r = stream.readBytes32(); bytes32 s = stream.readBytes32(); IERC20Permit(tokenIn).safePermit( msg.sender, address(this), value, deadline, v, r, s ); } /// @notice Processes native coin: call swap for all pools that swap from native coin /// @param stream Streamed program function processNative( uint256 stream ) private returns (uint256 amountTotal) { amountTotal = address(this).balance; distributeAndSwap(stream, address(this), NATIVE_ADDRESS, amountTotal); } /// @notice Processes ERC20 token from this contract balance: /// @notice Call swap for all pools that swap from this token /// @param stream Streamed program function processMyERC20( uint256 stream ) private returns (uint256 amountTotal) { address token = stream.readAddress(); amountTotal = IERC20(token).balanceOf(address(this)); unchecked { if (amountTotal > 0) amountTotal -= 1; // slot undrain protection } distributeAndSwap(stream, address(this), token, amountTotal); } /// @notice Processes ERC20 token from msg.sender balance: /// @notice Call swap for all pools that swap from this token /// @param stream Streamed program /// @param amountTotal Amount of tokens to take from msg.sender function processUserERC20(uint256 stream, uint256 amountTotal) private { address token = stream.readAddress(); distributeAndSwap(stream, msg.sender, token, amountTotal); } /// @notice Processes ERC20 token for cases when the token has only one output pool /// @notice In this case liquidity is already at pool balance. This is an optimization /// @notice Call swap for all pools that swap from this token /// @param stream Streamed program function processOnePool(uint256 stream) private { address token = stream.readAddress(); swap(stream, INTERNAL_INPUT_SOURCE, token, 0); } /// @notice Processes Bento tokens /// @notice Call swap for all pools that swap from this token /// @param stream Streamed program function processInsideBento(uint256 stream) private { address token = stream.readAddress(); uint256 amountTotal = bentoBox.balanceOf(token, address(this)); unchecked { if (amountTotal > 0) amountTotal -= 1; // slot undrain protection } distributeAndSwap(stream, address(this), token, amountTotal); } /// @notice Distributes amountTotal to several pools according to their shares and calls swap for each pool /// @param stream Streamed program /// @param from Where to take liquidity for swap /// @param tokenIn Input token /// @param amountTotal Total amount of tokenIn for swaps function distributeAndSwap( uint256 stream, address from, address tokenIn, uint256 amountTotal ) private { uint8 num = stream.readUint8(); unchecked { for (uint256 i = 0; i < num; ++i) { uint16 share = stream.readUint16(); uint256 amount = (amountTotal * share) / type(uint16).max /*65535*/; amountTotal -= amount; swap(stream, from, tokenIn, amount); } } } /// @notice Makes swap /// @param stream Streamed program /// @param from Where to take liquidity for swap /// @param tokenIn Input token /// @param amountIn Amount of tokenIn to take for swap function swap( uint256 stream, address from, address tokenIn, uint256 amountIn ) private { uint8 poolType = stream.readUint8(); if (poolType == 0) swapUniV2(stream, from, tokenIn, amountIn); else if (poolType == 1) swapUniV3(stream, from, tokenIn, amountIn); else if (poolType == 2) wrapNative(stream, from, tokenIn, amountIn); else if (poolType == 3) bentoBridge(stream, from, tokenIn, amountIn); else if (poolType == 4) swapTrident(stream, from, tokenIn, amountIn); else if (poolType == 5) swapCurve(stream, from, tokenIn, amountIn); else revert("RouteProcessor: Unknown pool type"); } /// @notice Wraps/unwraps native token /// @param stream [direction & fake, recipient, wrapToken?] /// @param from Where to take liquidity for swap /// @param tokenIn Input token /// @param amountIn Amount of tokenIn to take for swap function wrapNative( uint256 stream, address from, address tokenIn, uint256 amountIn ) private { uint8 directionAndFake = stream.readUint8(); address to = stream.readAddress(); if (directionAndFake & 1 == 1) { // wrap native address wrapToken = stream.readAddress(); if (directionAndFake & 2 == 0) IWETH(wrapToken).deposit{ value: amountIn }(); if (to != address(this)) IERC20(wrapToken).safeTransfer(to, amountIn); } else { // unwrap native if (directionAndFake & 2 == 0) { if (from == msg.sender) IERC20(tokenIn).safeTransferFrom( msg.sender, address(this), amountIn ); IWETH(tokenIn).withdraw(amountIn); } (bool success, ) = payable(to).call{ value: amountIn }(""); require( success, "RouteProcessor.wrapNative: Native token transfer failed" ); } } /// @notice Bridge/unbridge tokens to/from Bento /// @param stream [direction, recipient] /// @param from Where to take liquidity for swap /// @param tokenIn Input token /// @param amountIn Amount of tokenIn to take for swap function bentoBridge( uint256 stream, address from, address tokenIn, uint256 amountIn ) private { uint8 direction = stream.readUint8(); address to = stream.readAddress(); if (direction > 0) { // outside to Bento // deposit to arbitrary recipient is possible only from address(bentoBox) if (from == address(this)) IERC20(tokenIn).safeTransfer(address(bentoBox), amountIn); else if (from == msg.sender) IERC20(tokenIn).safeTransferFrom( msg.sender, address(bentoBox), amountIn ); else { // tokens already are at address(bentoBox) amountIn = IERC20(tokenIn).balanceOf(address(bentoBox)) + bentoBox.strategyData(tokenIn).balance - bentoBox.totals(tokenIn).elastic; } bentoBox.deposit(tokenIn, address(bentoBox), to, amountIn, 0); } else { // Bento to outside if (from != INTERNAL_INPUT_SOURCE) { bentoBox.transfer(tokenIn, from, address(this), amountIn); } else amountIn = bentoBox.balanceOf(tokenIn, address(this)); bentoBox.withdraw(tokenIn, address(this), to, 0, amountIn); } } /// @notice UniswapV2 pool swap /// @param stream [pool, direction, recipient, fee] /// @param from Where to take liquidity for swap /// @param tokenIn Input token /// @param amountIn Amount of tokenIn to take for swap function swapUniV2( uint256 stream, address from, address tokenIn, uint256 amountIn ) private { address pool = stream.readAddress(); uint8 direction = stream.readUint8(); address to = stream.readAddress(); uint24 fee = stream.readUint24(); // pool fee in 1/1_000_000 if (from == address(this)) IERC20(tokenIn).safeTransfer(pool, amountIn); else if (from == msg.sender) IERC20(tokenIn).safeTransferFrom(msg.sender, pool, amountIn); (uint256 r0, uint256 r1, ) = IUniswapV2Pair(pool).getReserves(); require(r0 > 0 && r1 > 0, "Wrong pool reserves"); (uint256 reserveIn, uint256 reserveOut) = direction == 1 ? (r0, r1) : (r1, r0); amountIn = IERC20(tokenIn).balanceOf(pool) - reserveIn; // tokens already were transferred uint256 amountInWithFee = amountIn * (1_000_000 - fee); uint256 amountOut = (amountInWithFee * reserveOut) / (reserveIn * 1_000_000 + amountInWithFee); (uint256 amount0Out, uint256 amount1Out) = direction == 1 ? (uint256(0), amountOut) : (amountOut, uint256(0)); IUniswapV2Pair(pool).swap(amount0Out, amount1Out, to, new bytes(0)); } /// @notice Trident pool swap /// @param stream [pool, swapData] /// @param from Where to take liquidity for swap /// @param tokenIn Input token /// @param amountIn Amount of tokenIn to take for swap function swapTrident( uint256 stream, address from, address tokenIn, uint256 amountIn ) private { address pool = stream.readAddress(); bytes memory swapData = stream.readBytes(); if (from != INTERNAL_INPUT_SOURCE) { bentoBox.transfer(tokenIn, from, pool, amountIn); } IPool(pool).swap(swapData); } /// @notice UniswapV3 pool swap /// @param stream [pool, direction, recipient] /// @param from Where to take liquidity for swap /// @param tokenIn Input token /// @param amountIn Amount of tokenIn to take for swap function swapUniV3( uint256 stream, address from, address tokenIn, uint256 amountIn ) private { address pool = stream.readAddress(); bool zeroForOne = stream.readUint8() > 0; address recipient = stream.readAddress(); if (from == msg.sender) IERC20(tokenIn).safeTransferFrom( msg.sender, address(this), uint256(amountIn) ); lastCalledPool = pool; IUniswapV3Pool(pool).swap( recipient, zeroForOne, int256(amountIn), zeroForOne ? MIN_SQRT_RATIO + 1 : MAX_SQRT_RATIO - 1, abi.encode(tokenIn) ); require( lastCalledPool == IMPOSSIBLE_POOL_ADDRESS, "RouteProcessor.swapUniV3: unexpected" ); // Just to be sure } /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap. /// @dev In the implementation you must pay the pool tokens owed for the swap. /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory. /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped. /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token0 to the pool. /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token1 to the pool. /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call function uniswapV3SwapCallback( int256 amount0Delta, int256 amount1Delta, bytes calldata data ) public { require( msg.sender == lastCalledPool, "RouteProcessor.uniswapV3SwapCallback: call from unknown source" ); int256 amount = amount0Delta > 0 ? amount0Delta : amount1Delta; require( amount > 0, "RouteProcessor.uniswapV3SwapCallback: not positive amount" ); lastCalledPool = IMPOSSIBLE_POOL_ADDRESS; address tokenIn = abi.decode(data, (address)); IERC20(tokenIn).safeTransfer(msg.sender, uint256(amount)); } /// @notice Called to `msg.sender` after executing a swap via IAlgebraPool#swap. /// @dev In the implementation you must pay the pool tokens owed for the swap. /// The caller of this method _must_ be checked to be a AlgebraPool deployed by the canonical AlgebraFactory. /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped. /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token0 to the pool. /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token1 to the pool. /// @param data Any data passed through by the caller via the IAlgebraPoolActions#swap call function algebraSwapCallback( int256 amount0Delta, int256 amount1Delta, bytes calldata data ) external { uniswapV3SwapCallback(amount0Delta, amount1Delta, data); } /// @notice Called to `msg.sender` after executing a swap via PancakeV3Pool#swap. /// @dev In the implementation you must pay the pool tokens owed for the swap. /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token0 to the pool. /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by /// the end of the swap. If positive, the callback must send that amount of token1 to the pool. /// @param data Any data passed through by the caller via the PancakeV3Pool#swap call function pancakeV3SwapCallback( int256 amount0Delta, int256 amount1Delta, bytes calldata data ) external { uniswapV3SwapCallback(amount0Delta, amount1Delta, data); } /// @notice Curve pool swap. Legacy pools that don't return amountOut and have native coins are not supported /// @param stream [pool, poolType, fromIndex, toIndex, recipient, output token] /// @param from Where to take liquidity for swap /// @param tokenIn Input token /// @param amountIn Amount of tokenIn to take for swap function swapCurve( uint256 stream, address from, address tokenIn, uint256 amountIn ) private { address pool = stream.readAddress(); uint8 poolType = stream.readUint8(); int128 fromIndex = int8(stream.readUint8()); int128 toIndex = int8(stream.readUint8()); address to = stream.readAddress(); address tokenOut = stream.readAddress(); uint256 amountOut; if (tokenIn == NATIVE_ADDRESS) { amountOut = ICurve(pool).exchange{ value: amountIn }( fromIndex, toIndex, amountIn, 0 ); } else { if (from == msg.sender) IERC20(tokenIn).safeTransferFrom( msg.sender, address(this), amountIn ); IERC20(tokenIn).approveSafe(pool, amountIn); if (poolType == 0) amountOut = ICurve(pool).exchange( fromIndex, toIndex, amountIn, 0 ); else { uint256 balanceBefore = IERC20(tokenOut).balanceOf( address(this) ); ICurveLegacy(pool).exchange(fromIndex, toIndex, amountIn, 0); uint256 balanceAfter = IERC20(tokenOut).balanceOf( address(this) ); amountOut = balanceAfter - balanceBefore; } } if (to != address(this)) { if (tokenOut == NATIVE_ADDRESS) { (bool success, ) = payable(to).call{ value: amountOut }(""); require( success, "RouteProcessor.swapCurve: Native token transfer failed" ); } else { IERC20(tokenOut).safeTransfer(to, amountOut); } } } } /// @notice Minimal BentoBox vault interface. /// @dev `token` is aliased as `address` from `IERC20` for simplicity. interface IBentoBoxMinimal { /// @notice Balance per ERC-20 token per account in shares. function balanceOf(address, address) external view returns (uint256); /// @dev Helper function to represent an `amount` of `token` in shares. /// @param token The ERC-20 token. /// @param amount The `token` amount. /// @param roundUp If the result `share` should be rounded up. /// @return share The token amount represented in shares. function toShare( address token, uint256 amount, bool roundUp ) external view returns (uint256 share); /// @dev Helper function to represent shares back into the `token` amount. /// @param token The ERC-20 token. /// @param share The amount of shares. /// @param roundUp If the result should be rounded up. /// @return amount The share amount back into native representation. function toAmount( address token, uint256 share, bool roundUp ) external view returns (uint256 amount); /// @notice Registers this contract so that users can approve it for BentoBox. function registerProtocol() external; /// @notice Deposit an amount of `token` represented in either `amount` or `share`. /// @param token The ERC-20 token to deposit. /// @param from which account to pull the tokens. /// @param to which account to push the tokens. /// @param amount Token amount in native representation to deposit. /// @param share Token amount represented in shares to deposit. Takes precedence over `amount`. /// @return amountOut The amount deposited. /// @return shareOut The deposited amount represented in shares. function deposit( address token, address from, address to, uint256 amount, uint256 share ) external payable returns (uint256 amountOut, uint256 shareOut); /// @notice Withdraws an amount of `token` from a user account. /// @param token_ The ERC-20 token to withdraw. /// @param from which user to pull the tokens. /// @param to which user to push the tokens. /// @param amount of tokens. Either one of `amount` or `share` needs to be supplied. /// @param share Like above, but `share` takes precedence over `amount`. function withdraw( address token_, address from, address to, uint256 amount, uint256 share ) external returns (uint256 amountOut, uint256 shareOut); /// @notice Transfer shares from a user account to another one. /// @param token The ERC-20 token to transfer. /// @param from which user to pull the tokens. /// @param to which user to push the tokens. /// @param share The amount of `token` in shares. function transfer( address token, address from, address to, uint256 share ) external; /// @dev Reads the Rebase `totals`from storage for a given token function totals(address token) external view returns (Rebase memory total); function strategyData( address token ) external view returns (StrategyData memory total); /// @dev Approves users' BentoBox assets to a "master" contract. function setMasterContractApproval( address user, address masterContract, bool approved, uint8 v, bytes32 r, bytes32 s ) external; function harvest( address token, bool balance, uint256 maxChangeAmount ) external; } interface ICurve { function exchange( int128 i, int128 j, uint256 dx, uint256 min_dy ) external payable returns (uint256); } interface ICurveLegacy { function exchange( int128 i, int128 j, uint256 dx, uint256 min_dy ) external payable; } /// @notice Trident pool interface. interface IPool { /// @notice Executes a swap from one token to another. /// @dev The input tokens must've already been sent to the pool. /// @param data ABI-encoded params that the pool requires. /// @return finalAmountOut The amount of output tokens that were sent to the user. function swap( bytes calldata data ) external returns (uint256 finalAmountOut); /// @notice Executes a swap from one token to another with a callback. /// @dev This function allows borrowing the output tokens and sending the input tokens in the callback. /// @param data ABI-encoded params that the pool requires. /// @return finalAmountOut The amount of output tokens that were sent to the user. function flashSwap( bytes calldata data ) external returns (uint256 finalAmountOut); /// @notice Mints liquidity tokens. /// @param data ABI-encoded params that the pool requires. /// @return liquidity The amount of liquidity tokens that were minted for the user. function mint(bytes calldata data) external returns (uint256 liquidity); /// @notice Burns liquidity tokens. /// @dev The input LP tokens must've already been sent to the pool. /// @param data ABI-encoded params that the pool requires. /// @return withdrawnAmounts The amount of various output tokens that were sent to the user. function burn( bytes calldata data ) external returns (TokenAmount[] memory withdrawnAmounts); /// @notice Burns liquidity tokens for a single output token. /// @dev The input LP tokens must've already been sent to the pool. /// @param data ABI-encoded params that the pool requires. /// @return amountOut The amount of output tokens that were sent to the user. function burnSingle( bytes calldata data ) external returns (uint256 amountOut); /// @return A unique identifier for the pool type. function poolIdentifier() external pure returns (bytes32); /// @return An array of tokens supported by the pool. function getAssets() external view returns (address[] memory); /// @notice Simulates a trade and returns the expected output. /// @dev The pool does not need to include a trade simulator directly in itself - it can use a library. /// @param data ABI-encoded params that the pool requires. /// @return finalAmountOut The amount of output tokens that will be sent to the user if the trade is executed. function getAmountOut( bytes calldata data ) external view returns (uint256 finalAmountOut); /// @notice Simulates a trade and returns the expected output. /// @dev The pool does not need to include a trade simulator directly in itself - it can use a library. /// @param data ABI-encoded params that the pool requires. /// @return finalAmountIn The amount of input tokens that are required from the user if the trade is executed. function getAmountIn( bytes calldata data ) external view returns (uint256 finalAmountIn); /// @dev This event must be emitted on all swaps. event Swap( address indexed recipient, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut ); /// @dev This struct frames output tokens for burns. struct TokenAmount { address token; uint256 amount; } } interface ITridentCLPool { function token0() external returns (address); function token1() external returns (address); function swap( address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bool unwrapBento, bytes calldata data ) external returns (int256 amount0, int256 amount1); } interface IUniswapV2Pair { 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; 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; } interface IUniswapV3Pool { function token0() external returns (address); function token1() external returns (address); function swap( address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes calldata data ) external returns (int256 amount0, int256 amount1); } interface IWETH { function deposit() external payable; function transfer(address to, uint256 value) external returns (bool); function withdraw(uint256) external; } /** @notice Simple read stream */ library InputStream { /** @notice Creates stream from data * @param data data */ function createStream( bytes memory data ) internal pure returns (uint256 stream) { assembly { stream := mload(0x40) mstore(0x40, add(stream, 64)) mstore(stream, data) let length := mload(data) mstore(add(stream, 32), add(data, length)) } } /** @notice Checks if stream is not empty * @param stream stream */ function isNotEmpty(uint256 stream) internal pure returns (bool) { uint256 pos; uint256 finish; assembly { pos := mload(stream) finish := mload(add(stream, 32)) } return pos < finish; } /** @notice Reads uint8 from the stream * @param stream stream */ function readUint8(uint256 stream) internal pure returns (uint8 res) { assembly { let pos := mload(stream) pos := add(pos, 1) res := mload(pos) mstore(stream, pos) } } /** @notice Reads uint16 from the stream * @param stream stream */ function readUint16(uint256 stream) internal pure returns (uint16 res) { assembly { let pos := mload(stream) pos := add(pos, 2) res := mload(pos) mstore(stream, pos) } } /** @notice Reads uint24 from the stream * @param stream stream */ function readUint24(uint256 stream) internal pure returns (uint24 res) { assembly { let pos := mload(stream) pos := add(pos, 3) res := mload(pos) mstore(stream, pos) } } /** @notice Reads uint32 from the stream * @param stream stream */ function readUint32(uint256 stream) internal pure returns (uint32 res) { assembly { let pos := mload(stream) pos := add(pos, 4) res := mload(pos) mstore(stream, pos) } } /** @notice Reads uint256 from the stream * @param stream stream */ function readUint(uint256 stream) internal pure returns (uint256 res) { assembly { let pos := mload(stream) pos := add(pos, 32) res := mload(pos) mstore(stream, pos) } } /** @notice Reads bytes32 from the stream * @param stream stream */ function readBytes32(uint256 stream) internal pure returns (bytes32 res) { assembly { let pos := mload(stream) pos := add(pos, 32) res := mload(pos) mstore(stream, pos) } } /** @notice Reads address from the stream * @param stream stream */ function readAddress(uint256 stream) internal pure returns (address res) { assembly { let pos := mload(stream) pos := add(pos, 20) res := mload(pos) mstore(stream, pos) } } /** @notice Reads bytes from the stream * @param stream stream */ function readBytes( uint256 stream ) internal pure returns (bytes memory res) { assembly { let pos := mload(stream) res := add(pos, 32) let length := mload(res) mstore(stream, add(res, length)) } } } library Approve { /** * @dev ERC20 approve that correct works with token.approve which returns bool or nothing (USDT for example) * @param token The token targeted by the call. * @param spender token spender * @param amount token amount */ function approveStable( IERC20 token, address spender, uint256 amount ) internal returns (bool) { (bool success, bytes memory data) = address(token).call( abi.encodeWithSelector(token.approve.selector, spender, amount) ); return success && (data.length == 0 || abi.decode(data, (bool))); } /** * @dev ERC20 approve that correct works with token.approve which reverts if amount and * current allowance are not zero simultaniously (USDT for example). * In second case it tries to set allowance to 0, and then back to amount. * @param token The token targeted by the call. * @param spender token spender * @param amount token amount */ function approveSafe( IERC20 token, address spender, uint256 amount ) internal returns (bool) { return approveStable(token, spender, amount) || (approveStable(token, spender, 0) && approveStable(token, spender, amount)); } } struct Rebase { uint128 elastic; uint128 base; } struct StrategyData { uint64 strategyStartDate; uint64 targetPercentage; uint128 balance; // the balance of the strategy that BentoBox thinks is in there } /// @notice A rebasing library library RebaseLibrary { /// @notice Calculates the base value in relationship to `elastic` and `total`. function toBase( Rebase memory total, uint256 elastic ) internal pure returns (uint256 base) { if (total.elastic == 0) { base = elastic; } else { base = (elastic * total.base) / total.elastic; } } /// @notice Calculates the elastic value in relationship to `base` and `total`. function toElastic( Rebase memory total, uint256 base ) internal pure returns (uint256 elastic) { if (total.base == 0) { elastic = base; } else { elastic = (base * total.elastic) / total.base; } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; import "../extensions/IERC20Permit.sol"; import "../../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; /** * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } /** * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful. */ function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } /** * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 oldAllowance = token.allowance(address(this), spender); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value)); } /** * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value)); } } /** * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. Compatible with tokens that require the approval to be set to * 0 before setting it to a non-zero value. */ function forceApprove(IERC20 token, address spender, uint256 value) internal { bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value); if (!_callOptionalReturnBool(token, approvalCall)) { _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0)); _callOptionalReturn(token, approvalCall); } } /** * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`. * Revert on invalid signature. */ function safePermit( IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). * * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead. */ function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false // and not revert is the subcall reverts. (bool success, bytes memory returndata) = address(token).call(data); return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 amount) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
{ "remappings": [ "@eth-optimism/=node_modules/@hop-protocol/sdk/node_modules/@eth-optimism/", "@uniswap/=node_modules/@uniswap/", "eth-gas-reporter/=node_modules/eth-gas-reporter/", "hardhat/=node_modules/hardhat/", "hardhat-deploy/=node_modules/hardhat-deploy/", "@openzeppelin/=lib/openzeppelin-contracts/", "celer-network/=lib/sgn-v2-contracts/", "create3-factory/=lib/create3-factory/src/", "solmate/=lib/solmate/src/", "solady/=lib/solady/src/", "ds-test/=lib/ds-test/src/", "forge-std/=lib/forge-std/src/", "lifi/=src/", "test/=test/", "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/", "openzeppelin-contracts/=lib/openzeppelin-contracts/", "openzeppelin/=lib/openzeppelin-contracts/contracts/", "sgn-v2-contracts/=lib/sgn-v2-contracts/contracts/" ], "optimizer": { "enabled": true, "runs": 1000000 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs" }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "london", "viaIR": false, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_bentoBox","type":"address"},{"internalType":"address[]","name":"priviledgedUserList","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"MinimalOutputBalanceViolation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":true,"internalType":"address","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"Route","type":"event"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"algebraSwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bentoBox","outputs":[{"internalType":"contract IBentoBoxMinimal","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"pancakeV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"priviledgedUsers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"route","type":"bytes"}],"name":"processRoute","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resume","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"bool","name":"priviledge","type":"bool"}],"name":"setPriviledge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"transferValueTo","type":"address"},{"internalType":"uint256","name":"amountValueTransfer","type":"uint256"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"route","type":"bytes"}],"name":"transferValueAndprocessRoute","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000100000000000000000000000029dacdf7ccadf4ee67c923b4c22255a4b2494ed7
-----Decoded View---------------
Arg [0] : _bentoBox (address): 0x0000000000000000000000000000000000000000
Arg [1] : priviledgedUserList (address[]): 0x29DaCdF7cCaDf4eE67c923b4C22255A4B2494eD7
-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [3] : 00000000000000000000000029dacdf7ccadf4ee67c923b4c22255a4b2494ed7
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
CELO | 100.00% | $0.656216 | 0.000000000000000001 | <$0.000001 |
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.