Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60c06040 | 16431552 | 598 days ago | IN | 0 ETH | 0.00772886 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xfE2460E9...5c14bdb43 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
ERC721OracleWrapper
Compiler Version
v0.8.10+commit.fc410830
Optimization Enabled:
Yes with 1000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.10; import {IEACAggregatorProxy} from "../interfaces/IEACAggregatorProxy.sol"; import {Errors} from "../protocol/libraries/helpers/Errors.sol"; import {IACLManager} from "../interfaces/IACLManager.sol"; import {IPoolAddressesProvider} from "../interfaces/IPoolAddressesProvider.sol"; import {INFTFloorOracle} from "./interfaces/INFTFloorOracle.sol"; contract ERC721OracleWrapper is IEACAggregatorProxy { INFTFloorOracle private oracleAddress; address private immutable asset; IPoolAddressesProvider public immutable ADDRESSES_PROVIDER; /** * @dev Only asset listing or pool admin can call functions marked by this modifier. **/ modifier onlyAssetListingOrPoolAdmins() { _onlyAssetListingOrPoolAdmins(); _; } function _onlyAssetListingOrPoolAdmins() internal view { IACLManager aclManager = IACLManager( ADDRESSES_PROVIDER.getACLManager() ); require( aclManager.isAssetListingAdmin(msg.sender) || aclManager.isPoolAdmin(msg.sender), Errors.CALLER_NOT_ASSET_LISTING_OR_POOL_ADMIN ); } constructor( address _provider, address _oracleAddress, address _asset ) { ADDRESSES_PROVIDER = IPoolAddressesProvider(_provider); oracleAddress = INFTFloorOracle(_oracleAddress); asset = _asset; } function setOracle(address _oracleAddress) external onlyAssetListingOrPoolAdmins { oracleAddress = INFTFloorOracle(_oracleAddress); } function decimals() external pure override returns (uint8) { return 18; } function latestAnswer() external view override returns (int256) { return int256(oracleAddress.getPrice(asset)); } function latestTimestamp() external view override returns (uint256) { return uint256(oracleAddress.getLastUpdateTime(asset)); } function latestRound() external pure override returns (uint256) { return 0; } function getAnswer(uint256) external view override returns (int256) { return int256(oracleAddress.getPrice(asset)); } function getTimestamp(uint256) external view override returns (uint256) { return uint256(oracleAddress.getLastUpdateTime(asset)); } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.8.10; interface IEACAggregatorProxy { function decimals() external view returns (uint8); function latestAnswer() external view returns (int256); function latestTimestamp() external view returns (uint256); function latestRound() external view returns (uint256); function getAnswer(uint256 roundId) external view returns (int256); function getTimestamp(uint256 roundId) external view returns (uint256); event AnswerUpdated( int256 indexed current, uint256 indexed roundId, uint256 timestamp ); event NewRound(uint256 indexed roundId, address indexed startedBy); }
// SPDX-License-Identifier: AGPL-3.0 pragma solidity 0.8.10; import {IPoolAddressesProvider} from "./IPoolAddressesProvider.sol"; /** * @title IACLManager * * @notice Defines the basic interface for the ACL Manager **/ interface IACLManager { /** * @notice Returns the contract address of the PoolAddressesProvider * @return The address of the PoolAddressesProvider */ function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider); /** * @notice Returns the identifier of the PoolAdmin role * @return The id of the PoolAdmin role */ function POOL_ADMIN_ROLE() external view returns (bytes32); /** * @notice Returns the identifier of the EmergencyAdmin role * @return The id of the EmergencyAdmin role */ function EMERGENCY_ADMIN_ROLE() external view returns (bytes32); /** * @notice Returns the identifier of the RiskAdmin role * @return The id of the RiskAdmin role */ function RISK_ADMIN_ROLE() external view returns (bytes32); /** * @notice Returns the identifier of the FlashBorrower role * @return The id of the FlashBorrower role */ function FLASH_BORROWER_ROLE() external view returns (bytes32); /** * @notice Returns the identifier of the Bridge role * @return The id of the Bridge role */ function BRIDGE_ROLE() external view returns (bytes32); /** * @notice Returns the identifier of the AssetListingAdmin role * @return The id of the AssetListingAdmin role */ function ASSET_LISTING_ADMIN_ROLE() external view returns (bytes32); /** * @notice Set the role as admin of a specific role. * @dev By default the admin role for all roles is `DEFAULT_ADMIN_ROLE`. * @param role The role to be managed by the admin role * @param adminRole The admin role */ function setRoleAdmin(bytes32 role, bytes32 adminRole) external; /** * @notice Adds a new admin as PoolAdmin * @param admin The address of the new admin */ function addPoolAdmin(address admin) external; /** * @notice Removes an admin as PoolAdmin * @param admin The address of the admin to remove */ function removePoolAdmin(address admin) external; /** * @notice Returns true if the address is PoolAdmin, false otherwise * @param admin The address to check * @return True if the given address is PoolAdmin, false otherwise */ function isPoolAdmin(address admin) external view returns (bool); /** * @notice Adds a new admin as EmergencyAdmin * @param admin The address of the new admin */ function addEmergencyAdmin(address admin) external; /** * @notice Removes an admin as EmergencyAdmin * @param admin The address of the admin to remove */ function removeEmergencyAdmin(address admin) external; /** * @notice Returns true if the address is EmergencyAdmin, false otherwise * @param admin The address to check * @return True if the given address is EmergencyAdmin, false otherwise */ function isEmergencyAdmin(address admin) external view returns (bool); /** * @notice Adds a new admin as RiskAdmin * @param admin The address of the new admin */ function addRiskAdmin(address admin) external; /** * @notice Removes an admin as RiskAdmin * @param admin The address of the admin to remove */ function removeRiskAdmin(address admin) external; /** * @notice Returns true if the address is RiskAdmin, false otherwise * @param admin The address to check * @return True if the given address is RiskAdmin, false otherwise */ function isRiskAdmin(address admin) external view returns (bool); /** * @notice Adds a new address as FlashBorrower * @param borrower The address of the new FlashBorrower */ function addFlashBorrower(address borrower) external; /** * @notice Removes an admin as FlashBorrower * @param borrower The address of the FlashBorrower to remove */ function removeFlashBorrower(address borrower) external; /** * @notice Returns true if the address is FlashBorrower, false otherwise * @param borrower The address to check * @return True if the given address is FlashBorrower, false otherwise */ function isFlashBorrower(address borrower) external view returns (bool); /** * @notice Adds a new address as Bridge * @param bridge The address of the new Bridge */ function addBridge(address bridge) external; /** * @notice Removes an address as Bridge * @param bridge The address of the bridge to remove */ function removeBridge(address bridge) external; /** * @notice Returns true if the address is Bridge, false otherwise * @param bridge The address to check * @return True if the given address is Bridge, false otherwise */ function isBridge(address bridge) external view returns (bool); /** * @notice Adds a new admin as AssetListingAdmin * @param admin The address of the new admin */ function addAssetListingAdmin(address admin) external; /** * @notice Removes an admin as AssetListingAdmin * @param admin The address of the admin to remove */ function removeAssetListingAdmin(address admin) external; /** * @notice Returns true if the address is AssetListingAdmin, false otherwise * @param admin The address to check * @return True if the given address is AssetListingAdmin, false otherwise */ function isAssetListingAdmin(address admin) external view returns (bool); }
// SPDX-License-Identifier: AGPL-3.0 pragma solidity 0.8.10; import {DataTypes} from "../protocol/libraries/types/DataTypes.sol"; import {IParaProxy} from "../interfaces/IParaProxy.sol"; /** * @title IPoolAddressesProvider * * @notice Defines the basic interface for a Pool Addresses Provider. **/ interface IPoolAddressesProvider { /** * @dev Emitted when the market identifier is updated. * @param oldMarketId The old id of the market * @param newMarketId The new id of the market */ event MarketIdSet(string indexed oldMarketId, string indexed newMarketId); /** * @dev Emitted when the pool is updated. * @param implementationParams The old address of the Pool * @param _init The new address to call upon upgrade * @param _calldata The calldata input for the call */ event PoolUpdated( IParaProxy.ProxyImplementation[] indexed implementationParams, address _init, bytes _calldata ); /** * @dev Emitted when the pool configurator is updated. * @param oldAddress The old address of the PoolConfigurator * @param newAddress The new address of the PoolConfigurator */ event PoolConfiguratorUpdated( address indexed oldAddress, address indexed newAddress ); /** * @dev Emitted when the WETH is updated. * @param oldAddress The old address of the WETH * @param newAddress The new address of the WETH */ event WETHUpdated(address indexed oldAddress, address indexed newAddress); /** * @dev Emitted when the price oracle is updated. * @param oldAddress The old address of the PriceOracle * @param newAddress The new address of the PriceOracle */ event PriceOracleUpdated( address indexed oldAddress, address indexed newAddress ); /** * @dev Emitted when the ACL manager is updated. * @param oldAddress The old address of the ACLManager * @param newAddress The new address of the ACLManager */ event ACLManagerUpdated( address indexed oldAddress, address indexed newAddress ); /** * @dev Emitted when the ACL admin is updated. * @param oldAddress The old address of the ACLAdmin * @param newAddress The new address of the ACLAdmin */ event ACLAdminUpdated( address indexed oldAddress, address indexed newAddress ); /** * @dev Emitted when the price oracle sentinel is updated. * @param oldAddress The old address of the PriceOracleSentinel * @param newAddress The new address of the PriceOracleSentinel */ event PriceOracleSentinelUpdated( address indexed oldAddress, address indexed newAddress ); /** * @dev Emitted when the pool data provider is updated. * @param oldAddress The old address of the PoolDataProvider * @param newAddress The new address of the PoolDataProvider */ event ProtocolDataProviderUpdated( address indexed oldAddress, address indexed newAddress ); /** * @dev Emitted when a new proxy is created. * @param id The identifier of the proxy * @param proxyAddress The address of the created proxy contract * @param implementationAddress The address of the implementation contract */ event ProxyCreated( bytes32 indexed id, address indexed proxyAddress, address indexed implementationAddress ); /** * @dev Emitted when a new proxy is created. * @param id The identifier of the proxy * @param proxyAddress The address of the created proxy contract * @param implementationParams The params of the implementation update */ event ParaProxyCreated( bytes32 indexed id, address indexed proxyAddress, IParaProxy.ProxyImplementation[] indexed implementationParams ); /** * @dev Emitted when a new proxy is created. * @param id The identifier of the proxy * @param proxyAddress The address of the created proxy contract * @param implementationParams The params of the implementation update */ event ParaProxyUpdated( bytes32 indexed id, address indexed proxyAddress, IParaProxy.ProxyImplementation[] indexed implementationParams ); /** * @dev Emitted when a new non-proxied contract address is registered. * @param id The identifier of the contract * @param oldAddress The address of the old contract * @param newAddress The address of the new contract */ event AddressSet( bytes32 indexed id, address indexed oldAddress, address indexed newAddress ); /** * @dev Emitted when the implementation of the proxy registered with id is updated * @param id The identifier of the contract * @param proxyAddress The address of the proxy contract * @param oldImplementationAddress The address of the old implementation contract * @param newImplementationAddress The address of the new implementation contract */ event AddressSetAsProxy( bytes32 indexed id, address indexed proxyAddress, address oldImplementationAddress, address indexed newImplementationAddress ); /** * @dev Emitted when the marketplace registered is updated * @param id The identifier of the marketplace * @param marketplace The address of the marketplace contract * @param adapter The address of the marketplace adapter contract * @param operator The address of the marketplace transfer helper * @param paused Is the marketplace adapter paused */ event MarketplaceUpdated( bytes32 indexed id, address indexed marketplace, address indexed adapter, address operator, bool paused ); /** * @notice Returns the id of the ParaSpace market to which this contract points to. * @return The market id **/ function getMarketId() external view returns (string memory); /** * @notice Associates an id with a specific PoolAddressesProvider. * @dev This can be used to create an onchain registry of PoolAddressesProviders to * identify and validate multiple ParaSpace markets. * @param newMarketId The market id */ function setMarketId(string calldata newMarketId) external; /** * @notice Returns an address by its identifier. * @dev The returned address might be an EOA or a contract, potentially proxied * @dev It returns ZERO if there is no registered address with the given id * @param id The id * @return The address of the registered for the specified id */ function getAddress(bytes32 id) external view returns (address); /** * @notice General function to update the implementation of a proxy registered with * certain `id`. If there is no proxy registered, it will instantiate one and * set as implementation the `newImplementationAddress`. * @dev IMPORTANT Use this function carefully, only for ids that don't have an explicit * setter function, in order to avoid unexpected consequences * @param id The id * @param newImplementationAddress The address of the new implementation */ function setAddressAsProxy(bytes32 id, address newImplementationAddress) external; /** * @notice Sets an address for an id replacing the address saved in the addresses map. * @dev IMPORTANT Use this function carefully, as it will do a hard replacement * @param id The id * @param newAddress The address to set */ function setAddress(bytes32 id, address newAddress) external; /** * @notice Returns the address of the Pool proxy. * @return The Pool proxy address **/ function getPool() external view returns (address); /** * @notice Updates the implementation of the Pool, or creates a proxy * setting the new `pool` implementation when the function is called for the first time. * @param implementationParams Contains the implementation addresses and function selectors * @param _init The address of the contract or implementation to execute _calldata * @param _calldata A function call, including function selector and arguments * _calldata is executed with delegatecall on _init **/ function updatePoolImpl( IParaProxy.ProxyImplementation[] calldata implementationParams, address _init, bytes calldata _calldata ) external; /** * @notice Returns the address of the PoolConfigurator proxy. * @return The PoolConfigurator proxy address **/ function getPoolConfigurator() external view returns (address); /** * @notice Updates the implementation of the PoolConfigurator, or creates a proxy * setting the new `PoolConfigurator` implementation when the function is called for the first time. * @param newPoolConfiguratorImpl The new PoolConfigurator implementation **/ function setPoolConfiguratorImpl(address newPoolConfiguratorImpl) external; /** * @notice Returns the address of the price oracle. * @return The address of the PriceOracle */ function getPriceOracle() external view returns (address); /** * @notice Updates the address of the price oracle. * @param newPriceOracle The address of the new PriceOracle */ function setPriceOracle(address newPriceOracle) external; /** * @notice Returns the address of the ACL manager. * @return The address of the ACLManager */ function getACLManager() external view returns (address); /** * @notice Updates the address of the ACL manager. * @param newAclManager The address of the new ACLManager **/ function setACLManager(address newAclManager) external; /** * @notice Returns the address of the ACL admin. * @return The address of the ACL admin */ function getACLAdmin() external view returns (address); /** * @notice Updates the address of the ACL admin. * @param newAclAdmin The address of the new ACL admin */ function setACLAdmin(address newAclAdmin) external; /** * @notice Returns the address of the price oracle sentinel. * @return The address of the PriceOracleSentinel */ function getPriceOracleSentinel() external view returns (address); /** * @notice Updates the address of the price oracle sentinel. * @param newPriceOracleSentinel The address of the new PriceOracleSentinel **/ function setPriceOracleSentinel(address newPriceOracleSentinel) external; /** * @notice Returns the address of the data provider. * @return The address of the DataProvider */ function getPoolDataProvider() external view returns (address); /** * @notice Returns the address of the Wrapped ETH. * @return The address of the Wrapped ETH */ function getWETH() external view returns (address); /** * @notice Returns the info of the marketplace. * @return The info of the marketplace */ function getMarketplace(bytes32 id) external view returns (DataTypes.Marketplace memory); /** * @notice Updates the address of the data provider. * @param newDataProvider The address of the new DataProvider **/ function setProtocolDataProvider(address newDataProvider) external; /** * @notice Updates the address of the WETH. * @param newWETH The address of the new WETH **/ function setWETH(address newWETH) external; /** * @notice Updates the info of the marketplace. * @param marketplace The address of the marketplace * @param adapter The contract which handles marketplace logic * @param operator The contract which operates users' tokens **/ function setMarketplace( bytes32 id, address marketplace, address adapter, address operator, bool paused ) external; }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.8.10; interface INFTFloorOracle { function getPrice(address token) external view returns (uint256 price); function getLastUpdateTime(address token) external view returns (uint256 timestamp); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.10; /** * @title Errors library * * @notice Defines the error messages emitted by the different contracts of the ParaSpace protocol */ library Errors { string public constant CALLER_NOT_POOL_ADMIN = "1"; // 'The caller of the function is not a pool admin' string public constant CALLER_NOT_EMERGENCY_ADMIN = "2"; // 'The caller of the function is not an emergency admin' string public constant CALLER_NOT_POOL_OR_EMERGENCY_ADMIN = "3"; // 'The caller of the function is not a pool or emergency admin' string public constant CALLER_NOT_RISK_OR_POOL_ADMIN = "4"; // 'The caller of the function is not a risk or pool admin' string public constant CALLER_NOT_ASSET_LISTING_OR_POOL_ADMIN = "5"; // 'The caller of the function is not an asset listing or pool admin' string public constant CALLER_NOT_BRIDGE = "6"; // 'The caller of the function is not a bridge' string public constant ADDRESSES_PROVIDER_NOT_REGISTERED = "7"; // 'Pool addresses provider is not registered' string public constant INVALID_ADDRESSES_PROVIDER_ID = "8"; // 'Invalid id for the pool addresses provider' string public constant NOT_CONTRACT = "9"; // 'Address is not a contract' string public constant CALLER_NOT_POOL_CONFIGURATOR = "10"; // 'The caller of the function is not the pool configurator' string public constant CALLER_NOT_XTOKEN = "11"; // 'The caller of the function is not an PToken or NToken' string public constant INVALID_ADDRESSES_PROVIDER = "12"; // 'The address of the pool addresses provider is invalid' string public constant RESERVE_ALREADY_ADDED = "14"; // 'Reserve has already been added to reserve list' string public constant NO_MORE_RESERVES_ALLOWED = "15"; // 'Maximum amount of reserves in the pool reached' string public constant RESERVE_LIQUIDITY_NOT_ZERO = "18"; // 'The liquidity of the reserve needs to be 0' string public constant INVALID_RESERVE_PARAMS = "20"; // 'Invalid risk parameters for the reserve' string public constant CALLER_MUST_BE_POOL = "23"; // 'The caller of this function must be a pool' string public constant INVALID_MINT_AMOUNT = "24"; // 'Invalid amount to mint' string public constant INVALID_BURN_AMOUNT = "25"; // 'Invalid amount to burn' string public constant INVALID_AMOUNT = "26"; // 'Amount must be greater than 0' string public constant RESERVE_INACTIVE = "27"; // 'Action requires an active reserve' string public constant RESERVE_FROZEN = "28"; // 'Action cannot be performed because the reserve is frozen' string public constant RESERVE_PAUSED = "29"; // 'Action cannot be performed because the reserve is paused' string public constant BORROWING_NOT_ENABLED = "30"; // 'Borrowing is not enabled' string public constant STABLE_BORROWING_NOT_ENABLED = "31"; // 'Stable borrowing is not enabled' string public constant NOT_ENOUGH_AVAILABLE_USER_BALANCE = "32"; // 'User cannot withdraw more than the available balance' string public constant INVALID_INTEREST_RATE_MODE_SELECTED = "33"; // 'Invalid interest rate mode selected' string public constant COLLATERAL_BALANCE_IS_ZERO = "34"; // 'The collateral balance is 0' string public constant HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD = "35"; // 'Health factor is lesser than the liquidation threshold' string public constant COLLATERAL_CANNOT_COVER_NEW_BORROW = "36"; // 'There is not enough collateral to cover a new borrow' string public constant COLLATERAL_SAME_AS_BORROWING_CURRENCY = "37"; // 'Collateral is (mostly) the same currency that is being borrowed' string public constant AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = "38"; // 'The requested amount is greater than the max loan size in stable rate mode' string public constant NO_DEBT_OF_SELECTED_TYPE = "39"; // 'For repayment of a specific type of debt, the user needs to have debt that type' string public constant NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = "40"; // 'To repay on behalf of a user an explicit amount to repay is needed' string public constant NO_OUTSTANDING_STABLE_DEBT = "41"; // 'User does not have outstanding stable rate debt on this reserve' string public constant NO_OUTSTANDING_VARIABLE_DEBT = "42"; // 'User does not have outstanding variable rate debt on this reserve' string public constant UNDERLYING_BALANCE_ZERO = "43"; // 'The underlying balance needs to be greater than 0' string public constant INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = "44"; // 'Interest rate rebalance conditions were not met' string public constant HEALTH_FACTOR_NOT_BELOW_THRESHOLD = "45"; // 'Health factor is not below the threshold' string public constant COLLATERAL_CANNOT_BE_AUCTIONED_OR_LIQUIDATED = "46"; // 'The collateral chosen cannot be auctioned OR liquidated' string public constant SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = "47"; // 'User did not borrow the specified currency' string public constant SAME_BLOCK_BORROW_REPAY = "48"; // 'Borrow and repay in same block is not allowed' string public constant BORROW_CAP_EXCEEDED = "50"; // 'Borrow cap is exceeded' string public constant SUPPLY_CAP_EXCEEDED = "51"; // 'Supply cap is exceeded' string public constant XTOKEN_SUPPLY_NOT_ZERO = "54"; // 'PToken supply is not zero' string public constant STABLE_DEBT_NOT_ZERO = "55"; // 'Stable debt supply is not zero' string public constant VARIABLE_DEBT_SUPPLY_NOT_ZERO = "56"; // 'Variable debt supply is not zero' string public constant LTV_VALIDATION_FAILED = "57"; // 'Ltv validation failed' string public constant PRICE_ORACLE_SENTINEL_CHECK_FAILED = "59"; // 'Price oracle sentinel validation failed' string public constant RESERVE_ALREADY_INITIALIZED = "61"; // 'Reserve has already been initialized' string public constant INVALID_LTV = "63"; // 'Invalid ltv parameter for the reserve' string public constant INVALID_LIQ_THRESHOLD = "64"; // 'Invalid liquidity threshold parameter for the reserve' string public constant INVALID_LIQ_BONUS = "65"; // 'Invalid liquidity bonus parameter for the reserve' string public constant INVALID_DECIMALS = "66"; // 'Invalid decimals parameter of the underlying asset of the reserve' string public constant INVALID_RESERVE_FACTOR = "67"; // 'Invalid reserve factor parameter for the reserve' string public constant INVALID_BORROW_CAP = "68"; // 'Invalid borrow cap for the reserve' string public constant INVALID_SUPPLY_CAP = "69"; // 'Invalid supply cap for the reserve' string public constant INVALID_LIQUIDATION_PROTOCOL_FEE = "70"; // 'Invalid liquidation protocol fee for the reserve' string public constant INVALID_DEBT_CEILING = "73"; // 'Invalid debt ceiling for the reserve string public constant INVALID_RESERVE_INDEX = "74"; // 'Invalid reserve index' string public constant ACL_ADMIN_CANNOT_BE_ZERO = "75"; // 'ACL admin cannot be set to the zero address' string public constant INCONSISTENT_PARAMS_LENGTH = "76"; // 'Array parameters that should be equal length are not' string public constant ZERO_ADDRESS_NOT_VALID = "77"; // 'Zero address not valid' string public constant INVALID_EXPIRATION = "78"; // 'Invalid expiration' string public constant INVALID_SIGNATURE = "79"; // 'Invalid signature' string public constant OPERATION_NOT_SUPPORTED = "80"; // 'Operation not supported' string public constant ASSET_NOT_LISTED = "82"; // 'Asset is not listed' string public constant INVALID_OPTIMAL_USAGE_RATIO = "83"; // 'Invalid optimal usage ratio' string public constant INVALID_OPTIMAL_STABLE_TO_TOTAL_DEBT_RATIO = "84"; // 'Invalid optimal stable to total debt ratio' string public constant UNDERLYING_CANNOT_BE_RESCUED = "85"; // 'The underlying asset cannot be rescued' string public constant ADDRESSES_PROVIDER_ALREADY_ADDED = "86"; // 'Reserve has already been added to reserve list' string public constant POOL_ADDRESSES_DO_NOT_MATCH = "87"; // 'The token implementation pool address and the pool address provided by the initializing pool do not match' string public constant STABLE_BORROWING_ENABLED = "88"; // 'Stable borrowing is enabled' string public constant SILOED_BORROWING_VIOLATION = "89"; // 'User is trying to borrow multiple assets including a siloed one' string public constant RESERVE_DEBT_NOT_ZERO = "90"; // the total debt of the reserve needs to be 0 string public constant NOT_THE_OWNER = "91"; // user is not the owner of a given asset string public constant LIQUIDATION_AMOUNT_NOT_ENOUGH = "92"; string public constant INVALID_ASSET_TYPE = "93"; // invalid asset type for action. string public constant INVALID_FLASH_CLAIM_RECEIVER = "94"; // invalid flash claim receiver. string public constant ERC721_HEALTH_FACTOR_NOT_BELOW_THRESHOLD = "95"; // ERC721 Health factor is not below the threshold. Can only liquidate ERC20. string public constant UNDERLYING_ASSET_CAN_NOT_BE_TRANSFERRED = "96"; //underlying asset can not be transferred. string public constant TOKEN_TRANSFERRED_CAN_NOT_BE_SELF_ADDRESS = "97"; //token transferred can not be self address. string public constant INVALID_AIRDROP_CONTRACT_ADDRESS = "98"; //invalid airdrop contract address. string public constant INVALID_AIRDROP_PARAMETERS = "99"; //invalid airdrop parameters. string public constant CALL_AIRDROP_METHOD_FAILED = "100"; //call airdrop method failed. string public constant SUPPLIER_NOT_NTOKEN = "101"; //supplier is not the NToken contract string public constant CALL_MARKETPLACE_FAILED = "102"; //call marketplace failed. string public constant INVALID_MARKETPLACE_ID = "103"; //invalid marketplace id. string public constant INVALID_MARKETPLACE_ORDER = "104"; //invalid marketplace id. string public constant CREDIT_DOES_NOT_MATCH_ORDER = "105"; //credit doesn't match order. string public constant PAYNOW_NOT_ENOUGH = "106"; //paynow not enough. string public constant INVALID_CREDIT_SIGNATURE = "107"; //invalid credit signature. string public constant INVALID_ORDER_TAKER = "108"; //invalid order taker. string public constant MARKETPLACE_PAUSED = "109"; //marketplace paused. string public constant INVALID_AUCTION_RECOVERY_HEALTH_FACTOR = "110"; //invalid auction recovery health factor. string public constant AUCTION_ALREADY_STARTED = "111"; //auction already started. string public constant AUCTION_NOT_STARTED = "112"; //auction not started yet. string public constant AUCTION_NOT_ENABLED = "113"; //auction not enabled on the reserve. string public constant ERC721_HEALTH_FACTOR_NOT_ABOVE_THRESHOLD = "114"; //ERC721 Health factor is not above the threshold. string public constant TOKEN_IN_AUCTION = "115"; //tokenId is in auction. string public constant AUCTIONED_BALANCE_NOT_ZERO = "116"; //auctioned balance not zero. string public constant LIQUIDATOR_CAN_NOT_BE_SELF = "117"; //user can not liquidate himself. string public constant INVALID_RECIPIENT = "118"; //invalid recipient specified in order. string public constant UNIV3_NOT_ALLOWED = "119"; //flash claim is not allowed for UniswapV3. string public constant NTOKEN_BALANCE_EXCEEDED = "120"; //ntoken balance exceed limit. string public constant ORACLE_PRICE_NOT_READY = "121"; //oracle price not ready. string public constant SET_ORACLE_SOURCE_NOT_ALLOWED = "122"; //source of oracle not allowed to set. string public constant INVALID_LIQUIDATION_ASSET = "123"; //invalid liquidation asset. string public constant ONLY_UNIV3_ALLOWED = "124"; //only UniswapV3 allowed. string public constant GLOBAL_DEBT_IS_ZERO = "125"; //liquidation is not allowed when global debt is zero. string public constant ORACLE_PRICE_EXPIRED = "126"; //oracle price expired. string public constant APE_STAKING_POSITION_EXISTED = "127"; //ape staking position is existed. string public constant SAPE_NOT_ALLOWED = "128"; //operation is not allow for sApe. string public constant TOTAL_STAKING_AMOUNT_WRONG = "129"; //cash plus borrow amount not equal to total staking amount. string public constant NOT_THE_BAKC_OWNER = "130"; //user is not the bakc owner. string public constant CALLER_NOT_EOA = "131"; //The caller of the function is not an EOA account string public constant MAKER_SAME_AS_TAKER = "132"; //maker and taker shouldn't be the same address }
// SPDX-License-Identifier: AGPL-3.0 pragma solidity ^0.8.10; /******************************************************************************\ * EIP-2535: https://eips.ethereum.org/EIPS/eip-2535 /******************************************************************************/ interface IParaProxy { enum ProxyImplementationAction { Add, Replace, Remove } // Add=0, Replace=1, Remove=2 struct ProxyImplementation { address implAddress; ProxyImplementationAction action; bytes4[] functionSelectors; } /// @notice Add/replace/remove any number of functions and optionally execute /// a function with delegatecall /// @param _implementationParams Contains the implementation addresses and function selectors /// @param _init The address of the contract or implementation to execute _calldata /// @param _calldata A function call, including function selector and arguments /// _calldata is executed with delegatecall on _init function updateImplementation( ProxyImplementation[] calldata _implementationParams, address _init, bytes calldata _calldata ) external; event ImplementationUpdated( ProxyImplementation[] _implementationParams, address _init, bytes _calldata ); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.10; import {OfferItem, ConsiderationItem} from "../../../dependencies/seaport/contracts/lib/ConsiderationStructs.sol"; library DataTypes { enum AssetType { ERC20, ERC721 } address public constant SApeAddress = address(0x1); uint256 public constant HEALTH_FACTOR_LIQUIDATION_THRESHOLD = 1e18; struct ReserveData { //stores the reserve configuration ReserveConfigurationMap configuration; //the liquidity index. Expressed in ray uint128 liquidityIndex; //the current supply rate. Expressed in ray uint128 currentLiquidityRate; //variable borrow index. Expressed in ray uint128 variableBorrowIndex; //the current variable borrow rate. Expressed in ray uint128 currentVariableBorrowRate; //timestamp of last update uint40 lastUpdateTimestamp; //the id of the reserve. Represents the position in the list of the active reserves uint16 id; //xToken address address xTokenAddress; //variableDebtToken address address variableDebtTokenAddress; //address of the interest rate strategy address interestRateStrategyAddress; //address of the auction strategy address auctionStrategyAddress; //the current treasury balance, scaled uint128 accruedToTreasury; } struct ReserveConfigurationMap { //bit 0-15: LTV //bit 16-31: Liq. threshold //bit 32-47: Liq. bonus //bit 48-55: Decimals //bit 56: reserve is active //bit 57: reserve is frozen //bit 58: borrowing is enabled //bit 59: stable rate borrowing enabled //bit 60: asset is paused //bit 61: borrowing in isolation mode is enabled //bit 62-63: reserved //bit 64-79: reserve factor //bit 80-115 borrow cap in whole tokens, borrowCap == 0 => no cap //bit 116-151 supply cap in whole tokens, supplyCap == 0 => no cap //bit 152-167 liquidation protocol fee //bit 168-175 eMode category //bit 176-211 unbacked mint cap in whole tokens, unbackedMintCap == 0 => minting disabled //bit 212-251 debt ceiling for isolation mode with (ReserveConfiguration::DEBT_CEILING_DECIMALS) decimals //bit 252-255 unused uint256 data; } struct UserConfigurationMap { /** * @dev Bitmap of the users collaterals and borrows. It is divided in pairs of bits, one pair per asset. * The first bit indicates if an asset is used as collateral by the user, the second whether an * asset is borrowed by the user. */ uint256 data; // auction validity time for closing invalid auctions in one tx. uint256 auctionValidityTime; } struct ERC721SupplyParams { uint256 tokenId; bool useAsCollateral; } struct NTokenData { uint256 tokenId; bool useAsCollateral; bool isAuctioned; } struct ReserveCache { uint256 currScaledVariableDebt; uint256 nextScaledVariableDebt; uint256 currLiquidityIndex; uint256 nextLiquidityIndex; uint256 currVariableBorrowIndex; uint256 nextVariableBorrowIndex; uint256 currLiquidityRate; uint256 currVariableBorrowRate; uint256 reserveFactor; ReserveConfigurationMap reserveConfiguration; address xTokenAddress; address variableDebtTokenAddress; uint40 reserveLastUpdateTimestamp; } struct ExecuteLiquidateParams { uint256 reservesCount; uint256 liquidationAmount; uint256 collateralTokenId; uint256 auctionRecoveryHealthFactor; address weth; address collateralAsset; address liquidationAsset; address borrower; address liquidator; bool receiveXToken; address priceOracle; address priceOracleSentinel; } struct ExecuteAuctionParams { uint256 reservesCount; uint256 auctionRecoveryHealthFactor; uint256 collateralTokenId; address collateralAsset; address user; address priceOracle; } struct ExecuteSupplyParams { address asset; uint256 amount; address onBehalfOf; address payer; uint16 referralCode; } struct ExecuteSupplyERC721Params { address asset; DataTypes.ERC721SupplyParams[] tokenData; address onBehalfOf; address payer; uint16 referralCode; } struct ExecuteBorrowParams { address asset; address user; address onBehalfOf; uint256 amount; uint16 referralCode; bool releaseUnderlying; uint256 reservesCount; address oracle; address priceOracleSentinel; } struct ExecuteRepayParams { address asset; uint256 amount; address onBehalfOf; bool usePTokens; } struct ExecuteWithdrawParams { address asset; uint256 amount; address to; uint256 reservesCount; address oracle; } struct ExecuteWithdrawERC721Params { address asset; uint256[] tokenIds; address to; uint256 reservesCount; address oracle; } struct ExecuteDecreaseUniswapV3LiquidityParams { address user; address asset; uint256 tokenId; uint256 reservesCount; uint128 liquidityDecrease; uint256 amount0Min; uint256 amount1Min; bool receiveEthAsWeth; address oracle; } struct FinalizeTransferParams { address asset; address from; address to; bool usedAsCollateral; uint256 amount; uint256 balanceFromBefore; uint256 balanceToBefore; uint256 reservesCount; address oracle; } struct FinalizeTransferERC721Params { address asset; address from; address to; bool usedAsCollateral; uint256 tokenId; uint256 balanceFromBefore; uint256 reservesCount; address oracle; } struct CalculateUserAccountDataParams { UserConfigurationMap userConfig; uint256 reservesCount; address user; address oracle; } struct ValidateBorrowParams { ReserveCache reserveCache; UserConfigurationMap userConfig; address asset; address userAddress; uint256 amount; uint256 reservesCount; address oracle; address priceOracleSentinel; } struct ValidateLiquidateERC20Params { ReserveCache liquidationAssetReserveCache; address liquidationAsset; address weth; uint256 totalDebt; uint256 healthFactor; uint256 liquidationAmount; uint256 actualLiquidationAmount; address priceOracleSentinel; } struct ValidateLiquidateERC721Params { ReserveCache liquidationAssetReserveCache; address liquidationAsset; address liquidator; address borrower; uint256 globalDebt; uint256 healthFactor; address collateralAsset; uint256 tokenId; address weth; uint256 actualLiquidationAmount; uint256 maxLiquidationAmount; uint256 auctionRecoveryHealthFactor; address priceOracleSentinel; address xTokenAddress; bool auctionEnabled; } struct ValidateAuctionParams { address user; uint256 auctionRecoveryHealthFactor; uint256 erc721HealthFactor; address collateralAsset; uint256 tokenId; address xTokenAddress; } struct CalculateInterestRatesParams { uint256 liquidityAdded; uint256 liquidityTaken; uint256 totalVariableDebt; uint256 reserveFactor; address reserve; address xToken; } struct InitReserveParams { address asset; address xTokenAddress; address variableDebtAddress; address interestRateStrategyAddress; address auctionStrategyAddress; uint16 reservesCount; uint16 maxNumberReserves; } struct ExecuteFlashClaimParams { address receiverAddress; address nftAsset; uint256[] nftTokenIds; bytes params; address oracle; } struct Credit { address token; uint256 amount; bytes orderId; uint8 v; bytes32 r; bytes32 s; } struct ExecuteMarketplaceParams { bytes32 marketplaceId; bytes payload; Credit credit; uint256 ethLeft; DataTypes.Marketplace marketplace; OrderInfo orderInfo; address weth; uint16 referralCode; uint256 reservesCount; address oracle; address priceOracleSentinel; } struct OrderInfo { address maker; address taker; bytes id; OfferItem[] offer; ConsiderationItem[] consideration; } struct Marketplace { address marketplace; address adapter; address operator; bool paused; } struct Auction { uint256 startTime; } struct AuctionData { address asset; uint256 tokenId; uint256 startTime; uint256 currentPriceMultiplier; uint256 maxPriceMultiplier; uint256 minExpPriceMultiplier; uint256 minPriceMultiplier; uint256 stepLinear; uint256 stepExp; uint256 tickLength; } struct TokenData { string symbol; address tokenAddress; } struct PoolStorage { // Map of reserves and their data (underlyingAssetOfReserve => reserveData) mapping(address => ReserveData) _reserves; // Map of users address and their configuration data (userAddress => userConfiguration) mapping(address => UserConfigurationMap) _usersConfig; // List of reserves as a map (reserveId => reserve). // It is structured as a mapping for gas savings reasons, using the reserve id as index mapping(uint256 => address) _reservesList; // Maximum number of active reserves there have been in the protocol. It is the upper bound of the reserves list uint16 _reservesCount; // Auction recovery health factor uint64 _auctionRecoveryHealthFactor; // incentive fee for claim ape reward to compound uint16 _apeCompoundFee; } struct ReserveConfigData { uint256 decimals; uint256 ltv; uint256 liquidationThreshold; uint256 liquidationBonus; uint256 reserveFactor; bool usageAsCollateralEnabled; bool borrowingEnabled; bool isActive; bool isFrozen; bool isPaused; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; import { OrderType, BasicOrderType, ItemType, Side } from "./ConsiderationEnums.sol"; /** * @dev An order contains eleven components: an offerer, a zone (or account that * can cancel the order or restrict who can fulfill the order depending on * the type), the order type (specifying partial fill support as well as * restricted order status), the start and end time, a hash that will be * provided to the zone when validating restricted orders, a salt, a key * corresponding to a given conduit, a counter, and an arbitrary number of * offer items that can be spent along with consideration items that must * be received by their respective recipient. */ struct OrderComponents { address offerer; address zone; OfferItem[] offer; ConsiderationItem[] consideration; OrderType orderType; uint256 startTime; uint256 endTime; bytes32 zoneHash; uint256 salt; bytes32 conduitKey; uint256 counter; } /** * @dev An offer item has five components: an item type (ETH or other native * tokens, ERC20, ERC721, and ERC1155, as well as criteria-based ERC721 and * ERC1155), a token address, a dual-purpose "identifierOrCriteria" * component that will either represent a tokenId or a merkle root * depending on the item type, and a start and end amount that support * increasing or decreasing amounts over the duration of the respective * order. */ struct OfferItem { ItemType itemType; address token; uint256 identifierOrCriteria; uint256 startAmount; uint256 endAmount; } /** * @dev A consideration item has the same five components as an offer item and * an additional sixth component designating the required recipient of the * item. */ struct ConsiderationItem { ItemType itemType; address token; uint256 identifierOrCriteria; uint256 startAmount; uint256 endAmount; address payable recipient; } /** * @dev A spent item is translated from a utilized offer item and has four * components: an item type (ETH or other native tokens, ERC20, ERC721, and * ERC1155), a token address, a tokenId, and an amount. */ struct SpentItem { ItemType itemType; address token; uint256 identifier; uint256 amount; } /** * @dev A received item is translated from a utilized consideration item and has * the same four components as a spent item, as well as an additional fifth * component designating the required recipient of the item. */ struct ReceivedItem { ItemType itemType; address token; uint256 identifier; uint256 amount; address payable recipient; } /** * @dev For basic orders involving ETH / native / ERC20 <=> ERC721 / ERC1155 * matching, a group of six functions may be called that only requires a * subset of the usual order arguments. Note the use of a "basicOrderType" * enum; this represents both the usual order type as well as the "route" * of the basic order (a simple derivation function for the basic order * type is `basicOrderType = orderType + (4 * basicOrderRoute)`.) */ struct BasicOrderParameters { // calldata offset address considerationToken; // 0x24 uint256 considerationIdentifier; // 0x44 uint256 considerationAmount; // 0x64 address payable offerer; // 0x84 address zone; // 0xa4 address offerToken; // 0xc4 uint256 offerIdentifier; // 0xe4 uint256 offerAmount; // 0x104 BasicOrderType basicOrderType; // 0x124 uint256 startTime; // 0x144 uint256 endTime; // 0x164 bytes32 zoneHash; // 0x184 uint256 salt; // 0x1a4 bytes32 offererConduitKey; // 0x1c4 bytes32 fulfillerConduitKey; // 0x1e4 uint256 totalOriginalAdditionalRecipients; // 0x204 AdditionalRecipient[] additionalRecipients; // 0x224 bytes signature; // 0x244 // Total length, excluding dynamic array data: 0x264 (580) } /** * @dev Basic orders can supply any number of additional recipients, with the * implied assumption that they are supplied from the offered ETH (or other * native token) or ERC20 token for the order. */ struct AdditionalRecipient { uint256 amount; address payable recipient; } /** * @dev The full set of order components, with the exception of the counter, * must be supplied when fulfilling more sophisticated orders or groups of * orders. The total number of original consideration items must also be * supplied, as the caller may specify additional consideration items. */ struct OrderParameters { address offerer; // 0x00 address zone; // 0x20 OfferItem[] offer; // 0x40 ConsiderationItem[] consideration; // 0x60 OrderType orderType; // 0x80 uint256 startTime; // 0xa0 uint256 endTime; // 0xc0 bytes32 zoneHash; // 0xe0 uint256 salt; // 0x100 bytes32 conduitKey; // 0x120 uint256 totalOriginalConsiderationItems; // 0x140 // offer.length // 0x160 } /** * @dev Orders require a signature in addition to the other order parameters. */ struct Order { OrderParameters parameters; bytes signature; } /** * @dev Advanced orders include a numerator (i.e. a fraction to attempt to fill) * and a denominator (the total size of the order) in addition to the * signature and other order parameters. It also supports an optional field * for supplying extra data; this data will be included in a staticcall to * `isValidOrderIncludingExtraData` on the zone for the order if the order * type is restricted and the offerer or zone are not the caller. */ struct AdvancedOrder { OrderParameters parameters; uint120 numerator; uint120 denominator; bytes signature; bytes extraData; } /** * @dev Orders can be validated (either explicitly via `validate`, or as a * consequence of a full or partial fill), specifically cancelled (they can * also be cancelled in bulk via incrementing a per-zone counter), and * partially or fully filled (with the fraction filled represented by a * numerator and denominator). */ struct OrderStatus { bool isValidated; bool isCancelled; uint120 numerator; uint120 denominator; } /** * @dev A criteria resolver specifies an order, side (offer vs. consideration), * and item index. It then provides a chosen identifier (i.e. tokenId) * alongside a merkle proof demonstrating the identifier meets the required * criteria. */ struct CriteriaResolver { uint256 orderIndex; Side side; uint256 index; uint256 identifier; bytes32[] criteriaProof; } /** * @dev A fulfillment is applied to a group of orders. It decrements a series of * offer and consideration items, then generates a single execution * element. A given fulfillment can be applied to as many offer and * consideration items as desired, but must contain at least one offer and * at least one consideration that match. The fulfillment must also remain * consistent on all key parameters across all offer items (same offerer, * token, type, tokenId, and conduit preference) as well as across all * consideration items (token, type, tokenId, and recipient). */ struct Fulfillment { FulfillmentComponent[] offerComponents; FulfillmentComponent[] considerationComponents; } /** * @dev Each fulfillment component contains one index referencing a specific * order and another referencing a specific offer or consideration item. */ struct FulfillmentComponent { uint256 orderIndex; uint256 itemIndex; } /** * @dev An execution is triggered once all consideration items have been zeroed * out. It sends the item in question from the offerer to the item's * recipient, optionally sourcing approvals from either this contract * directly or from the offerer's chosen conduit if one is specified. An * execution is not provided as an argument, but rather is derived via * orders, criteria resolvers, and fulfillments (where the total number of * executions will be less than or equal to the total number of indicated * fulfillments) and returned as part of `matchOrders`. */ struct Execution { ReceivedItem item; address offerer; bytes32 conduitKey; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; // prettier-ignore enum OrderType { // 0: no partial fills, anyone can execute FULL_OPEN, // 1: partial fills supported, anyone can execute PARTIAL_OPEN, // 2: no partial fills, only offerer or zone can execute FULL_RESTRICTED, // 3: partial fills supported, only offerer or zone can execute PARTIAL_RESTRICTED } // prettier-ignore enum BasicOrderType { // 0: no partial fills, anyone can execute ETH_TO_ERC721_FULL_OPEN, // 1: partial fills supported, anyone can execute ETH_TO_ERC721_PARTIAL_OPEN, // 2: no partial fills, only offerer or zone can execute ETH_TO_ERC721_FULL_RESTRICTED, // 3: partial fills supported, only offerer or zone can execute ETH_TO_ERC721_PARTIAL_RESTRICTED, // 4: no partial fills, anyone can execute ETH_TO_ERC1155_FULL_OPEN, // 5: partial fills supported, anyone can execute ETH_TO_ERC1155_PARTIAL_OPEN, // 6: no partial fills, only offerer or zone can execute ETH_TO_ERC1155_FULL_RESTRICTED, // 7: partial fills supported, only offerer or zone can execute ETH_TO_ERC1155_PARTIAL_RESTRICTED, // 8: no partial fills, anyone can execute ERC20_TO_ERC721_FULL_OPEN, // 9: partial fills supported, anyone can execute ERC20_TO_ERC721_PARTIAL_OPEN, // 10: no partial fills, only offerer or zone can execute ERC20_TO_ERC721_FULL_RESTRICTED, // 11: partial fills supported, only offerer or zone can execute ERC20_TO_ERC721_PARTIAL_RESTRICTED, // 12: no partial fills, anyone can execute ERC20_TO_ERC1155_FULL_OPEN, // 13: partial fills supported, anyone can execute ERC20_TO_ERC1155_PARTIAL_OPEN, // 14: no partial fills, only offerer or zone can execute ERC20_TO_ERC1155_FULL_RESTRICTED, // 15: partial fills supported, only offerer or zone can execute ERC20_TO_ERC1155_PARTIAL_RESTRICTED, // 16: no partial fills, anyone can execute ERC721_TO_ERC20_FULL_OPEN, // 17: partial fills supported, anyone can execute ERC721_TO_ERC20_PARTIAL_OPEN, // 18: no partial fills, only offerer or zone can execute ERC721_TO_ERC20_FULL_RESTRICTED, // 19: partial fills supported, only offerer or zone can execute ERC721_TO_ERC20_PARTIAL_RESTRICTED, // 20: no partial fills, anyone can execute ERC1155_TO_ERC20_FULL_OPEN, // 21: partial fills supported, anyone can execute ERC1155_TO_ERC20_PARTIAL_OPEN, // 22: no partial fills, only offerer or zone can execute ERC1155_TO_ERC20_FULL_RESTRICTED, // 23: partial fills supported, only offerer or zone can execute ERC1155_TO_ERC20_PARTIAL_RESTRICTED } // prettier-ignore enum BasicOrderRouteType { // 0: provide Ether (or other native token) to receive offered ERC721 item. ETH_TO_ERC721, // 1: provide Ether (or other native token) to receive offered ERC1155 item. ETH_TO_ERC1155, // 2: provide ERC20 item to receive offered ERC721 item. ERC20_TO_ERC721, // 3: provide ERC20 item to receive offered ERC1155 item. ERC20_TO_ERC1155, // 4: provide ERC721 item to receive offered ERC20 item. ERC721_TO_ERC20, // 5: provide ERC1155 item to receive offered ERC20 item. ERC1155_TO_ERC20 } // prettier-ignore enum ItemType { // 0: ETH on mainnet, MATIC on polygon, etc. NATIVE, // 1: ERC20 items (ERC777 and ERC20 analogues could also technically work) ERC20, // 2: ERC721 items ERC721, // 3: ERC1155 items ERC1155, // 4: ERC721 items where a number of tokenIds are supported ERC721_WITH_CRITERIA, // 5: ERC1155 items where a number of ids are supported ERC1155_WITH_CRITERIA } // prettier-ignore enum Side { // 0: Items that can be spent OFFER, // 1: Items that must be received CONSIDERATION }
{ "optimizer": { "enabled": true, "runs": 1000 }, "evmVersion": "london", "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_provider","type":"address"},{"internalType":"address","name":"_oracleAddress","type":"address"},{"internalType":"address","name":"_asset","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"int256","name":"current","type":"int256"},{"indexed":true,"internalType":"uint256","name":"roundId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AnswerUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roundId","type":"uint256"},{"indexed":true,"internalType":"address","name":"startedBy","type":"address"}],"name":"NewRound","type":"event"},{"inputs":[],"name":"ADDRESSES_PROVIDER","outputs":[{"internalType":"contract IPoolAddressesProvider","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getAnswer","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestAnswer","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestRound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"latestTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_oracleAddress","type":"address"}],"name":"setOracle","outputs":[],"stateMutability":"nonpayable","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 ]
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.