Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x659c39cd889839e8bbf0de12939fe66605de33f356621fa009129b29c5d16743 | Deposit | (pending) | 2 days ago | IN | 0 ETH | (Pending) | |||
Deposit | 20644226 | 42 mins ago | IN | 0 ETH | 0.00018142 | ||||
Deposit | 20644045 | 1 hr ago | IN | 0 ETH | 0.00026635 | ||||
Deposit | 20643617 | 2 hrs ago | IN | 0 ETH | 0.00030214 | ||||
Deposit | 20643529 | 3 hrs ago | IN | 0 ETH | 0.00032307 | ||||
Deposit | 20643510 | 3 hrs ago | IN | 0 ETH | 0.00026794 | ||||
Deposit | 20643477 | 3 hrs ago | IN | 0 ETH | 0.00033584 | ||||
Deposit | 20643104 | 4 hrs ago | IN | 0 ETH | 0.00030584 | ||||
Deposit | 20642793 | 5 hrs ago | IN | 0 ETH | 0.0004114 | ||||
Deposit | 20642714 | 5 hrs ago | IN | 0 ETH | 0.00023752 | ||||
Deposit | 20642297 | 7 hrs ago | IN | 0 ETH | 0.00147864 | ||||
Deposit | 20641977 | 8 hrs ago | IN | 0 ETH | 0.00083533 | ||||
Deposit | 20641473 | 9 hrs ago | IN | 0 ETH | 0.00021853 | ||||
Deposit | 20641290 | 10 hrs ago | IN | 0 ETH | 0.00031017 | ||||
Deposit | 20641257 | 10 hrs ago | IN | 0 ETH | 0.00034675 | ||||
Deposit | 20641246 | 10 hrs ago | IN | 0 ETH | 0.00023261 | ||||
Deposit | 20641232 | 10 hrs ago | IN | 0 ETH | 0.00023261 | ||||
Deposit | 20641208 | 10 hrs ago | IN | 0 ETH | 0.00030154 | ||||
Deposit | 20640906 | 11 hrs ago | IN | 0 ETH | 0.00021324 | ||||
Deposit | 20640768 | 12 hrs ago | IN | 0 ETH | 0.00031454 | ||||
Deposit | 20640524 | 13 hrs ago | IN | 0 ETH | 0.00023991 | ||||
Deposit | 20640233 | 14 hrs ago | IN | 0 ETH | 0.00021364 | ||||
Deposit | 20640137 | 14 hrs ago | IN | 0 ETH | 0.00017042 | ||||
Deposit | 20640129 | 14 hrs ago | IN | 0 ETH | 0.00020146 | ||||
Deposit | 20640126 | 14 hrs ago | IN | 0 ETH | 0.00027138 |
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
20265589 | 52 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0x929B44db...af1b88474 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
TellerWithMultiAssetSupport
Compiler Version
v0.8.21+commit.d9974bed
Optimization Enabled:
Yes with 200 runs
Other Settings:
shanghai EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.21; import {ERC20} from "@solmate/tokens/ERC20.sol"; import {WETH} from "@solmate/tokens/WETH.sol"; import {BoringVault} from "src/base/BoringVault.sol"; import {AccountantWithRateProviders} from "src/base/Roles/AccountantWithRateProviders.sol"; import {FixedPointMathLib} from "@solmate/utils/FixedPointMathLib.sol"; import {SafeTransferLib} from "@solmate/utils/SafeTransferLib.sol"; import {BeforeTransferHook} from "src/interfaces/BeforeTransferHook.sol"; import {Auth, Authority} from "@solmate/auth/Auth.sol"; import {ReentrancyGuard} from "@solmate/utils/ReentrancyGuard.sol"; import {IPausable} from "src/interfaces/IPausable.sol"; contract TellerWithMultiAssetSupport is Auth, BeforeTransferHook, ReentrancyGuard, IPausable { using FixedPointMathLib for uint256; using SafeTransferLib for ERC20; using SafeTransferLib for WETH; // ========================================= CONSTANTS ========================================= /** * @notice Native address used to tell the contract to handle native asset deposits. */ address internal constant NATIVE = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; /** * @notice The maximum possible share lock period. */ uint256 internal constant MAX_SHARE_LOCK_PERIOD = 3 days; // ========================================= STATE ========================================= /** * @notice Mapping ERC20s to an isSupported bool. */ mapping(ERC20 => bool) public isSupported; /** * @notice The deposit nonce used to map to a deposit hash. */ uint96 public depositNonce = 1; /** * @notice After deposits, shares are locked to the msg.sender's address * for `shareLockPeriod`. * @dev During this time all trasnfers from msg.sender will revert, and * deposits are refundable. */ uint64 public shareLockPeriod; /** * @notice Used to pause calls to `deposit` and `depositWithPermit`. */ bool public isPaused; /** * @dev Maps deposit nonce to keccak256(address receiver, address depositAsset, uint256 depositAmount, uint256 shareAmount, uint256 timestamp, uint256 shareLockPeriod). */ mapping(uint256 => bytes32) public publicDepositHistory; /** * @notice Maps user address to the time their shares will be unlocked. */ mapping(address => uint256) public shareUnlockTime; /** * @notice Mapping `from` address to a bool to deny them from transferring shares. */ mapping(address => bool) public fromDenyList; /** * @notice Mapping `to` address to a bool to deny them from receiving shares. */ mapping(address => bool) public toDenyList; /** * @notice Mapping `opeartor` address to a bool to deny them from calling `transfer` or `transferFrom`. */ mapping(address => bool) public operatorDenyList; //============================== ERRORS =============================== error TellerWithMultiAssetSupport__ShareLockPeriodTooLong(); error TellerWithMultiAssetSupport__SharesAreLocked(); error TellerWithMultiAssetSupport__SharesAreUnLocked(); error TellerWithMultiAssetSupport__BadDepositHash(); error TellerWithMultiAssetSupport__AssetNotSupported(); error TellerWithMultiAssetSupport__ZeroAssets(); error TellerWithMultiAssetSupport__MinimumMintNotMet(); error TellerWithMultiAssetSupport__MinimumAssetsNotMet(); error TellerWithMultiAssetSupport__PermitFailedAndAllowanceTooLow(); error TellerWithMultiAssetSupport__ZeroShares(); error TellerWithMultiAssetSupport__DualDeposit(); error TellerWithMultiAssetSupport__Paused(); error TellerWithMultiAssetSupport__TransferDenied(address from, address to, address operator); //============================== EVENTS =============================== event Paused(); event Unpaused(); event AssetAdded(address indexed asset); event AssetRemoved(address indexed asset); event Deposit( uint256 indexed nonce, address indexed receiver, address indexed depositAsset, uint256 depositAmount, uint256 shareAmount, uint256 depositTimestamp, uint256 shareLockPeriodAtTimeOfDeposit ); event BulkDeposit(address indexed asset, uint256 depositAmount); event BulkWithdraw(address indexed asset, uint256 shareAmount); event DepositRefunded(uint256 indexed nonce, bytes32 depositHash, address indexed user); event DenyFrom(address indexed user); event DenyTo(address indexed user); event DenyOperator(address indexed user); event AllowFrom(address indexed user); event AllowTo(address indexed user); event AllowOperator(address indexed user); //============================== IMMUTABLES =============================== /** * @notice The BoringVault this contract is working with. */ BoringVault public immutable vault; /** * @notice The AccountantWithRateProviders this contract is working with. */ AccountantWithRateProviders public immutable accountant; /** * @notice One share of the BoringVault. */ uint256 internal immutable ONE_SHARE; /** * @notice The native wrapper contract. */ WETH public immutable nativeWrapper; constructor(address _owner, address _vault, address _accountant, address _weth) Auth(_owner, Authority(address(0))) { vault = BoringVault(payable(_vault)); ONE_SHARE = 10 ** vault.decimals(); accountant = AccountantWithRateProviders(_accountant); nativeWrapper = WETH(payable(_weth)); } // ========================================= ADMIN FUNCTIONS ========================================= /** * @notice Pause this contract, which prevents future calls to `deposit` and `depositWithPermit`. * @dev Callable by MULTISIG_ROLE. */ function pause() external requiresAuth { isPaused = true; emit Paused(); } /** * @notice Unpause this contract, which allows future calls to `deposit` and `depositWithPermit`. * @dev Callable by MULTISIG_ROLE. */ function unpause() external requiresAuth { isPaused = false; emit Unpaused(); } /** * @notice Adds this asset as a deposit asset. * @dev The accountant must also support pricing this asset, else the `deposit` call will revert. * @dev Callable by OWNER_ROLE. */ function addAsset(ERC20 asset) external requiresAuth { isSupported[asset] = true; emit AssetAdded(address(asset)); } /** * @notice Removes this asset as a deposit asset. * @dev Callable by OWNER_ROLE. */ function removeAsset(ERC20 asset) external requiresAuth { isSupported[asset] = false; emit AssetRemoved(address(asset)); } /** * @notice Sets the share lock period. * @dev This not only locks shares to the user address, but also serves as the pending deposit period, where deposits can be reverted. * @dev If a new shorter share lock period is set, users with pending share locks could make a new deposit to receive 1 wei shares, * and have their shares unlock sooner than their original deposit allows. This state would allow for the user deposit to be refunded, * but only if they have not transferred their shares out of there wallet. This is an accepted limitation, and should be known when decreasing * the share lock period. * @dev Callable by OWNER_ROLE. */ function setShareLockPeriod(uint64 _shareLockPeriod) external requiresAuth { if (_shareLockPeriod > MAX_SHARE_LOCK_PERIOD) revert TellerWithMultiAssetSupport__ShareLockPeriodTooLong(); shareLockPeriod = _shareLockPeriod; } /** * @notice Deny a user from transferring or receiving shares. * @dev Callable by OWNER_ROLE, and DENIER_ROLE. */ function denyAll(address user) external requiresAuth { fromDenyList[user] = true; toDenyList[user] = true; operatorDenyList[user] = true; emit DenyFrom(user); emit DenyTo(user); emit DenyOperator(user); } /** * @notice Allow a user to transfer or receive shares. * @dev Callable by OWNER_ROLE, and DENIER_ROLE. */ function allowAll(address user) external requiresAuth { fromDenyList[user] = false; toDenyList[user] = false; operatorDenyList[user] = false; emit AllowFrom(user); emit AllowTo(user); emit AllowOperator(user); } /** * @notice Deny a user from transferring shares. * @dev Callable by OWNER_ROLE, and DENIER_ROLE. */ function denyFrom(address user) external requiresAuth { fromDenyList[user] = true; emit DenyFrom(user); } /** * @notice Allow a user to transfer shares. * @dev Callable by OWNER_ROLE, and DENIER_ROLE. */ function allowFrom(address user) external requiresAuth { fromDenyList[user] = false; emit AllowFrom(user); } /** * @notice Deny a user from receiving shares. * @dev Callable by OWNER_ROLE, and DENIER_ROLE. */ function denyTo(address user) external requiresAuth { toDenyList[user] = true; emit DenyTo(user); } /** * @notice Allow a user to receive shares. * @dev Callable by OWNER_ROLE, and DENIER_ROLE. */ function allowTo(address user) external requiresAuth { toDenyList[user] = false; emit AllowTo(user); } /** * @notice Deny an operator from transferring shares. * @dev Callable by OWNER_ROLE, and DENIER_ROLE. */ function denyOperator(address user) external requiresAuth { operatorDenyList[user] = true; emit DenyOperator(user); } /** * @notice Allow an operator to transfer shares. * @dev Callable by OWNER_ROLE, and DENIER_ROLE. */ function allowOperator(address user) external requiresAuth { operatorDenyList[user] = false; emit AllowOperator(user); } // ========================================= BeforeTransferHook FUNCTIONS ========================================= /** * @notice Implement beforeTransfer hook to check if shares are locked, or if `from`, `to`, or `operator` are on the deny list. */ function beforeTransfer(address from, address to, address operator) public view virtual { if (fromDenyList[from] || toDenyList[to] || operatorDenyList[operator]) { revert TellerWithMultiAssetSupport__TransferDenied(from, to, operator); } if (shareUnlockTime[from] >= block.timestamp) revert TellerWithMultiAssetSupport__SharesAreLocked(); } // ========================================= REVERT DEPOSIT FUNCTIONS ========================================= /** * @notice Allows DEPOSIT_REFUNDER_ROLE to revert a pending deposit. * @dev Once a deposit share lock period has passed, it can no longer be reverted. * @dev It is possible the admin does not setup the BoringVault to call the transfer hook, * but this contract can still be saving share lock state. In the event this happens * deposits are still refundable if the user has not transferred their shares. * But there is no guarantee that the user has not transferred their shares. * @dev Callable by STRATEGIST_MULTISIG_ROLE. */ function refundDeposit( uint256 nonce, address receiver, address depositAsset, uint256 depositAmount, uint256 shareAmount, uint256 depositTimestamp, uint256 shareLockUpPeriodAtTimeOfDeposit ) external requiresAuth { if ((block.timestamp - depositTimestamp) > shareLockUpPeriodAtTimeOfDeposit) { // Shares are already unlocked, so we can not revert deposit. revert TellerWithMultiAssetSupport__SharesAreUnLocked(); } bytes32 depositHash = keccak256( abi.encode( receiver, depositAsset, depositAmount, shareAmount, depositTimestamp, shareLockUpPeriodAtTimeOfDeposit ) ); if (publicDepositHistory[nonce] != depositHash) revert TellerWithMultiAssetSupport__BadDepositHash(); // Delete hash to prevent refund gas. delete publicDepositHistory[nonce]; // If deposit used native asset, send user back wrapped native asset. depositAsset = depositAsset == NATIVE ? address(nativeWrapper) : depositAsset; // Burn shares and refund assets to receiver. vault.exit(receiver, ERC20(depositAsset), depositAmount, receiver, shareAmount); emit DepositRefunded(nonce, depositHash, receiver); } // ========================================= USER FUNCTIONS ========================================= /** * @notice Allows users to deposit into the BoringVault, if this contract is not paused. * @dev Publicly callable. */ function deposit(ERC20 depositAsset, uint256 depositAmount, uint256 minimumMint) public payable requiresAuth nonReentrant returns (uint256 shares) { if (isPaused) revert TellerWithMultiAssetSupport__Paused(); if (!isSupported[depositAsset]) revert TellerWithMultiAssetSupport__AssetNotSupported(); if (address(depositAsset) == NATIVE) { if (msg.value == 0) revert TellerWithMultiAssetSupport__ZeroAssets(); nativeWrapper.deposit{value: msg.value}(); depositAmount = msg.value; shares = depositAmount.mulDivDown(ONE_SHARE, accountant.getRateInQuoteSafe(nativeWrapper)); if (shares < minimumMint) revert TellerWithMultiAssetSupport__MinimumMintNotMet(); // `from` is address(this) since user already sent value. nativeWrapper.safeApprove(address(vault), depositAmount); vault.enter(address(this), nativeWrapper, depositAmount, msg.sender, shares); } else { if (msg.value > 0) revert TellerWithMultiAssetSupport__DualDeposit(); shares = _erc20Deposit(depositAsset, depositAmount, minimumMint, msg.sender); } _afterPublicDeposit(msg.sender, depositAsset, depositAmount, shares, shareLockPeriod); } /** * @notice Allows users to deposit into BoringVault using permit. * @dev Publicly callable. */ function depositWithPermit( ERC20 depositAsset, uint256 depositAmount, uint256 minimumMint, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public requiresAuth nonReentrant returns (uint256 shares) { if (isPaused) revert TellerWithMultiAssetSupport__Paused(); if (!isSupported[depositAsset]) revert TellerWithMultiAssetSupport__AssetNotSupported(); try depositAsset.permit(msg.sender, address(vault), depositAmount, deadline, v, r, s) {} catch { if (depositAsset.allowance(msg.sender, address(vault)) < depositAmount) { revert TellerWithMultiAssetSupport__PermitFailedAndAllowanceTooLow(); } } shares = _erc20Deposit(depositAsset, depositAmount, minimumMint, msg.sender); _afterPublicDeposit(msg.sender, depositAsset, depositAmount, shares, shareLockPeriod); } /** * @notice Allows on ramp role to deposit into this contract. * @dev Does NOT support native deposits. * @dev Callable by SOLVER_ROLE. */ function bulkDeposit(ERC20 depositAsset, uint256 depositAmount, uint256 minimumMint, address to) external requiresAuth nonReentrant returns (uint256 shares) { if (!isSupported[depositAsset]) revert TellerWithMultiAssetSupport__AssetNotSupported(); shares = _erc20Deposit(depositAsset, depositAmount, minimumMint, to); emit BulkDeposit(address(depositAsset), depositAmount); } /** * @notice Allows off ramp role to withdraw from this contract. * @dev Callable by SOLVER_ROLE. */ function bulkWithdraw(ERC20 withdrawAsset, uint256 shareAmount, uint256 minimumAssets, address to) external requiresAuth returns (uint256 assetsOut) { if (!isSupported[withdrawAsset]) revert TellerWithMultiAssetSupport__AssetNotSupported(); if (shareAmount == 0) revert TellerWithMultiAssetSupport__ZeroShares(); assetsOut = shareAmount.mulDivDown(accountant.getRateInQuoteSafe(withdrawAsset), ONE_SHARE); if (assetsOut < minimumAssets) revert TellerWithMultiAssetSupport__MinimumAssetsNotMet(); vault.exit(to, withdrawAsset, assetsOut, msg.sender, shareAmount); emit BulkWithdraw(address(withdrawAsset), shareAmount); } // ========================================= INTERNAL HELPER FUNCTIONS ========================================= /** * @notice Implements a common ERC20 deposit into BoringVault. */ function _erc20Deposit(ERC20 depositAsset, uint256 depositAmount, uint256 minimumMint, address to) internal returns (uint256 shares) { if (depositAmount == 0) revert TellerWithMultiAssetSupport__ZeroAssets(); shares = depositAmount.mulDivDown(ONE_SHARE, accountant.getRateInQuoteSafe(depositAsset)); if (shares < minimumMint) revert TellerWithMultiAssetSupport__MinimumMintNotMet(); vault.enter(msg.sender, depositAsset, depositAmount, to, shares); } /** * @notice Handle share lock logic, and event. */ function _afterPublicDeposit( address user, ERC20 depositAsset, uint256 depositAmount, uint256 shares, uint256 currentShareLockPeriod ) internal { shareUnlockTime[user] = block.timestamp + currentShareLockPeriod; uint256 nonce = depositNonce; publicDepositHistory[nonce] = keccak256(abi.encode(user, depositAsset, depositAmount, shares, block.timestamp, currentShareLockPeriod)); depositNonce++; emit Deposit(nonce, user, address(depositAsset), depositAmount, shares, block.timestamp, currentShareLockPeriod); } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Modern and gas efficient ERC20 + EIP-2612 implementation. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol) /// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol) /// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it. abstract contract ERC20 { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event Transfer(address indexed from, address indexed to, uint256 amount); event Approval(address indexed owner, address indexed spender, uint256 amount); /*////////////////////////////////////////////////////////////// METADATA STORAGE //////////////////////////////////////////////////////////////*/ string public name; string public symbol; uint8 public immutable decimals; /*////////////////////////////////////////////////////////////// ERC20 STORAGE //////////////////////////////////////////////////////////////*/ uint256 public totalSupply; mapping(address => uint256) public balanceOf; mapping(address => mapping(address => uint256)) public allowance; /*////////////////////////////////////////////////////////////// EIP-2612 STORAGE //////////////////////////////////////////////////////////////*/ uint256 internal immutable INITIAL_CHAIN_ID; bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR; mapping(address => uint256) public nonces; /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ constructor( string memory _name, string memory _symbol, uint8 _decimals ) { name = _name; symbol = _symbol; decimals = _decimals; INITIAL_CHAIN_ID = block.chainid; INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator(); } /*////////////////////////////////////////////////////////////// ERC20 LOGIC //////////////////////////////////////////////////////////////*/ function approve(address spender, uint256 amount) public virtual returns (bool) { allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function transfer(address to, uint256 amount) public virtual returns (bool) { balanceOf[msg.sender] -= amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(msg.sender, to, amount); return true; } function transferFrom( address from, address to, uint256 amount ) public virtual returns (bool) { uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals. if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount; balanceOf[from] -= amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(from, to, amount); return true; } /*////////////////////////////////////////////////////////////// EIP-2612 LOGIC //////////////////////////////////////////////////////////////*/ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual { require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED"); // Unchecked because the only math done is incrementing // the owner's nonce which cannot realistically overflow. unchecked { address recoveredAddress = ecrecover( keccak256( abi.encodePacked( "\x19\x01", DOMAIN_SEPARATOR(), keccak256( abi.encode( keccak256( "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)" ), owner, spender, value, nonces[owner]++, deadline ) ) ) ), v, r, s ); require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER"); allowance[recoveredAddress][spender] = value; } emit Approval(owner, spender, value); } function DOMAIN_SEPARATOR() public view virtual returns (bytes32) { return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator(); } function computeDomainSeparator() internal view virtual returns (bytes32) { return keccak256( abi.encode( keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), keccak256(bytes(name)), keccak256("1"), block.chainid, address(this) ) ); } /*////////////////////////////////////////////////////////////// INTERNAL MINT/BURN LOGIC //////////////////////////////////////////////////////////////*/ function _mint(address to, uint256 amount) internal virtual { totalSupply += amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(address(0), to, amount); } function _burn(address from, uint256 amount) internal virtual { balanceOf[from] -= amount; // Cannot underflow because a user's balance // will never be larger than the total supply. unchecked { totalSupply -= amount; } emit Transfer(from, address(0), amount); } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; import {ERC20} from "./ERC20.sol"; import {SafeTransferLib} from "../utils/SafeTransferLib.sol"; /// @notice Minimalist and modern Wrapped Ether implementation. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/WETH.sol) /// @author Inspired by WETH9 (https://github.com/dapphub/ds-weth/blob/master/src/weth9.sol) contract WETH is ERC20("Wrapped Ether", "WETH", 18) { using SafeTransferLib for address; event Deposit(address indexed from, uint256 amount); event Withdrawal(address indexed to, uint256 amount); function deposit() public payable virtual { _mint(msg.sender, msg.value); emit Deposit(msg.sender, msg.value); } function withdraw(uint256 amount) public virtual { _burn(msg.sender, amount); emit Withdrawal(msg.sender, amount); msg.sender.safeTransferETH(amount); } receive() external payable virtual { deposit(); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.21; import {Address} from "@openzeppelin/contracts/utils/Address.sol"; import {ERC721Holder} from "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol"; import {ERC1155Holder} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol"; import {FixedPointMathLib} from "@solmate/utils/FixedPointMathLib.sol"; import {SafeTransferLib} from "@solmate/utils/SafeTransferLib.sol"; import {ERC20} from "@solmate/tokens/ERC20.sol"; import {BeforeTransferHook} from "src/interfaces/BeforeTransferHook.sol"; import {Auth, Authority} from "@solmate/auth/Auth.sol"; contract BoringVault is ERC20, Auth, ERC721Holder, ERC1155Holder { using Address for address; using SafeTransferLib for ERC20; using FixedPointMathLib for uint256; // ========================================= STATE ========================================= /** * @notice Contract responsbile for implementing `beforeTransfer`. */ BeforeTransferHook public hook; //============================== EVENTS =============================== event Enter(address indexed from, address indexed asset, uint256 amount, address indexed to, uint256 shares); event Exit(address indexed to, address indexed asset, uint256 amount, address indexed from, uint256 shares); //============================== CONSTRUCTOR =============================== constructor(address _owner, string memory _name, string memory _symbol, uint8 _decimals) ERC20(_name, _symbol, _decimals) Auth(_owner, Authority(address(0))) {} //============================== MANAGE =============================== /** * @notice Allows manager to make an arbitrary function call from this contract. * @dev Callable by MANAGER_ROLE. */ function manage(address target, bytes calldata data, uint256 value) external requiresAuth returns (bytes memory result) { result = target.functionCallWithValue(data, value); } /** * @notice Allows manager to make arbitrary function calls from this contract. * @dev Callable by MANAGER_ROLE. */ function manage(address[] calldata targets, bytes[] calldata data, uint256[] calldata values) external requiresAuth returns (bytes[] memory results) { uint256 targetsLength = targets.length; results = new bytes[](targetsLength); for (uint256 i; i < targetsLength; ++i) { results[i] = targets[i].functionCallWithValue(data[i], values[i]); } } //============================== ENTER =============================== /** * @notice Allows minter to mint shares, in exchange for assets. * @dev If assetAmount is zero, no assets are transferred in. * @dev Callable by MINTER_ROLE. */ function enter(address from, ERC20 asset, uint256 assetAmount, address to, uint256 shareAmount) external requiresAuth { // Transfer assets in if (assetAmount > 0) asset.safeTransferFrom(from, address(this), assetAmount); // Mint shares. _mint(to, shareAmount); emit Enter(from, address(asset), assetAmount, to, shareAmount); } //============================== EXIT =============================== /** * @notice Allows burner to burn shares, in exchange for assets. * @dev If assetAmount is zero, no assets are transferred out. * @dev Callable by BURNER_ROLE. */ function exit(address to, ERC20 asset, uint256 assetAmount, address from, uint256 shareAmount) external requiresAuth { // Burn shares. _burn(from, shareAmount); // Transfer assets out. if (assetAmount > 0) asset.safeTransfer(to, assetAmount); emit Exit(to, address(asset), assetAmount, from, shareAmount); } //============================== BEFORE TRANSFER HOOK =============================== /** * @notice Sets the share locker. * @notice If set to zero address, the share locker logic is disabled. * @dev Callable by OWNER_ROLE. */ function setBeforeTransferHook(address _hook) external requiresAuth { hook = BeforeTransferHook(_hook); } /** * @notice Call `beforeTransferHook` passing in `from` `to`, and `msg.sender`. */ function _callBeforeTransfer(address from, address to) internal view { if (address(hook) != address(0)) hook.beforeTransfer(from, to, msg.sender); } function transfer(address to, uint256 amount) public override returns (bool) { _callBeforeTransfer(msg.sender, to); return super.transfer(to, amount); } function transferFrom(address from, address to, uint256 amount) public override returns (bool) { _callBeforeTransfer(from, to); return super.transferFrom(from, to, amount); } //============================== RECEIVE =============================== receive() external payable {} }
// SPDX-License-Identifier: MIT pragma solidity 0.8.21; import {FixedPointMathLib} from "@solmate/utils/FixedPointMathLib.sol"; import {IRateProvider} from "src/interfaces/IRateProvider.sol"; import {ERC20} from "@solmate/tokens/ERC20.sol"; import {SafeTransferLib} from "@solmate/utils/SafeTransferLib.sol"; import {BoringVault} from "src/base/BoringVault.sol"; import {Auth, Authority} from "@solmate/auth/Auth.sol"; import {IPausable} from "src/interfaces/IPausable.sol"; contract AccountantWithRateProviders is Auth, IRateProvider, IPausable { using FixedPointMathLib for uint256; using SafeTransferLib for ERC20; // ========================================= STRUCTS ========================================= /** * @param payoutAddress the address `claimFees` sends fees to * @param highwaterMark the highest value of the BoringVault's share price * @param feesOwedInBase total pending fees owed in terms of base * @param totalSharesLastUpdate total amount of shares the last exchange rate update * @param exchangeRate the current exchange rate in terms of base * @param allowedExchangeRateChangeUpper the max allowed change to exchange rate from an update * @param allowedExchangeRateChangeLower the min allowed change to exchange rate from an update * @param lastUpdateTimestamp the block timestamp of the last exchange rate update * @param isPaused whether or not this contract is paused * @param minimumUpdateDelayInSeconds the minimum amount of time that must pass between * exchange rate updates, such that the update won't trigger the contract to be paused * @param managementFee the management fee * @param performanceFee the performance fee */ struct AccountantState { address payoutAddress; uint96 highwaterMark; uint128 feesOwedInBase; uint128 totalSharesLastUpdate; uint96 exchangeRate; uint16 allowedExchangeRateChangeUpper; uint16 allowedExchangeRateChangeLower; uint64 lastUpdateTimestamp; bool isPaused; uint24 minimumUpdateDelayInSeconds; uint16 managementFee; uint16 performanceFee; } /** * @param isPeggedToBase whether or not the asset is 1:1 with the base asset * @param rateProvider the rate provider for this asset if `isPeggedToBase` is false */ struct RateProviderData { bool isPeggedToBase; IRateProvider rateProvider; } // ========================================= STATE ========================================= /** * @notice Store the accountant state in 3 packed slots. */ AccountantState public accountantState; /** * @notice Maps ERC20s to their RateProviderData. */ mapping(ERC20 => RateProviderData) public rateProviderData; //============================== ERRORS =============================== error AccountantWithRateProviders__UpperBoundTooSmall(); error AccountantWithRateProviders__LowerBoundTooLarge(); error AccountantWithRateProviders__ManagementFeeTooLarge(); error AccountantWithRateProviders__PerformanceFeeTooLarge(); error AccountantWithRateProviders__Paused(); error AccountantWithRateProviders__ZeroFeesOwed(); error AccountantWithRateProviders__OnlyCallableByBoringVault(); error AccountantWithRateProviders__UpdateDelayTooLarge(); error AccountantWithRateProviders__ExchangeRateAboveHighwaterMark(); //============================== EVENTS =============================== event Paused(); event Unpaused(); event DelayInSecondsUpdated(uint24 oldDelay, uint24 newDelay); event UpperBoundUpdated(uint16 oldBound, uint16 newBound); event LowerBoundUpdated(uint16 oldBound, uint16 newBound); event ManagementFeeUpdated(uint16 oldFee, uint16 newFee); event PerformanceFeeUpdated(uint16 oldFee, uint16 newFee); event PayoutAddressUpdated(address oldPayout, address newPayout); event RateProviderUpdated(address asset, bool isPegged, address rateProvider); event ExchangeRateUpdated(uint96 oldRate, uint96 newRate, uint64 currentTime); event FeesClaimed(address indexed feeAsset, uint256 amount); event HighwaterMarkReset(); //============================== IMMUTABLES =============================== /** * @notice The base asset rates are provided in. */ ERC20 public immutable base; /** * @notice The decimals rates are provided in. */ uint8 public immutable decimals; /** * @notice The BoringVault this accountant is working with. * Used to determine share supply for fee calculation. */ BoringVault public immutable vault; /** * @notice One share of the BoringVault. */ uint256 internal immutable ONE_SHARE; constructor( address _owner, address _vault, address payoutAddress, uint96 startingExchangeRate, address _base, uint16 allowedExchangeRateChangeUpper, uint16 allowedExchangeRateChangeLower, uint24 minimumUpdateDelayInSeconds, uint16 managementFee, uint16 performanceFee ) Auth(_owner, Authority(address(0))) { base = ERC20(_base); decimals = ERC20(_base).decimals(); vault = BoringVault(payable(_vault)); ONE_SHARE = 10 ** vault.decimals(); accountantState = AccountantState({ payoutAddress: payoutAddress, highwaterMark: startingExchangeRate, feesOwedInBase: 0, totalSharesLastUpdate: uint128(vault.totalSupply()), exchangeRate: startingExchangeRate, allowedExchangeRateChangeUpper: allowedExchangeRateChangeUpper, allowedExchangeRateChangeLower: allowedExchangeRateChangeLower, lastUpdateTimestamp: uint64(block.timestamp), isPaused: false, minimumUpdateDelayInSeconds: minimumUpdateDelayInSeconds, managementFee: managementFee, performanceFee: performanceFee }); } // ========================================= ADMIN FUNCTIONS ========================================= /** * @notice Pause this contract, which prevents future calls to `updateExchangeRate`, and any safe rate * calls will revert. * @dev Callable by MULTISIG_ROLE. */ function pause() external requiresAuth { accountantState.isPaused = true; emit Paused(); } /** * @notice Unpause this contract, which allows future calls to `updateExchangeRate`, and any safe rate * calls will stop reverting. * @dev Callable by MULTISIG_ROLE. */ function unpause() external requiresAuth { accountantState.isPaused = false; emit Unpaused(); } /** * @notice Update the minimum time delay between `updateExchangeRate` calls. * @dev There are no input requirements, as it is possible the admin would want * the exchange rate updated as frequently as needed. * @dev Callable by OWNER_ROLE. */ function updateDelay(uint24 minimumUpdateDelayInSeconds) external requiresAuth { if (minimumUpdateDelayInSeconds > 14 days) revert AccountantWithRateProviders__UpdateDelayTooLarge(); uint24 oldDelay = accountantState.minimumUpdateDelayInSeconds; accountantState.minimumUpdateDelayInSeconds = minimumUpdateDelayInSeconds; emit DelayInSecondsUpdated(oldDelay, minimumUpdateDelayInSeconds); } /** * @notice Update the allowed upper bound change of exchange rate between `updateExchangeRateCalls`. * @dev Callable by OWNER_ROLE. */ function updateUpper(uint16 allowedExchangeRateChangeUpper) external requiresAuth { if (allowedExchangeRateChangeUpper < 1e4) revert AccountantWithRateProviders__UpperBoundTooSmall(); uint16 oldBound = accountantState.allowedExchangeRateChangeUpper; accountantState.allowedExchangeRateChangeUpper = allowedExchangeRateChangeUpper; emit UpperBoundUpdated(oldBound, allowedExchangeRateChangeUpper); } /** * @notice Update the allowed lower bound change of exchange rate between `updateExchangeRateCalls`. * @dev Callable by OWNER_ROLE. */ function updateLower(uint16 allowedExchangeRateChangeLower) external requiresAuth { if (allowedExchangeRateChangeLower > 1e4) revert AccountantWithRateProviders__LowerBoundTooLarge(); uint16 oldBound = accountantState.allowedExchangeRateChangeLower; accountantState.allowedExchangeRateChangeLower = allowedExchangeRateChangeLower; emit LowerBoundUpdated(oldBound, allowedExchangeRateChangeLower); } /** * @notice Update the management fee to a new value. * @dev Callable by OWNER_ROLE. */ function updateManagementFee(uint16 managementFee) external requiresAuth { if (managementFee > 0.2e4) revert AccountantWithRateProviders__ManagementFeeTooLarge(); uint16 oldFee = accountantState.managementFee; accountantState.managementFee = managementFee; emit ManagementFeeUpdated(oldFee, managementFee); } /** * @notice Update the performance fee to a new value. * @dev Callable by OWNER_ROLE. */ function updatePerformanceFee(uint16 performanceFee) external requiresAuth { if (performanceFee > 0.5e4) revert AccountantWithRateProviders__PerformanceFeeTooLarge(); uint16 oldFee = accountantState.performanceFee; accountantState.performanceFee = performanceFee; emit PerformanceFeeUpdated(oldFee, performanceFee); } /** * @notice Update the payout address fees are sent to. * @dev Callable by OWNER_ROLE. */ function updatePayoutAddress(address payoutAddress) external requiresAuth { address oldPayout = accountantState.payoutAddress; accountantState.payoutAddress = payoutAddress; emit PayoutAddressUpdated(oldPayout, payoutAddress); } /** * @notice Update the rate provider data for a specific `asset`. * @dev Rate providers must return rates in terms of `base` or * an asset pegged to base and they must use the same decimals * as `asset`. * @dev Callable by OWNER_ROLE. */ function setRateProviderData(ERC20 asset, bool isPeggedToBase, address rateProvider) external requiresAuth { rateProviderData[asset] = RateProviderData({isPeggedToBase: isPeggedToBase, rateProvider: IRateProvider(rateProvider)}); emit RateProviderUpdated(address(asset), isPeggedToBase, rateProvider); } /** * @notice Reset the highwater mark to the current exchange rate. * @dev Callable by OWNER_ROLE. */ function resetHighwaterMark() external requiresAuth { AccountantState storage state = accountantState; if (state.exchangeRate > state.highwaterMark) { revert AccountantWithRateProviders__ExchangeRateAboveHighwaterMark(); } uint64 currentTime = uint64(block.timestamp); uint256 currentTotalShares = vault.totalSupply(); _calculateFeesOwed(state, state.exchangeRate, state.exchangeRate, currentTotalShares, currentTime); state.totalSharesLastUpdate = uint128(currentTotalShares); state.highwaterMark = accountantState.exchangeRate; state.lastUpdateTimestamp = currentTime; emit HighwaterMarkReset(); } // ========================================= UPDATE EXCHANGE RATE/FEES FUNCTIONS ========================================= /** * @notice Updates this contract exchangeRate. * @dev If new exchange rate is outside of accepted bounds, or if not enough time has passed, this * will pause the contract, and this function will NOT calculate fees owed. * @dev Callable by UPDATE_EXCHANGE_RATE_ROLE. */ function updateExchangeRate(uint96 newExchangeRate) external requiresAuth { AccountantState storage state = accountantState; if (state.isPaused) revert AccountantWithRateProviders__Paused(); uint64 currentTime = uint64(block.timestamp); uint256 currentExchangeRate = state.exchangeRate; uint256 currentTotalShares = vault.totalSupply(); if ( currentTime < state.lastUpdateTimestamp + state.minimumUpdateDelayInSeconds || newExchangeRate > currentExchangeRate.mulDivDown(state.allowedExchangeRateChangeUpper, 1e4) || newExchangeRate < currentExchangeRate.mulDivDown(state.allowedExchangeRateChangeLower, 1e4) ) { // Instead of reverting, pause the contract. This way the exchange rate updater is able to update the exchange rate // to a better value, and pause it. state.isPaused = true; } else { _calculateFeesOwed(state, newExchangeRate, currentExchangeRate, currentTotalShares, currentTime); } state.exchangeRate = newExchangeRate; state.totalSharesLastUpdate = uint128(currentTotalShares); state.lastUpdateTimestamp = currentTime; emit ExchangeRateUpdated(uint96(currentExchangeRate), newExchangeRate, currentTime); } /** * @notice Claim pending fees. * @dev This function must be called by the BoringVault. * @dev This function will lose precision if the exchange rate * decimals is greater than the feeAsset's decimals. */ function claimFees(ERC20 feeAsset) external { if (msg.sender != address(vault)) revert AccountantWithRateProviders__OnlyCallableByBoringVault(); AccountantState storage state = accountantState; if (state.isPaused) revert AccountantWithRateProviders__Paused(); if (state.feesOwedInBase == 0) revert AccountantWithRateProviders__ZeroFeesOwed(); // Determine amount of fees owed in feeAsset. uint256 feesOwedInFeeAsset; RateProviderData memory data = rateProviderData[feeAsset]; if (address(feeAsset) == address(base)) { feesOwedInFeeAsset = state.feesOwedInBase; } else { uint8 feeAssetDecimals = ERC20(feeAsset).decimals(); uint256 feesOwedInBaseUsingFeeAssetDecimals = changeDecimals(state.feesOwedInBase, decimals, feeAssetDecimals); if (data.isPeggedToBase) { feesOwedInFeeAsset = feesOwedInBaseUsingFeeAssetDecimals; } else { uint256 rate = data.rateProvider.getRate(); feesOwedInFeeAsset = feesOwedInBaseUsingFeeAssetDecimals.mulDivDown(10 ** feeAssetDecimals, rate); } } // Zero out fees owed. state.feesOwedInBase = 0; // Transfer fee asset to payout address. feeAsset.safeTransferFrom(msg.sender, state.payoutAddress, feesOwedInFeeAsset); emit FeesClaimed(address(feeAsset), feesOwedInFeeAsset); } // ========================================= RATE FUNCTIONS ========================================= /** * @notice Get this BoringVault's current rate in the base. */ function getRate() public view returns (uint256 rate) { rate = accountantState.exchangeRate; } /** * @notice Get this BoringVault's current rate in the base. * @dev Revert if paused. */ function getRateSafe() external view returns (uint256 rate) { if (accountantState.isPaused) revert AccountantWithRateProviders__Paused(); rate = getRate(); } /** * @notice Get this BoringVault's current rate in the provided quote. * @dev `quote` must have its RateProviderData set, else this will revert. * @dev This function will lose precision if the exchange rate * decimals is greater than the quote's decimals. */ function getRateInQuote(ERC20 quote) public view returns (uint256 rateInQuote) { if (address(quote) == address(base)) { rateInQuote = accountantState.exchangeRate; } else { RateProviderData memory data = rateProviderData[quote]; uint8 quoteDecimals = ERC20(quote).decimals(); uint256 exchangeRateInQuoteDecimals = changeDecimals(accountantState.exchangeRate, decimals, quoteDecimals); if (data.isPeggedToBase) { rateInQuote = exchangeRateInQuoteDecimals; } else { uint256 quoteRate = data.rateProvider.getRate(); uint256 oneQuote = 10 ** quoteDecimals; rateInQuote = oneQuote.mulDivDown(exchangeRateInQuoteDecimals, quoteRate); } } } /** * @notice Get this BoringVault's current rate in the provided quote. * @dev `quote` must have its RateProviderData set, else this will revert. * @dev Revert if paused. */ function getRateInQuoteSafe(ERC20 quote) external view returns (uint256 rateInQuote) { if (accountantState.isPaused) revert AccountantWithRateProviders__Paused(); rateInQuote = getRateInQuote(quote); } // ========================================= INTERNAL HELPER FUNCTIONS ========================================= /** * @notice Used to change the decimals of precision used for an amount. */ function changeDecimals(uint256 amount, uint8 fromDecimals, uint8 toDecimals) internal pure returns (uint256) { if (fromDecimals == toDecimals) { return amount; } else if (fromDecimals < toDecimals) { return amount * 10 ** (toDecimals - fromDecimals); } else { return amount / 10 ** (fromDecimals - toDecimals); } } /** * @notice Calculate fees owed in base. * @dev This function will update the highwater mark if the new exchange rate is higher. */ function _calculateFeesOwed( AccountantState storage state, uint96 newExchangeRate, uint256 currentExchangeRate, uint256 currentTotalShares, uint64 currentTime ) internal { // Only update fees if we are not paused. // Update fee accounting. uint256 shareSupplyToUse = currentTotalShares; // Use the minimum between current total supply and total supply for last update. if (state.totalSharesLastUpdate < shareSupplyToUse) { shareSupplyToUse = state.totalSharesLastUpdate; } // Determine management fees owned. uint256 timeDelta = currentTime - state.lastUpdateTimestamp; uint256 minimumAssets = newExchangeRate > currentExchangeRate ? shareSupplyToUse.mulDivDown(currentExchangeRate, ONE_SHARE) : shareSupplyToUse.mulDivDown(newExchangeRate, ONE_SHARE); uint256 managementFeesAnnual = minimumAssets.mulDivDown(state.managementFee, 1e4); uint256 newFeesOwedInBase = managementFeesAnnual.mulDivDown(timeDelta, 365 days); // Account for performance fees. if (newExchangeRate > state.highwaterMark) { if (state.performanceFee > 0) { uint256 changeInExchangeRate = newExchangeRate - state.highwaterMark; uint256 yieldEarned = changeInExchangeRate.mulDivDown(shareSupplyToUse, ONE_SHARE); uint256 performanceFeesOwedInBase = yieldEarned.mulDivDown(state.performanceFee, 1e4); newFeesOwedInBase += performanceFeesOwedInBase; } // Always update the highwater mark if the new exchange rate is higher. // This way if we are not iniitiall taking performance fees, we can start taking them // without back charging them on past performance. state.highwaterMark = newExchangeRate; } state.feesOwedInBase += uint128(newFeesOwedInBase); } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Arithmetic library with operations for fixed-point numbers. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol) /// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol) library FixedPointMathLib { /*////////////////////////////////////////////////////////////// SIMPLIFIED FIXED POINT OPERATIONS //////////////////////////////////////////////////////////////*/ uint256 internal constant MAX_UINT256 = 2**256 - 1; uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s. function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down. } function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up. } function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down. } function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) { return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up. } /*////////////////////////////////////////////////////////////// LOW LEVEL FIXED POINT OPERATIONS //////////////////////////////////////////////////////////////*/ function mulDivDown( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y)) if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) { revert(0, 0) } // Divide x * y by the denominator. z := div(mul(x, y), denominator) } } function mulDivUp( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y)) if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) { revert(0, 0) } // If x * y modulo the denominator is strictly greater than 0, // 1 is added to round up the division of x * y by the denominator. z := add(gt(mod(mul(x, y), denominator), 0), div(mul(x, y), denominator)) } } function rpow( uint256 x, uint256 n, uint256 scalar ) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { switch x case 0 { switch n case 0 { // 0 ** 0 = 1 z := scalar } default { // 0 ** n = 0 z := 0 } } default { switch mod(n, 2) case 0 { // If n is even, store scalar in z for now. z := scalar } default { // If n is odd, store x in z for now. z := x } // Shifting right by 1 is like dividing by 2. let half := shr(1, scalar) for { // Shift n right by 1 before looping to halve it. n := shr(1, n) } n { // Shift n right by 1 each iteration to halve it. n := shr(1, n) } { // Revert immediately if x ** 2 would overflow. // Equivalent to iszero(eq(div(xx, x), x)) here. if shr(128, x) { revert(0, 0) } // Store x squared. let xx := mul(x, x) // Round to the nearest number. let xxRound := add(xx, half) // Revert if xx + half overflowed. if lt(xxRound, xx) { revert(0, 0) } // Set x to scaled xxRound. x := div(xxRound, scalar) // If n is even: if mod(n, 2) { // Compute z * x. let zx := mul(z, x) // If z * x overflowed: if iszero(eq(div(zx, x), z)) { // Revert if x is non-zero. if iszero(iszero(x)) { revert(0, 0) } } // Round to the nearest number. let zxRound := add(zx, half) // Revert if zx + half overflowed. if lt(zxRound, zx) { revert(0, 0) } // Return properly scaled zxRound. z := div(zxRound, scalar) } } } } } /*////////////////////////////////////////////////////////////// GENERAL NUMBER UTILITIES //////////////////////////////////////////////////////////////*/ function sqrt(uint256 x) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { let y := x // We start y at x, which will help us make our initial estimate. z := 181 // The "correct" value is 1, but this saves a multiplication later. // This segment is to get a reasonable initial estimate for the Babylonian method. With a bad // start, the correct # of bits increases ~linearly each iteration instead of ~quadratically. // We check y >= 2^(k + 8) but shift right by k bits // each branch to ensure that if x >= 256, then y >= 256. if iszero(lt(y, 0x10000000000000000000000000000000000)) { y := shr(128, y) z := shl(64, z) } if iszero(lt(y, 0x1000000000000000000)) { y := shr(64, y) z := shl(32, z) } if iszero(lt(y, 0x10000000000)) { y := shr(32, y) z := shl(16, z) } if iszero(lt(y, 0x1000000)) { y := shr(16, y) z := shl(8, z) } // Goal was to get z*z*y within a small factor of x. More iterations could // get y in a tighter range. Currently, we will have y in [256, 256*2^16). // We ensured y >= 256 so that the relative difference between y and y+1 is small. // That's not possible if x < 256 but we can just verify those cases exhaustively. // Now, z*z*y <= x < z*z*(y+1), and y <= 2^(16+8), and either y >= 256, or x < 256. // Correctness can be checked exhaustively for x < 256, so we assume y >= 256. // Then z*sqrt(y) is within sqrt(257)/sqrt(256) of sqrt(x), or about 20bps. // For s in the range [1/256, 256], the estimate f(s) = (181/1024) * (s+1) is in the range // (1/2.84 * sqrt(s), 2.84 * sqrt(s)), with largest error when s = 1 and when s = 256 or 1/256. // Since y is in [256, 256*2^16), let a = y/65536, so that a is in [1/256, 256). Then we can estimate // sqrt(y) using sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2^18. // There is no overflow risk here since y < 2^136 after the first branch above. z := shr(18, mul(z, add(y, 65536))) // A mul() is saved from starting z at 181. // Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough. z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) z := shr(1, add(z, div(x, z))) // If x+1 is a perfect square, the Babylonian method cycles between // floor(sqrt(x)) and ceil(sqrt(x)). This statement ensures we return floor. // See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division // Since the ceil is rare, we save gas on the assignment and repeat division in the rare case. // If you don't care whether the floor or ceil square root is returned, you can remove this statement. z := sub(z, lt(div(x, z), z)) } } function unsafeMod(uint256 x, uint256 y) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Mod x by y. Note this will return // 0 instead of reverting if y is zero. z := mod(x, y) } } function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 r) { /// @solidity memory-safe-assembly assembly { // Divide x by y. Note this will return // 0 instead of reverting if y is zero. r := div(x, y) } } function unsafeDivUp(uint256 x, uint256 y) internal pure returns (uint256 z) { /// @solidity memory-safe-assembly assembly { // Add 1 to x * y if x % y > 0. Note this will // return 0 instead of reverting if y is zero. z := add(gt(mod(x, y), 0), div(x, y)) } } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; import {ERC20} from "../tokens/ERC20.sol"; /// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol) /// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer. /// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller. library SafeTransferLib { /*////////////////////////////////////////////////////////////// ETH OPERATIONS //////////////////////////////////////////////////////////////*/ function safeTransferETH(address to, uint256 amount) internal { bool success; /// @solidity memory-safe-assembly assembly { // Transfer the ETH and store if it succeeded or not. success := call(gas(), to, amount, 0, 0, 0, 0) } require(success, "ETH_TRANSFER_FAILED"); } /*////////////////////////////////////////////////////////////// ERC20 OPERATIONS //////////////////////////////////////////////////////////////*/ function safeTransferFrom( ERC20 token, address from, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), and(from, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "from" argument. mstore(add(freeMemoryPointer, 36), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument. mstore(add(freeMemoryPointer, 68), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 100 because the length of our calldata totals up like so: 4 + 32 * 3. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 100, 0, 32) ) } require(success, "TRANSFER_FROM_FAILED"); } function safeTransfer( ERC20 token, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument. mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 68, 0, 32) ) } require(success, "TRANSFER_FAILED"); } function safeApprove( ERC20 token, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument. mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 68, 0, 32) ) } require(success, "APPROVE_FAILED"); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.21; interface BeforeTransferHook { function beforeTransfer(address from, address to, address operator) external view; }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Provides a flexible and updatable auth pattern which is completely separate from application logic. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Auth.sol) /// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol) abstract contract Auth { event OwnershipTransferred(address indexed user, address indexed newOwner); event AuthorityUpdated(address indexed user, Authority indexed newAuthority); address public owner; Authority public authority; constructor(address _owner, Authority _authority) { owner = _owner; authority = _authority; emit OwnershipTransferred(msg.sender, _owner); emit AuthorityUpdated(msg.sender, _authority); } modifier requiresAuth() virtual { require(isAuthorized(msg.sender, msg.sig), "UNAUTHORIZED"); _; } function isAuthorized(address user, bytes4 functionSig) internal view virtual returns (bool) { Authority auth = authority; // Memoizing authority saves us a warm SLOAD, around 100 gas. // Checking if the caller is the owner only after calling the authority saves gas in most cases, but be // aware that this makes protected functions uncallable even to the owner if the authority is out of order. return (address(auth) != address(0) && auth.canCall(user, address(this), functionSig)) || user == owner; } function setAuthority(Authority newAuthority) public virtual { // We check if the caller is the owner first because we want to ensure they can // always swap out the authority even if it's reverting or using up a lot of gas. require(msg.sender == owner || authority.canCall(msg.sender, address(this), msg.sig)); authority = newAuthority; emit AuthorityUpdated(msg.sender, newAuthority); } function transferOwnership(address newOwner) public virtual requiresAuth { owner = newOwner; emit OwnershipTransferred(msg.sender, newOwner); } } /// @notice A generic interface for a contract which provides authorization data to an Auth instance. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Auth.sol) /// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol) interface Authority { function canCall( address user, address target, bytes4 functionSig ) external view returns (bool); }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Gas optimized reentrancy protection for smart contracts. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol) /// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol) abstract contract ReentrancyGuard { uint256 private locked = 1; modifier nonReentrant() virtual { require(locked == 1, "REENTRANCY"); locked = 2; _; locked = 1; } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.21; interface IPausable { function pause() external; function unpause() external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol) pragma solidity ^0.8.20; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev The ETH balance of the account is not enough to perform the operation. */ error AddressInsufficientBalance(address account); /** * @dev There's no code at `target` (it is not a contract). */ error AddressEmptyCode(address target); /** * @dev A call to an address target failed. The target may have reverted. */ error FailedInnerCall(); /** * @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.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { if (address(this).balance < amount) { revert AddressInsufficientBalance(address(this)); } (bool success, ) = recipient.call{value: amount}(""); if (!success) { revert FailedInnerCall(); } } /** * @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 or custom error, it is bubbled * up by this function (like regular Solidity function calls). However, if * the call reverted with no returned reason, this function reverts with a * {FailedInnerCall} error. * * 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. */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0); } /** * @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`. */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { if (address(this).balance < value) { revert AddressInsufficientBalance(address(this)); } (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an * unsuccessful call. */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata ) internal view returns (bytes memory) { if (!success) { _revert(returndata); } else { // only check if target is a contract if the call was successful and the return data is empty // otherwise we already know that it was a contract if (returndata.length == 0 && target.code.length == 0) { revert AddressEmptyCode(target); } return returndata; } } /** * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the * revert reason or with a default {FailedInnerCall} error. */ function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) { if (!success) { _revert(returndata); } else { return returndata; } } /** * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}. */ function _revert(bytes memory returndata) 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 FailedInnerCall(); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/utils/ERC721Holder.sol) pragma solidity ^0.8.20; import {IERC721Receiver} from "../IERC721Receiver.sol"; /** * @dev Implementation of the {IERC721Receiver} interface. * * Accepts all token transfers. * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or * {IERC721-setApprovalForAll}. */ abstract contract ERC721Holder is IERC721Receiver { /** * @dev See {IERC721Receiver-onERC721Received}. * * Always returns `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) { return this.onERC721Received.selector; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/utils/ERC1155Holder.sol) pragma solidity ^0.8.20; import {IERC165, ERC165} from "../../../utils/introspection/ERC165.sol"; import {IERC1155Receiver} from "../IERC1155Receiver.sol"; /** * @dev Simple implementation of `IERC1155Receiver` that will allow a contract to hold ERC1155 tokens. * * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be * stuck. */ abstract contract ERC1155Holder is ERC165, IERC1155Receiver { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId); } function onERC1155Received( address, address, uint256, uint256, bytes memory ) public virtual override returns (bytes4) { return this.onERC1155Received.selector; } function onERC1155BatchReceived( address, address, uint256[] memory, uint256[] memory, bytes memory ) public virtual override returns (bytes4) { return this.onERC1155BatchReceived.selector; } }
// SPDX-License-Identifier: GPL-3.0-or-later // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma solidity ^0.8.0; interface IRateProvider { function getRate() external view returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.20; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be * reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol) pragma solidity ^0.8.20; import {IERC165} from "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol) pragma solidity ^0.8.20; import {IERC165} from "../../utils/introspection/IERC165.sol"; /** * @dev Interface that must be implemented by smart contracts in order to receive * ERC-1155 token transfers. */ interface IERC1155Receiver is IERC165 { /** * @dev Handles the receipt of a single ERC1155 token type. This function is * called at the end of a `safeTransferFrom` after the balance has been updated. * * NOTE: To accept the transfer, this must return * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` * (i.e. 0xf23a6e61, or its own function selector). * * @param operator The address which initiated the transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param id The ID of the token being transferred * @param value The amount of tokens being transferred * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns (bytes4); /** * @dev Handles the receipt of a multiple ERC1155 token types. This function * is called at the end of a `safeBatchTransferFrom` after the balances have * been updated. * * NOTE: To accept the transfer(s), this must return * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` * (i.e. 0xbc197c81, or its own function selector). * * @param operator The address which initiated the batch transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param ids An array containing ids of each token being transferred (order and length must match values array) * @param values An array containing amounts of each token being transferred (order and length must match ids array) * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol) pragma solidity ^0.8.20; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
{ "remappings": [ "@solmate/=lib/solmate/src/", "@forge-std/=lib/forge-std/src/", "@ds-test/=lib/forge-std/lib/ds-test/src/", "ds-test/=lib/forge-std/lib/ds-test/src/", "@openzeppelin/=lib/openzeppelin-contracts/", "@ccip/=lib/ccip/", "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/", "ccip/=lib/ccip/contracts/", "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/", "forge-std/=lib/forge-std/src/", "openzeppelin-contracts/=lib/openzeppelin-contracts/", "solmate/=lib/solmate/src/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "shanghai", "viaIR": false, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_vault","type":"address"},{"internalType":"address","name":"_accountant","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"TellerWithMultiAssetSupport__AssetNotSupported","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__BadDepositHash","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__DualDeposit","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__MinimumAssetsNotMet","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__MinimumMintNotMet","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__Paused","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__PermitFailedAndAllowanceTooLow","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__ShareLockPeriodTooLong","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__SharesAreLocked","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__SharesAreUnLocked","type":"error"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"TellerWithMultiAssetSupport__TransferDenied","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__ZeroAssets","type":"error"},{"inputs":[],"name":"TellerWithMultiAssetSupport__ZeroShares","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"AllowFrom","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"AllowOperator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"AllowTo","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"}],"name":"AssetAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"}],"name":"AssetRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"contract Authority","name":"newAuthority","type":"address"}],"name":"AuthorityUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"depositAmount","type":"uint256"}],"name":"BulkDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"shareAmount","type":"uint256"}],"name":"BulkWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"DenyFrom","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"DenyOperator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"DenyTo","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"depositAsset","type":"address"},{"indexed":false,"internalType":"uint256","name":"depositAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shareAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"depositTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shareLockPeriodAtTimeOfDeposit","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"depositHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"DepositRefunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpaused","type":"event"},{"inputs":[],"name":"accountant","outputs":[{"internalType":"contract AccountantWithRateProviders","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"}],"name":"addAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"allowAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"allowFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"allowOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"allowTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"authority","outputs":[{"internalType":"contract Authority","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"beforeTransfer","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"depositAsset","type":"address"},{"internalType":"uint256","name":"depositAmount","type":"uint256"},{"internalType":"uint256","name":"minimumMint","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"bulkDeposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"withdrawAsset","type":"address"},{"internalType":"uint256","name":"shareAmount","type":"uint256"},{"internalType":"uint256","name":"minimumAssets","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"bulkWithdraw","outputs":[{"internalType":"uint256","name":"assetsOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"denyAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"denyFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"denyOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"denyTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"depositAsset","type":"address"},{"internalType":"uint256","name":"depositAmount","type":"uint256"},{"internalType":"uint256","name":"minimumMint","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"depositNonce","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"depositAsset","type":"address"},{"internalType":"uint256","name":"depositAmount","type":"uint256"},{"internalType":"uint256","name":"minimumMint","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"depositWithPermit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"fromDenyList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"name":"isSupported","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nativeWrapper","outputs":[{"internalType":"contract WETH","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"operatorDenyList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"publicDepositHistory","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"depositAsset","type":"address"},{"internalType":"uint256","name":"depositAmount","type":"uint256"},{"internalType":"uint256","name":"shareAmount","type":"uint256"},{"internalType":"uint256","name":"depositTimestamp","type":"uint256"},{"internalType":"uint256","name":"shareLockUpPeriodAtTimeOfDeposit","type":"uint256"}],"name":"refundDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ERC20","name":"asset","type":"address"}],"name":"removeAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract Authority","name":"newAuthority","type":"address"}],"name":"setAuthority","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_shareLockPeriod","type":"uint64"}],"name":"setShareLockPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shareLockPeriod","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"shareUnlockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"toDenyList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"contract BoringVault","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
[ 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.