Overview
ETH Balance
0 ETH
Eth Value
$0.00Token Holdings
More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 14 from a total of 14 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Harvest | 17973360 | 380 days ago | IN | 0 ETH | 0.00434648 | ||||
Set Strategist | 16989139 | 518 days ago | IN | 0 ETH | 0.00073832 | ||||
Harvest | 16591434 | 574 days ago | IN | 0 ETH | 0.00541033 | ||||
Harvest | 16018384 | 654 days ago | IN | 0 ETH | 0.00238817 | ||||
Harvest | 15680861 | 701 days ago | IN | 0 ETH | 0.000765 | ||||
Harvest | 15001256 | 807 days ago | IN | 0 ETH | 0.00336022 | ||||
Harvest | 14841062 | 834 days ago | IN | 0 ETH | 0.00385943 | ||||
Harvest | 14803772 | 840 days ago | IN | 0 ETH | 0.00426836 | ||||
Harvest | 14621609 | 869 days ago | IN | 0 ETH | 0.0086261 | ||||
Harvest | 14621253 | 869 days ago | IN | 0 ETH | 0.00628006 | ||||
Harvest | 14531006 | 883 days ago | IN | 0 ETH | 0.00898124 | ||||
Harvest | 14198984 | 935 days ago | IN | 0 ETH | 0.01116235 | ||||
Harvest | 14114570 | 948 days ago | IN | 0 ETH | 0.0491942 | ||||
0x60806040 | 14038792 | 960 days ago | IN | 0 ETH | 0.39480437 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
NewStrategyAngleStakeDao
Compiler Version
v0.8.2+commit.661d1103
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.2; import "../BaseStrategy.sol"; import "../interfaces/IAngle.sol"; import "../interfaces/IMultiRewards.sol"; contract NewStrategyAngleStakeDao is BaseStrategy { address public stableMaster = 0x5adDc89785D75C86aB939E9e15bfBBb7Fc086A87; address public poolManager = 0xe9f183FC656656f1F17af1F2b0dF79b8fF9ad8eD; address public liquidityGauge = 0x51fE22abAF4a26631b2913E417c0560D547797a7; address public sanUSDC_EUR = 0x9C215206Da4bf108aE5aEEf9dA7caD3352A36Dad; address public angle = 0x31429d1856aD1377A8A0079410B297e1a9e214c2; address public gauge; constructor( address _controller, address _want, address _gauge ) BaseStrategy(_controller, _want) { gauge = _gauge; IERC20(angle).approve(_gauge, type(uint256).max); IERC20(want).approve(stableMaster, type(uint256).max); IERC20(sanUSDC_EUR).approve(liquidityGauge, type(uint256).max); } function name() external pure override returns (string memory) { return "StrategyAngleStakeDao"; } function deposit() public override { // usdc => sanUSDC_EUR uint256 wantBalance = IERC20(want).balanceOf(address(this)); IStableMaster(stableMaster).deposit(wantBalance, address(this), IPoolManager(poolManager)); uint256 sanUsdcEurBalance = IERC20(sanUSDC_EUR).balanceOf(address(this)); IERC20(sanUSDC_EUR).transfer(IController(controller).vaults(want), sanUsdcEurBalance); } function withdraw(uint256 _amount) external override onlyController { // Withdraw san LP from angle yield staking pool ILiquidityGauge(liquidityGauge).withdraw(_amount); uint256 sanLPObtained = IERC20(sanUSDC_EUR).balanceOf(address(this)); // burn san LP to obtain USDC IStableMaster(stableMaster).withdraw(sanLPObtained, address(this), address(this), IPoolManager(poolManager)); address _vault = IController(controller).vaults(address(want)); require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds uint256 usdcAmount = IERC20(want).balanceOf(address(this)); IERC20(want).transfer(_vault, usdcAmount); } function _withdrawSome(uint256 _amount) internal override { ILiquidityGauge(liquidityGauge).withdraw(_amount); } function withdrawAll() external override onlyController returns (uint256) { uint256 stakedBalance = balanceOfPool(); _withdrawSome(stakedBalance); uint256 sanLPObtained = IERC20(sanUSDC_EUR).balanceOf(address(this)); IERC20(sanUSDC_EUR).transfer(IController(controller).vaults(want), sanLPObtained); // send funds to vault IERC20(sanUSDC_EUR).approve(liquidityGauge, 0); return sanLPObtained; } function harvest() public onlyAdmin { // claim angle from angle // send to multi rewards ILiquidityGauge(liquidityGauge).claim_rewards(address(this)); uint256 angleBalance = IERC20(angle).balanceOf(address(this)); if (angleBalance > 0) { uint256 _fee = (angleBalance * performanceFee) / FEE_DENOMINATOR; IERC20(angle).transfer(IController(controller).rewards(), _fee); uint256 angleLeft = IERC20(angle).balanceOf(address(this)); IMultiRewards(gauge).notifyRewardAmount(angle, angleLeft); } } function stake() public { uint256 sanUSDC_EURBalance = IERC20(sanUSDC_EUR).balanceOf(address(this)); ILiquidityGauge(liquidityGauge).deposit(sanUSDC_EURBalance, address(this)); } function balanceOfPool() public view override returns (uint256) { return ILiquidityGauge(liquidityGauge).balanceOf(address(this)); } function setGauge(address _newGauge) external onlyAdmin { IERC20(angle).approve(gauge, 0); gauge = _newGauge; IERC20(angle).approve(_newGauge, type(uint256).max); } function setLiquidityGauge(address _newLiquidityGauge) external onlyAdmin { uint256 stakedBalance = balanceOfPool(); // withdraw all from the old staking contract _withdrawSome(stakedBalance); // sett new staking contract liquidityGauge = _newLiquidityGauge; IERC20(sanUSDC_EUR).approve(_newLiquidityGauge, type(uint256).max); // stake all into the new contract stake(); } function setPoolManager(address _newPoolManager) external onlyAdmin { poolManager = _newPoolManager; } function refreshApproves() external onlyAdmin { IERC20(angle).approve(gauge, type(uint256).max); IERC20(want).approve(stableMaster, type(uint256).max); IERC20(sanUSDC_EUR).approve(liquidityGauge, type(uint256).max); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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 `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, uint256 amount ) external returns (bool); /** * @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); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20.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; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } 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)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } 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"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } /** * @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"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (utils/Address.sol) pragma solidity ^0.8.0; /** * @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 * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; assembly { size := extcodesize(account) } return size > 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://diligence.consensys.net/posts/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.5.11/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 functionCall(target, data, "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"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(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) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(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) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason 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 { // 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 assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.2; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/utils/Address.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "./interfaces/IController.sol"; abstract contract BaseStrategy { using SafeERC20 for IERC20; using Address for address; uint256 public performanceFee = 1500; uint256 public withdrawalFee = 50; uint256 public constant FEE_DENOMINATOR = 10000; address public governance; address public controller; address public strategist; address public want; uint256 public earned; event Harvested(uint256 wantEarned, uint256 lifetimeEarned); constructor(address _controller, address _want) { governance = msg.sender; strategist = msg.sender; controller = _controller; want = _want; } modifier onlyGovernance() { require(msg.sender == governance, "!governance"); _; } modifier onlyController() { require(msg.sender == controller, "!controller"); _; } modifier onlyAdmin() { require(msg.sender == controller || msg.sender == strategist, "!admin"); _; } function clean(IERC20 _asset) external onlyGovernance returns (uint256 balance) { require(want != address(_asset), "want"); balance = _asset.balanceOf(address(this)); _asset.safeTransfer(governance, balance); } function withdraw(uint256 _amount) external virtual onlyController { uint256 _balance = IERC20(want).balanceOf(address(this)); if (_balance < _amount) { _withdrawSome(_amount - _balance); } uint256 _fee = _amount * withdrawalFee / FEE_DENOMINATOR; IERC20(want).safeTransfer(IController(controller).rewards(), _fee); address _vault = IController(controller).vaults(address(want)); require(_vault != address(0), "!vault"); IERC20(want).safeTransfer(_vault, _amount - _fee); } function withdrawAll() external virtual onlyController returns (uint256 balance) { _withdrawSome(balanceOfPool()); balance = IERC20(want).balanceOf(address(this)); address _vault = IController(controller).vaults(address(want)); require(_vault != address(0), "!vault"); IERC20(want).safeTransfer(_vault, balance); } function balanceOfWant() public view returns (uint256) { return IERC20(want).balanceOf(address(this)); } function balanceOf() public view returns (uint256) { return balanceOfWant() + balanceOfPool(); } function setWithdrawalFee(uint256 _withdrawalFee) external onlyGovernance { withdrawalFee = _withdrawalFee; } function setPerformanceFee(uint256 _performanceFee) external onlyGovernance { performanceFee = _performanceFee; } function setStrategist(address _strategist) external onlyGovernance { strategist = _strategist; } function setGovernance(address _governance) external onlyGovernance { governance = _governance; } function setController(address _controller) external onlyGovernance { controller = _controller; } /* Implemented by strategy */ function name() external pure virtual returns (string memory); function balanceOfPool() public view virtual returns (uint256); function deposit() public virtual; function _withdrawSome(uint256 _amount) internal virtual; }
// SPDX-License-Identifier: GNU GPLv3 pragma solidity >=0.8.2; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; // ====================================== IAngle.sol =============================== // This file contains the interfaces for the main contracts of Angle protocol. // Some of these contracts need to be deployed several times across the protocol with different // initializations. We only leave in the following interfaces the user-facing functions // that anyone can call without having a role. There are some view functions and some // state-changing functions. /// @notice Interface for the `PoolManager` contract handling the collateral of the protocol /// @dev There is one such contract per stablecoin/collateral pair interface IPoolManager { /// @return apr Estimated Annual Percentage Rate for SLPs based on lending to other protocols function estimatedAPR() external view returns (uint256 apr); /// @return The amount of the underlying collateral that the contract currently owns function getBalance() external view returns (uint256); /// @return The amount of collateral owned by this contract plus the amount that has been lent to strategies function getTotalAsset() external view returns (uint256); } /// @notice Interface for `StableMaster`, the contract handling all the collateral types accepted for a given stablecoin interface IStableMaster { // Struct to handle all the parameters to manage the fees // related to a given collateral pool (associated to the stablecoin) struct MintBurnData { // Values of the thresholds to compute the minting fees // depending on HA hedge (scaled by `BASE_PARAMS`) uint64[] xFeeMint; // Values of the fees at thresholds (scaled by `BASE_PARAMS`) uint64[] yFeeMint; // Values of the thresholds to compute the burning fees // depending on HA hedge (scaled by `BASE_PARAMS`) uint64[] xFeeBurn; // Values of the fees at thresholds (scaled by `BASE_PARAMS`) uint64[] yFeeBurn; // Max proportion of collateral from users that can be covered by HAs // It is exactly the same as the parameter of the same name in `PerpetualManager`, whenever one is updated // the other changes accordingly uint64 targetHAHedge; // Minting fees correction set by the `FeeManager` contract: they are going to be multiplied // to the value of the fees computed using the hedge curve // Scaled by `BASE_PARAMS` uint64 bonusMalusMint; // Burning fees correction set by the `FeeManager` contract: they are going to be multiplied // to the value of the fees computed using the hedge curve // Scaled by `BASE_PARAMS` uint64 bonusMalusBurn; // Parameter used to limit the number of stablecoins that can be issued using the concerned collateral uint256 capOnStableMinted; } // Struct to handle all the variables and parameters to handle SLPs in the protocol // including the fraction of interests they receive or the fees to be distributed to // them struct SLPData { // Last timestamp at which the `sanRate` has been updated for SLPs uint256 lastBlockUpdated; // Fees accumulated from previous blocks and to be distributed to SLPs uint256 lockedInterests; // Max interests used to update the `sanRate` in a single block // Should be in collateral token base uint256 maxInterestsDistributed; // Amount of fees left aside for SLPs and that will be distributed // when the protocol is collateralized back again uint256 feesAside; // Part of the fees normally going to SLPs that is left aside // before the protocol is collateralized back again (depends on collateral ratio) // Updated by keepers and scaled by `BASE_PARAMS` uint64 slippageFee; // Portion of the fees from users minting and burning // that goes to SLPs (the rest goes to surplus) uint64 feesForSLPs; // Slippage factor that's applied to SLPs exiting (depends on collateral ratio) // If `slippage = BASE_PARAMS`, SLPs can get nothing, if `slippage = 0` they get their full claim // Updated by keepers and scaled by `BASE_PARAMS` uint64 slippage; // Portion of the interests from lending // that goes to SLPs (the rest goes to surplus) uint64 interestsForSLPs; } struct Collateral { // Interface for the token accepted by the underlying `PoolManager` contract IERC20 token; // Reference to the `SanToken` for the pool ISanToken sanToken; // Reference to the `PerpetualManager` for the pool IPerpetualManager perpetualManager; // Adress of the oracle for the change rate between // collateral and the corresponding stablecoin IOracle oracle; // Amount of collateral in the reserves that comes from users // converted in stablecoin value. Updated at minting and burning. // A `stocksUsers` of 10 for a collateral type means that overall the balance of the collateral from users // that minted/burnt stablecoins using this collateral is worth 10 of stablecoins uint256 stocksUsers; // Exchange rate between sanToken and collateral uint256 sanRate; // Base used in the collateral implementation (ERC20 decimal) uint256 collatBase; // Parameters for SLPs and update of the `sanRate` SLPData slpData; // All the fees parameters MintBurnData feeData; } /// @notice Lets a user send collateral to the system to mint stablecoins /// @param amount Amount of collateral sent /// @param user Address of the contract or the person to give the minted tokens to /// @param poolManager Address of the `PoolManager` of the required collateral /// @param minStableAmount Minimum amount of stablecoins the user wants to get with this transaction /// @dev The `poolManager` refers to the collateral that the user wants to send /// @dev `minStableAmount` serves as a slippage protection for users function mint( uint256 amount, address user, IPoolManager poolManager, uint256 minStableAmount ) external; /// @notice Lets a user burn agTokens (stablecoins) and receive the collateral specified by the `poolManager` /// in exchange /// @param amount Amount of stable asset burnt /// @param burner Address from which the agTokens will be burnt /// @param dest Address where collateral is going to be sent /// @param poolManager Collateral type requested by the user burning /// @param minCollatAmount Minimum amount of collateral that the user wants to get with this transaction function burn( uint256 amount, address burner, address dest, IPoolManager poolManager, uint256 minCollatAmount ) external; /// @notice Lets a SLP enter the protocol by sending collateral to the system in exchange of sanTokens /// @param user Address of the SLP to send sanTokens to /// @param amount Amount of collateral sent /// @param poolManager Address of the `PoolManager` of the required collateral: the corresponding collateral /// type is the one that is going to be sent by the user function deposit( uint256 amount, address user, IPoolManager poolManager ) external; /// @notice Lets a SLP burn of sanTokens and receive the corresponding collateral back in exchange at the /// current exchange rate between sanTokens and collateral /// @param amount Amount of sanTokens burnt by the SLP /// @param burner Address that will burn its sanTokens /// @param dest Address that will receive the collateral /// @param poolManager Address of the `PoolManager` of the required collateral function withdraw( uint256 amount, address burner, address dest, IPoolManager poolManager ) external; /// @return Collateral ratio for this stablecoin function getCollateralRatio() external view returns (uint256); function collateralMap(IPoolManager poolManager) external view returns ( IERC20 token, ISanToken sanToken, IPerpetualManager perpetualManager, IOracle oracle, uint256 stocksUsers, uint256 sanRate, uint256 collatBase, SLPData memory slpData, MintBurnData memory feeData ); } /// @notice Interface for the contract managing perpetuals: there is one such contract per collateral/stablecoin /// pair in the protocol interface IPerpetualManager { /// @notice Lets a HA join the protocol and create a perpetual /// @param owner Address of the future owner of the perpetual /// @param margin Amount of collateral brought by the HA /// @param committedAmount Amount of collateral hedged by the HA /// @param maxOracleRate Maximum oracle value that the HA wants to see stored in the perpetual /// @param minNetMargin Minimum net margin that the HA is willing to see stored in the perpetual /// @return perpetualID The ID of the perpetual opened by this HA /// @dev The future owner of the perpetual cannot be the zero address /// @dev It is possible to open a perpetual on behalf of someone else /// @dev The `maxOracleRate` parameter serves as a protection against oracle manipulations for HAs opening perpetuals /// @dev `minNetMargin` is a protection against too big variations in the fees for HAs function openPerpetual( address owner, uint256 margin, uint256 committedAmount, uint256 maxOracleRate, uint256 minNetMargin ) external returns (uint256 perpetualID); /// @notice Lets a HA close a perpetual owned or controlled for the stablecoin/collateral pair associated /// to this `PerpetualManager` contract /// @param perpetualID ID of the perpetual to close /// @param to Address which will receive the proceeds from this perpetual /// @param minCashOutAmount Minimum net cash out amount that the HA is willing to get for closing the /// perpetual /// @dev The HA gets the current amount of her position depending on the entry oracle value /// and current oracle value minus some transaction fees computed on the committed amount /// @dev `msg.sender` should be the owner of `perpetualID` or be approved for this perpetual /// @dev If the `PoolManager` does not have enough collateral, the perpetual owner will be converted to a SLP and /// receive sanTokens /// @dev The `minCashOutAmount` serves as a protection for HAs closing their perpetuals: it protects them both /// from fees that would have become too high and from a too big decrease in oracle value function closePerpetual( uint256 perpetualID, address to, uint256 minCashOutAmount ) external; /// @notice Lets a HA increase the `margin` in a perpetual she controls for this /// stablecoin/collateral pair /// @param perpetualID ID of the perpetual to which amount should be added to `margin` /// @param amount Amount to add to the perpetual's `margin` function addToPerpetual(uint256 perpetualID, uint256 amount) external; /// @notice Lets a HA decrease the `margin` in a perpetual she controls for this /// stablecoin/collateral pair /// @param perpetualID ID of the perpetual from which collateral should be removed /// @param amount Amount to remove from the perpetual's `margin` /// @param to Address which will receive the collateral removed from this perpetual function removeFromPerpetual( uint256 perpetualID, uint256 amount, address to ) external; // =========================== External View Function ========================== /// @notice Returns the `cashOutAmount` of the perpetual owned by someone at a given oracle value /// @param perpetualID ID of the perpetual /// @param rate Oracle value /// @return The `cashOutAmount` of the perpetual /// @return Whether the position of the perpetual is now too small compared with its initial position function getCashOutAmount(uint256 perpetualID, uint256 rate) external view returns (uint256, uint256); // =========================== Reward Distribution ============================= /// @notice Allows to check the amount of reward tokens earned by a perpetual /// @param perpetualID ID of the perpetual to check /// @return The earned tokens by the perpetual that have not been claimed yet function earned(uint256 perpetualID) external view returns (uint256); /// @notice Allows a perpetual owner to withdraw rewards /// @param perpetualID ID of the perpetual which accumulated tokens /// @dev Only an approved caller can claim the rewards for the perpetual with perpetualID function getReward(uint256 perpetualID) external; // =============================== ERC721 logic ================================ /// @notice Gets the balance of an owner /// @param owner Address of the owner /// @return Balance (ie the number of perpetuals) owned by a HA function balanceOf(address owner) external view returns (uint256); /// @notice Gets the owner of the perpetual with ID perpetualID /// @param perpetualID ID of the perpetual /// @return Owner address function ownerOf(uint256 perpetualID) external view returns (address); /// @notice Approves to an address specified by `to` a perpetual specified by `perpetualID` /// @param to Address to approve the perpetual to /// @param perpetualID ID of the perpetual function approve(address to, uint256 perpetualID) external; /// @param perpetualID ID of the concerned perpetual /// @return Approved address by a perpetual owner function getApproved(uint256 perpetualID) external view returns (address); /// @notice Sets approval on all perpetuals owned by the owner to an operator /// @param operator Address to approve (or block) on all perpetuals /// @param approved Whether the sender wants to approve or block the operator function setApprovalForAll(address operator, bool approved) external; /// @param owner Owner of perpetuals /// @param operator Address to check if approved /// @return If the operator address is approved on all perpetuals by the owner function isApprovedForAll(address owner, address operator) external view returns (bool); /// @param perpetualID ID of the perpetual /// @return If the sender address is approved for the perpetualId function isApprovedOrOwner(address spender, uint256 perpetualID) external view returns (bool); /// @notice Transfers the `perpetualID` from an address to another /// @param from Source address /// @param to Destination a address /// @param perpetualID ID of the perpetual to transfer function transferFrom( address from, address to, uint256 perpetualID ) external; /// @notice Safely transfers the `perpetualID` from an address to another without data in it /// @param from Source address /// @param to Destination a address /// @param perpetualID ID of the perpetual to transfer function safeTransferFrom( address from, address to, uint256 perpetualID ) external; /// @notice Safely transfers the `perpetualID` from an address to another with data in the transfer /// @param from Source address /// @param to Destination a address /// @param perpetualID ID of the perpetual to transfer function safeTransferFrom( address from, address to, uint256 perpetualID, bytes memory _data ) external; } /// @notice Interface for the staking contract of the Angle protocol interface IStakingRewards { /// @dev Used instead of having a public variable to respect the ERC20 standard /// @return Total supply function totalSupply() external view returns (uint256); /// @param account Account to query the balance of /// @return Number of token staked by an account function balanceOf(address account) external view returns (uint256); /// @return Current timestamp if a reward is being distributed and the end of the staking /// period if staking is done function lastTimeRewardApplicable() external view returns (uint256); /// @notice Returns how much unclaimed rewards an account has /// @param account Address for which the request is made /// @return How much a given account earned rewards function earned(address account) external view returns (uint256); /// @notice Lets someone stake a given amount of `stakingTokens` /// @param amount Amount of ERC20 staking token that the `msg.sender` wants to stake function stake(uint256 amount) external; /// @notice Allows to stake on behalf of another address /// @param amount Amount to stake /// @param onBehalf Address to stake onBehalf of function stakeOnBehalf(uint256 amount, address onBehalf) external; /// @notice Lets a user withdraw a given amount of collateral from the staking contract /// @param amount Amount of the ERC20 staking token that the `msg.sender` wants to withdraw function withdraw(uint256 amount) external; /// @notice Triggers a payment of the reward earned to the msg.sender function getReward() external; /// @notice Lets the caller withdraw its staking and claim rewards function exit() external; } /// @notice Interface for agToken, that is to say Angle's stablecoins /// @dev This contract is used to create and handle the stablecoins of Angle protocol /// @dev Only the `StableMaster` contract can mint or burn agTokens /// @dev It is still possible for any address to burn its agTokens without redeeming collateral in exchange /// @dev agTokens are classical ERC-20 tokens, so it is still possible to `approve` an address, `transfer` or /// `transferFrom` the tokens interface IAgToken { /// @notice Burns `amount` of agToken on behalf of another account without redeeming collateral back /// @param account Account to burn on behalf of /// @param amount Amount to burn /// @param poolManager Reference to the `PoolManager` contract for which the `stocksUsers` will /// need to be updated /// @dev When calling this function, people should specify the `poolManager` for which they want to decrease /// the `stocksUsers`: this a way for the protocol to maintain healthy accounting variables /// @dev This function is for instance to be used by governance to burn the tokens accumulated by the `BondingCurve` /// contract function burnFromNoRedeem( address account, uint256 amount, address poolManager ) external; /// @notice Destroys `amount` token from the caller without giving collateral back /// @param amount Amount to burn /// @param poolManager Reference to the `PoolManager` contract for which the `stocksUsers` will need to be updated function burnNoRedeem(uint256 amount, address poolManager) external; } /// @notice Interface for sanTokens, these tokens are used to mark the debt the contract has to SLPs /// @dev The exchange rate between sanTokens and collateral will automatically change as interests and transaction fees accrue to SLPs /// @dev There is one `SanToken` contract per pair stablecoin/collateral /// @dev Only the `StableMaster` contract can mint or burn sanTokens /// @dev It is still possible for any address to burn its sanTokens without redeeming collateral in exchange /// @dev Like `AgTokens`, sanTokens are classical ERC-20 tokens, so it is still possible to `approve` an address, `transfer` or /// `transferFrom` the tokens interface ISanToken { /// @notice Destroys `amount` token for the caller without giving collateral back /// @param amount Amount to burn function burnNoRedeem(uint256 amount) external; } /// @notice Interface for the `Core` contract interface ICore { /// @return `_governorList` List of all the governor addresses of the protocol function governorList() external view returns (address[] memory); } /// @notice Interface for Angle's oracle contracts reading oracle rates from both UniswapV3 and Chainlink, /// from just UniswapV3 or from just Chainlink interface IOracle { /// @notice Reads one of the rates from the circuits given /// @return rate The current rate between the in-currency and out-currency /// @dev By default if the oracle involves a Uniswap price and a Chainlink price /// this function will return the Uniswap price /// @dev The rate returned is expressed with base `BASE` (and not the base of the out-currency) function read() external view returns (uint256 rate); /// @notice Read rates from the circuit of both Uniswap and Chainlink if there are both circuits /// else returns twice the same price /// @return Return all available rates (Chainlink and Uniswap) with the lowest rate returned first. /// @dev The rate returned is expressed with base `BASE` (and not the base of the out-currency) function readAll() external view returns (uint256, uint256); /// @notice Reads rates from the circuit of both Uniswap and Chainlink if there are both circuits /// and returns either the highest of both rates or the lowest /// @return rate The lower rate between Chainlink and Uniswap /// @dev If there is only one rate computed in an oracle contract, then the only rate is returned /// regardless of the value of the `lower` parameter /// @dev The rate returned is expressed with base `BASE` (and not the base of the out-currency) function readLower() external view returns (uint256 rate); /// @notice Reads rates from the circuit of both Uniswap and Chainlink if there are both circuits /// and returns either the highest of both rates or the lowest /// @return rate The upper rate between Chainlink and Uniswap /// @dev If there is only one rate computed in an oracle contract, then the only rate is returned /// regardless of the value of the `lower` parameter /// @dev The rate returned is expressed with base `BASE` (and not the base of the out-currency) function readUpper() external view returns (uint256 rate); /// @notice Converts an in-currency quote amount to out-currency using one of the rates available in the oracle /// contract /// @param quoteAmount Amount (in the input collateral) to be converted to be converted in out-currency /// @return Quote amount in out-currency from the base amount in in-currency /// @dev Like in the read function, if the oracle involves a Uniswap and a Chainlink price, this function /// will use the Uniswap price to compute the out quoteAmount /// @dev The rate returned is expressed with base `BASE` (and not the base of the out-currency) function readQuote(uint256 quoteAmount) external view returns (uint256); /// @notice Returns the lowest quote amount between Uniswap and Chainlink circuits (if possible). If the oracle /// contract only involves a single feed, then this returns the value of this feed /// @param quoteAmount Amount (in the input collateral) to be converted /// @return The lowest quote amount from the quote amount in in-currency /// @dev The rate returned is expressed with base `BASE` (and not the base of the out-currency) function readQuoteLower(uint256 quoteAmount) external view returns (uint256); } /// @notice Interface for the `BondingCurve` contract /// @dev This contract allows people to buy ANGLE governance tokens using the protocol's stablecoins /// @dev It is with high certainty not going to be distributed directly at launch interface IBondingCurve { /// @notice Lets `msg.sender` buy tokens (ANGLE tokens normally) against an allowed token (a stablecoin normally) /// @param _agToken Reference to the agToken used, that is the stablecoin used to buy the token associated to this /// bonding curve /// @param maxAmountToPayInAgToken Maximum amount to pay in agTokens that the user is willing to pay to buy the /// `targetSoldTokenQuantity` function buySoldToken( IAgToken _agToken, uint256 targetSoldTokenQuantity, uint256 maxAmountToPayInAgToken ) external; /// @dev More generally than the expression used, the value of the price is: /// `startPrice/(1-tokensSoldInTx/tokensToSellInTotal)^power` with `power = 2` /// @dev The precision of this function is not that important as it is a view function anyone can query /// @notice Returns the current price of the token (expressed in reference) function getCurrentPrice() external view returns (uint256); /// @return The quantity of governance tokens that are still to be sold function getQuantityLeftToSell() external view returns (uint256); /// @param targetQuantity Quantity of ANGLE tokens to buy /// @dev This is an utility function that can be queried before buying tokens /// @return The amount to pay for the desired amount of ANGLE to buy function computePriceFromQuantity(uint256 targetQuantity) external view returns (uint256); } /// @title ICollateralSettler /// @notice Interface for the collateral settlement contracts that are used when a collateral is getting revoked interface ICollateralSettler { /// @notice Allows a user to claim collateral for a `dest` address by sending agTokens and gov tokens (optional) /// @param dest Address of the user to claim collateral for /// @param amountAgToken Amount of agTokens sent /// @param amountGovToken Amount of governance sent /// @dev The more gov tokens a user sends, the more preferably it ends up being treated during the redeem period function claimUser( address dest, uint256 amountAgToken, uint256 amountGovToken ) external; /// @notice Allows a HA to claim collateral by sending a `perpetualID` and gov tokens (optional) /// @param perpetualID Perpetual owned by the HA /// @param amountGovToken Amount of governance sent /// @dev The contract automatically recognizes the beneficiary of the perpetual function claimHA(uint256 perpetualID, uint256 amountGovToken) external; /// @notice Allows a SLP to claim collateral for an address `dest` by sending sanTokens and gov tokens (optional) /// @param dest Address to claim collateral for /// @param amountSanToken Amount of sanTokens sent /// @param amountGovToken Amount of governance tokens sent function claimSLP( address dest, uint256 amountSanToken, uint256 amountGovToken ) external; /// @notice Computes the base amount each category of claim will get after the claim period has ended /// @dev This function can only be called once when claim period is over /// @dev It is at the level of this function that the waterfall between the different /// categories of stakeholders and of claims is executed function setAmountToRedistributeEach() external; /// @notice Lets a user or a LP redeem its corresponding share of collateral /// @param user Address of the user to redeem collateral to /// @dev This function can only be called after the `setAmountToRedistributeEach` function has been called /// @dev The entry point to redeem is the same for users, HAs and SLPs function redeemCollateral(address user) external; } interface ILiquidityGauge { function deposit(uint256 _value, address _addr) external; function withdraw(uint256 _value) external; function claim_rewards(address _addr) external; function balanceOf(address account) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.2; interface IController { function withdraw(address, uint256) external; function balanceOf(address) external view returns (uint256); function earn(address, uint256) external; function want(address) external view returns (address); function rewards() external view returns (address); function vaults(address) external view returns (address); function strategies(address) external view returns (address); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.2; interface IMultiRewards { function balanceOf(address) external returns(uint); function stakeFor(address, uint) external; function withdrawFor(address, uint) external; function notifyRewardAmount(address, uint) external; }
{ "evmVersion": "istanbul", "libraries": {}, "metadata": { "bytecodeHash": "ipfs", "useLiteralContent": true }, "optimizer": { "enabled": false, "runs": 200 }, "remappings": [], "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_controller","type":"address"},{"internalType":"address","name":"_want","type":"address"},{"internalType":"address","name":"_gauge","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"wantEarned","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lifetimeEarned","type":"uint256"}],"name":"Harvested","type":"event"},{"inputs":[],"name":"FEE_DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"angle","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfWant","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_asset","type":"address"}],"name":"clean","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gauge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"liquidityGauge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"performanceFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"refreshApproves","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sanUSDC_EUR","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_controller","type":"address"}],"name":"setController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newGauge","type":"address"}],"name":"setGauge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_governance","type":"address"}],"name":"setGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newLiquidityGauge","type":"address"}],"name":"setLiquidityGauge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceFee","type":"uint256"}],"name":"setPerformanceFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newPoolManager","type":"address"}],"name":"setPoolManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_strategist","type":"address"}],"name":"setStrategist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawalFee","type":"uint256"}],"name":"setWithdrawalFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stableMaster","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"strategist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"want","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawalFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
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)
00000000000000000000000029d3782825432255041db2eafcb7174f5273f08a000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000003c310fc54c0534dc3c45312934508722284352d1
-----Decoded View---------------
Arg [0] : _controller (address): 0x29D3782825432255041Db2EAfCB7174f5273f08A
Arg [1] : _want (address): 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
Arg [2] : _gauge (address): 0x3c310Fc54C0534dc3C45312934508722284352D1
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000029d3782825432255041db2eafcb7174f5273f08a
Arg [1] : 000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
Arg [2] : 0000000000000000000000003c310fc54c0534dc3c45312934508722284352d1
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
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.