Spend less on fees, more on crypto. Buy crypto easily with MoonPay Balance. 20M+ users trust MoonPay worldwide.
Ready to onboard to Ethereum? With MetaMask Portfolio, you're in control.
Don’t invest unless you’re prepared to lose all the money you invest.
Ready to simplify your web3 experience? Try the all-in-one web3 app trusted by millions worldwide.
Available on 9 networks: Ethereum mainnet, Linea, Polygon, Optimism, BNB Chain, zkSync Era, Base, Avalanche.
Everyday giveaways up to 100 ETH, Lucky Spins. Deposit BONUS 300% and Cashbacks!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
Slots, Roulette, Poker & more - Proud sponsors of UFC, Everton & StakeF1 team!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
Anonymous play on awesome games - sign up now for 25 free jackpot spins - worth $100s!
100s of games, generous bonuses, 20+ years of trusted gaming. Join CryptoWins & start winning today!
Overview
ETH Balance
Eth Value
$0.00Token Holdings
Could not find any matches!
- ERC-20 Tokens (15)4.98979599 DEFI5DEFI Top 5 T... (DEFI5)32,190.46103698 SUSHISushiToken (SUSHI)$46,676.17@1.45157.53864717 SNXSynthetix Ne... (SNX)$315.08@2.001,868.40578266 UNIUniswap (UNI)$25,746.63@13.7869.24193102 AAVEAave Token (AAVE)$23,315.14@336.7243.12290125 COMPCompound (COMP)$3,480.45@80.713,295.5223209 CRVCurve DAO To... (CRV)$2,781.40@0.8443.1505413 MKRMaker (MKR)$4,929.02@1,564.504,000 Earn $UNI airdrops at https://www.uniswaplabs.comERC-20: # un... (Earn $...)10 WJXNWrapped JAXNET$0.08@0.007930 TokenERC-20 TOKEN*[Suspicious]30 TokenERC-20 TOKEN*[Suspicious]1.4 TokenERC-20 TOKEN*[Suspicious]1.5 TokenERC-20 TOKEN*[Suspicious]1,500 TokenERC-20 TOKEN*[Suspicious]NFT Tokens (21)claim rewards on snxtoken.comsnxtoken.comERC-1155claim rewards on staave.netstaave.netERC-1155The Moonbirdpunk OfficialThe Moonbirdpunk OfficialERC-1155claim rewards on univ3portal.netuniv3portal.netERC-1155claim rewards on univ4labs.orguniv4labs.orgERC-1155ERC-1155 TOKEN*[Suspicious]ERC-1155 TOKEN*[Suspicious]ERC-1155 TOKEN*[Suspicious]ERC-1155 TOKEN*[Suspicious]ERC-1155 TOKEN*[Suspicious]ERC-1155 TOKEN*[Suspicious]ERC-1155 TOKEN*[Suspicious]ERC-1155 TOKEN*[Spam]
More Info
Private Name Tags
ContractCreator
TokenTracker
- Transactions
- Internal Transactions
- Token Transfers (ERC-20)
- NFT Transfers
- Contract
- Events
- Analytics
- Multichain Portfolio
- Cards New
- Info
Advanced Filter- Filter by Tx Type:
- Tx
- Internal Tx
- ERC-20
- NFTs
Latest 25 from a total of 7,568 transactions
Transaction Hash MethodBlockFromToTransfer 21255228 2024-11-24 4:30:35 29 days ago 1732422635 IN 0 ETH$0.00 0.00043652 10.13454606 Approve 21145496 2024-11-08 21:05:23 44 days ago 1731099923 IN 0 ETH$0.00 0.00047695 13.6234734 Approve 21145496 2024-11-08 21:05:23 44 days ago 1731099923 IN 0 ETH$0.00 0.00047695 13.6234734 Approve 20994143 2024-10-18 18:08:47 65 days ago 1729274927 IN 0 ETH$0.00 0.0006319 18.04916209 Redeem All 20731667 2024-09-12 2:51:59 102 days ago 1726109519 IN 0 ETH$0.00 0.00153895 3.19001711 Exit Pool 20731121 2024-09-12 1:02:11 102 days ago 1726102931 IN 0 ETH$0.00 0.00031505 3.22539508 Exit Pool 20731112 2024-09-12 1:00:23 102 days ago 1726102823 IN 0 ETH$0.00 0.00007532 3.42383762 Transfer 20724683 2024-09-11 3:27:59 103 days ago 1726025279 IN 0 ETH$0.00 0.00015436 2.55673419 Approve 20660690 2024-09-02 5:07:35 112 days ago 1725253655 IN 0 ETH$0.00 0.00003669 1.04810528 Approve 20660689 2024-09-02 5:07:23 112 days ago 1725253643 IN 0 ETH$0.00 0.0000374 1.06828036 Approve 20396134 2024-07-27 6:36:59 149 days ago 1722062219 IN 0 ETH$0.00 0.00004812 1.37450821 Approve 20396129 2024-07-27 6:35:59 149 days ago 1722062159 IN 0 ETH$0.00 0.00004834 1.3807644 Redeem All 20367936 2024-07-23 8:08:47 153 days ago 1721722127 IN 0 ETH$0.00 0.00167917 3.48068139 Approve 20322285 2024-07-16 23:12:59 159 days ago 1721171579 IN 0 ETH$0.00 0.00019674 5.61964835 Approve 20055125 2024-06-09 15:20:47 196 days ago 1717946447 IN 0 ETH$0.00 0.00052624 15.03125183 Approve 20055121 2024-06-09 15:19:59 196 days ago 1717946399 IN 0 ETH$0.00 0.00055515 15.85703396 Transfer 19909705 2024-05-20 7:39:47 217 days ago 1716190787 IN 0 ETH$0.00 0.00014579 3.36879925 Approve 19860766 2024-05-13 11:22:11 224 days ago 1715599331 IN 0 ETH$0.00 0.00011354 3.24333631 Approve 19837986 2024-05-10 6:56:47 227 days ago 1715324207 IN 0 ETH$0.00 0.00015903 4.54246748 Redeem All 19798368 2024-05-04 17:55:47 232 days ago 1714845347 IN 0 ETH$0.00 0.00250578 5.3849902 Approve 19764837 2024-04-30 1:27:47 237 days ago 1714440467 IN 0 ETH$0.00 0.00022587 6.10311124 Approve 19764835 2024-04-30 1:27:23 237 days ago 1714440443 IN 0 ETH$0.00 0.00024391 6.59051102 Approve 19764708 2024-04-30 1:01:59 237 days ago 1714438919 IN 0 ETH$0.00 0.00029355 7.9317781 Approve 19764704 2024-04-30 1:01:11 237 days ago 1714438871 IN 0 ETH$0.00 0.00024979 6.74933692 Approve 19764697 2024-04-30 0:59:47 237 days ago 1714438787 IN 0 ETH$0.00 0.00030438 8.22445119 Latest 1 internal transaction
Advanced mode:Parent Transaction Hash Block FromTo11398665 2020-12-06 10:41:53 1478 days ago 1607251313 Contract Creation 0 ETH$0.00 Loading...LoadingSimilar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0x17aC188e...b0CcFadF3The constructor portion of the code might be different and could alter the actual behaviour of the contractContract Name:DelegateCallProxyManyToOne
Compiler Versionv0.6.12+commit.27d51765
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: GPL-3.0 pragma solidity =0.6.12; import { Proxy } from "@openzeppelin/contracts/proxy/Proxy.sol"; /** * @dev Proxy contract which uses an implementation address shared with many * other proxies. * * An implementation holder contract stores the upgradeable implementation address. * When the proxy is called, it queries the implementation address from the holder * contract and delegatecalls the returned address, forwarding the received calldata * and ether. * * Note: This contract does not verify that the implementation * address is a valid delegation target. The manager must perform * this safety check before updating the implementation on the holder. */ contract DelegateCallProxyManyToOne is Proxy { /* ========== Constants ========== */ // Address that stores the implementation address. address internal immutable _implementationHolder; /* ========== Constructor ========== */ constructor() public { // Calls the sender rather than receiving the address in the constructor // arguments so that the address is computable using create2. _implementationHolder = ProxyDeployer(msg.sender).getImplementationHolder(); } /* ========== Internal Overrides ========== */ /** * @dev Queries the implementation address from the implementation holder. */ function _implementation() internal override view returns (address) { // Queries the implementation address from the implementation holder. (bool success, bytes memory data) = _implementationHolder.staticcall(""); require(success, string(data)); address implementation = abi.decode((data), (address)); require(implementation != address(0), "ERR_NULL_IMPLEMENTATION"); return implementation; } } interface ProxyDeployer { function getImplementationHolder() external view returns (address); }
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.6.0; /** * @dev Because we use the code hashes of the proxy contracts for proxy address * derivation, it is important that other packages have access to the correct * values when they import the salt library. */ library CodeHashes { bytes32 internal constant ONE_TO_ONE_CODEHASH = 0x63d9f7b5931b69188c8f6b806606f25892f1bb17b7f7e966fe3a32c04493aee4; bytes32 internal constant MANY_TO_ONE_CODEHASH = 0xa035ad05a1663db5bfd455b99cd7c6ac6bd49269738458eda140e0b78ed53f79; bytes32 internal constant IMPLEMENTATION_HOLDER_CODEHASH = 0x11c370493a726a0ffa93d42b399ad046f1b5a543b6e72f1a64f1488dc1c58f2c; }
// SPDX-License-Identifier: GPL-3.0 pragma solidity =0.6.12; /* ========== External Libraries ========== */ import { Create2 } from "@openzeppelin/contracts/utils/Create2.sol"; import { Address } from "@openzeppelin/contracts/utils/Address.sol"; import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol"; /* ========== Proxy Contracts ========== */ import "./ManyToOneImplementationHolder.sol"; import { DelegateCallProxyManyToOne } from "./DelegateCallProxyManyToOne.sol"; import { DelegateCallProxyOneToOne } from "./DelegateCallProxyOneToOne.sol"; /* ========== Internal Libraries ========== */ import { SaltyLib as Salty } from "./SaltyLib.sol"; import { CodeHashes } from "./CodeHashes.sol"; /* ========== Inheritance ========== */ import "./interfaces/IDelegateCallProxyManager.sol"; /** * @dev Contract that manages deployment and upgrades of delegatecall proxies. * * An implementation identifier can be created on the proxy manager which is * used to specify the logic address for a particular contract type, and to * upgrade the implementation as needed. * * ====== Proxy Types ====== * A one-to-one proxy is a single proxy contract with an upgradeable implementation * address. * * A many-to-one proxy is a single upgradeable implementation address that may be * used by many proxy contracts. * * ====== Access Control ====== * The proxy manager has a single address as its owner. * * The owner is the sole account with the following permissions: * - Create new many-to-one implementations * - Create new one-to-one proxies * - Modify the implementation address of existing proxies * - Lock proxies * - Designate approved deployers * - Remove approved deployers * - Modify the owner address * * Approved deployers may only deploy many-to-one proxies. * * ====== Upgrades ====== * Proxies can be upgraded by the owner if they are not locked. * * Many-to-one proxy implementations are upgraded by calling the holder contract * for the implementation ID being upgraded. * One-to-one proxies are upgraded by calling the proxy contract directly. * * The owner can lock a one-to-one proxy or many-to-one implementation ID so that * it becomes impossible to upgrade. */ contract DelegateCallProxyManager is Ownable, IDelegateCallProxyManager { /* ========== Events ========== */ event DeploymentApprovalGranted(address deployer); event DeploymentApprovalRevoked(address deployer); event ManyToOne_ImplementationCreated( bytes32 implementationID, address implementationAddress ); event ManyToOne_ImplementationUpdated( bytes32 implementationID, address implementationAddress ); event ManyToOne_ImplementationLocked(bytes32 implementationID); event ManyToOne_ProxyDeployed( bytes32 implementationID, address proxyAddress ); event OneToOne_ProxyDeployed( address proxyAddress, address implementationAddress ); event OneToOne_ImplementationUpdated( address proxyAddress, address implementationAddress ); event OneToOne_ImplementationLocked(address proxyAddress); /* ========== Storage ========== */ // Addresses allowed to deploy many-to-one proxies. mapping(address => bool) internal _approvedDeployers; // Maps implementation holders to their implementation IDs. mapping(bytes32 => address) internal _implementationHolders; // Maps implementation holders & proxy addresses to bool stating if they are locked. mapping(address => bool) internal _lockedImplementations; // Temporary value used in the many-to-one proxy constructor. // The many-to-one proxy contract is deployed with create2 and // uses static initialization code for simple address derivation, // so it calls the proxy manager in the constructor to get this // address in order to save it as an immutable in the bytecode. address internal _implementationHolder; /* ========== Modifiers ========== */ modifier onlyApprovedDeployer { address sender = _msgSender(); require(_approvedDeployers[sender] || sender == owner(), "ERR_NOT_APPROVED"); _; } /* ========== Constructor ========== */ constructor() public Ownable() {} /* ========== Access Control ========== */ /** * @dev Allows `deployer` to deploy many-to-one proxies. */ function approveDeployer(address deployer) external override onlyOwner { _approvedDeployers[deployer] = true; emit DeploymentApprovalGranted(deployer); } /** * @dev Prevents `deployer` from deploying many-to-one proxies. */ function revokeDeployerApproval(address deployer) external override onlyOwner { _approvedDeployers[deployer] = false; emit DeploymentApprovalRevoked(deployer); } /* ========== Implementation Management ========== */ /** * @dev Creates a many-to-one proxy relationship. * * Deploys an implementation holder contract which stores the * implementation address for many proxies. The implementation * address can be updated on the holder to change the runtime * code used by all its proxies. * * @param implementationID ID for the implementation, used to identify the * proxies that use it. Also used as the salt in the create2 call when * deploying the implementation holder contract. * @param implementation Address with the runtime code the proxies * should use. */ function createManyToOneProxyRelationship( bytes32 implementationID, address implementation ) external override onlyOwner { // Deploy the implementation holder contract with the implementation // ID as the create2 salt. address implementationHolder = Create2.deploy( 0, implementationID, type(ManyToOneImplementationHolder).creationCode ); // Store the implementation holder address _implementationHolders[implementationID] = implementationHolder; // Sets the implementation address. _setImplementation(implementationHolder, implementation); emit ManyToOne_ImplementationCreated( implementationID, implementation ); } /** * @dev Lock the current implementation for `implementationID` so that it can never be upgraded again. */ function lockImplementationManyToOne(bytes32 implementationID) external override onlyOwner { // Read the implementation holder address from storage. address implementationHolder = _implementationHolders[implementationID]; // Verify that the implementation exists. require(implementationHolder != address(0), "ERR_IMPLEMENTATION_ID"); _lockedImplementations[implementationHolder] = true; emit ManyToOne_ImplementationLocked(implementationID); } /** * @dev Lock the current implementation for `proxyAddress` so that it can never be upgraded again. */ function lockImplementationOneToOne(address proxyAddress) external override onlyOwner { _lockedImplementations[proxyAddress] = true; emit OneToOne_ImplementationLocked(proxyAddress); } /** * @dev Updates the implementation address for a many-to-one * proxy relationship. * * @param implementationID Identifier for the implementation. * @param implementation Address with the runtime code the proxies * should use. */ function setImplementationAddressManyToOne( bytes32 implementationID, address implementation ) external override onlyOwner { // Read the implementation holder address from storage. address implementationHolder = _implementationHolders[implementationID]; // Verify that the implementation exists. require(implementationHolder != address(0), "ERR_IMPLEMENTATION_ID"); // Verify implementation is not locked require(!_lockedImplementations[implementationHolder], "ERR_IMPLEMENTATION_LOCKED"); // Set the implementation address _setImplementation(implementationHolder, implementation); emit ManyToOne_ImplementationUpdated( implementationID, implementation ); } /** * @dev Updates the implementation address for a one-to-one proxy. * * Note: This could work for many-to-one as well if the caller * provides the implementation holder address in place of the * proxy address, as they use the same access control and update * mechanism. * * @param proxyAddress Address of the deployed proxy * @param implementation Address with the runtime code for * the proxy to use. */ function setImplementationAddressOneToOne( address proxyAddress, address implementation ) external override onlyOwner { // Verify proxy is not locked require(!_lockedImplementations[proxyAddress], "ERR_IMPLEMENTATION_LOCKED"); // Set the implementation address _setImplementation(proxyAddress, implementation); emit OneToOne_ImplementationUpdated(proxyAddress, implementation); } /* ========== Proxy Deployment ========== */ /** * @dev Deploy a proxy contract with a one-to-one relationship * with its implementation. * * The proxy will have its own implementation address which can * be updated by the proxy manager. * * @param suppliedSalt Salt provided by the account requesting deployment. * @param implementation Address of the contract with the runtime * code that the proxy should use. */ function deployProxyOneToOne( bytes32 suppliedSalt, address implementation ) external override onlyOwner returns(address proxyAddress) { // Derive the create2 salt from the deployment requester's address // and the requester-supplied salt. bytes32 salt = Salty.deriveOneToOneSalt(_msgSender(), suppliedSalt); // Deploy the proxy proxyAddress = Create2.deploy( 0, salt, type(DelegateCallProxyOneToOne).creationCode ); // Set the implementation address on the new proxy. _setImplementation(proxyAddress, implementation); emit OneToOne_ProxyDeployed(proxyAddress, implementation); } /** * @dev Deploy a proxy with a many-to-one relationship with its implemenation. * * The proxy will call the implementation holder for every transaction to * determine the address to use in calls. * * @param implementationID Identifier for the proxy's implementation. * @param suppliedSalt Salt provided by the account requesting deployment. */ function deployProxyManyToOne(bytes32 implementationID, bytes32 suppliedSalt) external override onlyApprovedDeployer returns(address proxyAddress) { // Read the implementation holder address from storage. address implementationHolder = _implementationHolders[implementationID]; // Verify that the implementation exists. require(implementationHolder != address(0), "ERR_IMPLEMENTATION_ID"); // Derive the create2 salt from the deployment requester's address, the // implementation ID and the requester-supplied salt. bytes32 salt = Salty.deriveManyToOneSalt( _msgSender(), implementationID, suppliedSalt ); // Set the implementation holder address in storage so the proxy // constructor can query it. _implementationHolder = implementationHolder; // Deploy the proxy, which will query the implementation holder address // and save it as an immutable in the contract bytecode. proxyAddress = Create2.deploy( 0, salt, type(DelegateCallProxyManyToOne).creationCode ); // Remove the address from temporary storage. _implementationHolder = address(0); emit ManyToOne_ProxyDeployed( implementationID, proxyAddress ); } /* ========== Queries ========== */ /** * @dev Returns a boolean stating whether `implementationID` is locked. */ function isImplementationLocked(bytes32 implementationID) external override view returns (bool) { // Read the implementation holder address from storage. address implementationHolder = _implementationHolders[implementationID]; // Verify that the implementation exists. require(implementationHolder != address(0), "ERR_IMPLEMENTATION_ID"); return _lockedImplementations[implementationHolder]; } /** * @dev Returns a boolean stating whether `proxyAddress` is locked. */ function isImplementationLocked(address proxyAddress) external override view returns (bool) { return _lockedImplementations[proxyAddress]; } /** * @dev Returns a boolean stating whether `deployer` is allowed to deploy many-to-one * proxies. */ function isApprovedDeployer(address deployer) external override view returns (bool) { return _approvedDeployers[deployer]; } /** * @dev Queries the temporary storage value `_implementationHolder`. * This is used in the constructor of the many-to-one proxy contract * so that the create2 address is static (adding constructor arguments * would change the codehash) and the implementation holder can be * stored as a constant. */ function getImplementationHolder() external override view returns (address) { return _implementationHolder; } /** * @dev Returns the address of the implementation holder contract * for `implementationID`. */ function getImplementationHolder( bytes32 implementationID ) external override view returns (address) { return _implementationHolders[implementationID]; } /** * @dev Computes the create2 address for a one-to-one proxy requested * by `originator` using `suppliedSalt`. * * @param originator Address of the account requesting deployment. * @param suppliedSalt Salt provided by the account requesting deployment. */ function computeProxyAddressOneToOne( address originator, bytes32 suppliedSalt ) external override view returns (address) { bytes32 salt = Salty.deriveOneToOneSalt(originator, suppliedSalt); return Create2.computeAddress(salt, CodeHashes.ONE_TO_ONE_CODEHASH); } /** * @dev Computes the create2 address for a many-to-one proxy for the * implementation `implementationID` requested by `originator` using * `suppliedSalt`. * * @param originator Address of the account requesting deployment. * @param implementationID The identifier for the contract implementation. * @param suppliedSalt Salt provided by the account requesting deployment. */ function computeProxyAddressManyToOne( address originator, bytes32 implementationID, bytes32 suppliedSalt ) external override view returns (address) { bytes32 salt = Salty.deriveManyToOneSalt( originator, implementationID, suppliedSalt ); return Create2.computeAddress(salt, CodeHashes.MANY_TO_ONE_CODEHASH); } /** * @dev Computes the create2 address of the implementation holder * for `implementationID`. * * @param implementationID The identifier for the contract implementation. */ function computeHolderAddressManyToOne(bytes32 implementationID) public override view returns (address) { return Create2.computeAddress( implementationID, CodeHashes.IMPLEMENTATION_HOLDER_CODEHASH ); } /* ========== Internal Functions ========== */ /** * @dev Sets the implementation address for a one-to-one proxy or * many-to-one implementation holder. Both use the same access * control and update mechanism, which is the receipt of a call * from the proxy manager with the abi-encoded implementation address * as the only calldata. * * Note: Verifies that the implementation address is a contract. * * @param proxyOrHolder Address of the one-to-one proxy or * many-to-one implementation holder contract. * @param implementation Address of the contract with the runtime * code that the proxy or proxies should use. */ function _setImplementation( address proxyOrHolder, address implementation ) internal { // Verify that the implementation address is a contract. require(Address.isContract(implementation), "ERR_NOT_CONTRACT"); // Set the implementation address on the contract. // solium-disable-next-line security/no-low-level-calls (bool success,) = proxyOrHolder.call(abi.encode(implementation)); require(success, "ERR_SET_ADDRESS_REVERT"); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer. * `CREATE2` can be used to compute in advance the address where a smart * contract will be deployed, which allows for interesting new mechanisms known * as 'counterfactual interactions'. * * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more * information. */ library Create2 { /** * @dev Deploys a contract using `CREATE2`. The address where the contract * will be deployed can be known in advance via {computeAddress}. * * The bytecode for a contract can be obtained from Solidity with * `type(contractName).creationCode`. * * Requirements: * * - `bytecode` must not be empty. * - `salt` must have not been used for `bytecode` already. * - the factory must have a balance of at least `amount`. * - if `amount` is non-zero, `bytecode` must have a `payable` constructor. */ function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address) { address addr; require(address(this).balance >= amount, "Create2: insufficient balance"); require(bytecode.length != 0, "Create2: bytecode length is zero"); // solhint-disable-next-line no-inline-assembly assembly { addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt) } require(addr != address(0), "Create2: Failed on deploy"); return addr; } /** * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the * `bytecodeHash` or `salt` will result in a new destination address. */ function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) { return computeAddress(salt, bytecodeHash, address(this)); } /** * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}. */ function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address) { bytes32 _data = keccak256( abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash) ); return address(uint256(_data)); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.2; /** * @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 in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly 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"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (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"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); 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 // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; import "../GSN/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: GPL-3.0 pragma solidity =0.6.12; /** * @dev The ManyToOneImplementationHolder stores an upgradeable implementation address * in storage, which many-to-one proxies query at execution time to determine which * contract to delegate to. * * The manager can upgrade the implementation address by calling the holder with the * abi-encoded address as calldata. If any other account calls the implementation holder, * it will return the implementation address. * * This pattern was inspired by the DharmaUpgradeBeacon from 0age * https://github.com/dharma-eng/dharma-smart-wallet/blob/master/contracts/upgradeability/smart-wallet/DharmaUpgradeBeacon.sol */ contract ManyToOneImplementationHolder { /* --- Storage --- */ address internal immutable _manager; address internal _implementation; /* --- Constructor --- */ constructor() public { _manager = msg.sender; } /** * @dev Fallback function for the contract. * * Used by proxies to read the implementation address and used * by the proxy manager to set the implementation address. * * If called by the owner, reads the implementation address from * calldata (must be abi-encoded) and stores it to the first slot. * * Otherwise, returns the stored implementation address. */ fallback() external payable { if (msg.sender != _manager) { assembly { mstore(0, sload(0)) return(0, 32) } } assembly { sstore(0, calldataload(0)) } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to * be specified by overriding the virtual {_implementation} function. * * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a * different contract through the {_delegate} function. * * The success and return data of the delegated call will be returned back to the caller of the proxy. */ abstract contract Proxy { /** * @dev Delegates the current call to `implementation`. * * This function does not return to its internall call site, it will return directly to the external caller. */ function _delegate(address implementation) internal { // solhint-disable-next-line no-inline-assembly assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0, 0, calldatasize()) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) // Copy the returned data. returndatacopy(0, 0, returndatasize()) switch result // delegatecall returns 0 on error. case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } /** * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function * and {_fallback} should delegate. */ function _implementation() internal virtual view returns (address); /** * @dev Delegates the current call to the address returned by `_implementation()`. * * This function does not return to its internall call site, it will return directly to the external caller. */ function _fallback() internal { _beforeFallback(); _delegate(_implementation()); } /** * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other * function in the contract matches the call data. */ fallback () payable external { _fallback(); } /** * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data * is empty. */ receive () payable external { _fallback(); } /** * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback` * call, or as part of the Solidity `fallback` or `receive` functions. * * If overriden should call `super._beforeFallback()`. */ function _beforeFallback() internal virtual { } }
// SPDX-License-Identifier: GPL-3.0 pragma solidity =0.6.12; import { Proxy } from "@openzeppelin/contracts/proxy/Proxy.sol"; /** * @dev Upgradeable delegatecall proxy for a single contract. * * This proxy stores an implementation address which can be upgraded by the proxy manager. * * To upgrade the implementation, the manager calls the proxy with the abi encoded implementation address. * * If any other account calls the proxy, it will delegatecall the implementation address with the received * calldata and ether. If the call succeeds, it will return with the received returndata. * If it reverts, it will revert with the received revert data. * * Note: The storage slot for the implementation address is: * `bytes32(uint256(keccak256("IMPLEMENTATION_ADDRESS")) + 1)` * This slot must not be used by the implementation contract. * * Note: This contract does not verify that the implementation address is a valid delegation target. * The manager must perform this safety check. */ contract DelegateCallProxyOneToOne is Proxy { /* ========== Constants ========== */ address internal immutable _manager; /* ========== Constructor ========== */ constructor() public { _manager = msg.sender ; } /* ========== Internal Overrides ========== */ /** * @dev Reads the implementation address from storage. */ function _implementation() internal override view returns (address) { address implementation; assembly { implementation := sload( // bytes32(uint256(keccak256("IMPLEMENTATION_ADDRESS")) + 1) 0x913bd12b32b36f36cedaeb6e043912bceb97022755958701789d3108d33a045a ) } return implementation; } /** * @dev Hook that is called before falling back to the implementation. * * Checks if the call is from the owner. * If it is, reads the abi-encoded implementation address from calldata and stores * it at the slot `bytes32(uint256(keccak256("IMPLEMENTATION_ADDRESS")) + 1)`, * then returns with no data. * If it is not, continues execution with the fallback function. */ function _beforeFallback() internal override { if (msg.sender != _manager) { super._beforeFallback(); } else { assembly { sstore( // bytes32(uint256(keccak256("IMPLEMENTATION_ADDRESS")) + 1) 0x913bd12b32b36f36cedaeb6e043912bceb97022755958701789d3108d33a045a, calldataload(0) ) return(0, 0) } } } }
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.6.0; /* --- External Libraries --- */ import { Create2 } from "@openzeppelin/contracts/utils/Create2.sol"; /* --- Proxy Contracts --- */ import { CodeHashes } from "./CodeHashes.sol"; /** * @dev Library for computing create2 salts and addresses for proxies * deployed by `DelegateCallProxyManager`. * * Because the proxy factory is meant to be used by multiple contracts, * we use a salt derivation pattern that includes the address of the * contract that requested the proxy deployment, a salt provided by that * contract and the implementation ID used (for many-to-one proxies only). */ library SaltyLib { /* --- Salt Derivation --- */ /** * @dev Derives the create2 salt for a many-to-one proxy. * * Many different contracts in the Indexed framework may use the * same implementation contract, and they all use the same init * code, so we derive the actual create2 salt from a combination * of the implementation ID, the address of the account requesting * deployment and the user-supplied salt. * * @param originator Address of the account requesting deployment. * @param implementationID The identifier for the contract implementation. * @param suppliedSalt Salt provided by the account requesting deployment. */ function deriveManyToOneSalt( address originator, bytes32 implementationID, bytes32 suppliedSalt ) internal pure returns (bytes32) { return keccak256( abi.encodePacked( originator, implementationID, suppliedSalt ) ); } /** * @dev Derives the create2 salt for a one-to-one proxy. * * @param originator Address of the account requesting deployment. * @param suppliedSalt Salt provided by the account requesting deployment. */ function deriveOneToOneSalt( address originator, bytes32 suppliedSalt ) internal pure returns (bytes32) { return keccak256(abi.encodePacked(originator, suppliedSalt)); } /* --- Address Derivation --- */ /** * @dev Computes the create2 address for a one-to-one proxy deployed * by `deployer` (the factory) when requested by `originator` using * `suppliedSalt`. * * @param deployer Address of the proxy factory. * @param originator Address of the account requesting deployment. * @param suppliedSalt Salt provided by the account requesting deployment. */ function computeProxyAddressOneToOne( address deployer, address originator, bytes32 suppliedSalt ) internal pure returns (address) { bytes32 salt = deriveOneToOneSalt(originator, suppliedSalt); return Create2.computeAddress(salt, CodeHashes.ONE_TO_ONE_CODEHASH, deployer); } /** * @dev Computes the create2 address for a many-to-one proxy for the * implementation `implementationID` deployed by `deployer` (the factory) * when requested by `originator` using `suppliedSalt`. * * @param deployer Address of the proxy factory. * @param originator Address of the account requesting deployment. * @param implementationID The identifier for the contract implementation. * @param suppliedSalt Salt provided by the account requesting deployment. */ function computeProxyAddressManyToOne( address deployer, address originator, bytes32 implementationID, bytes32 suppliedSalt ) internal pure returns (address) { bytes32 salt = deriveManyToOneSalt( originator, implementationID, suppliedSalt ); return Create2.computeAddress(salt, CodeHashes.MANY_TO_ONE_CODEHASH, deployer); } /** * @dev Computes the create2 address of the implementation holder * for `implementationID`. * * @param deployer Address of the proxy factory. * @param implementationID The identifier for the contract implementation. */ function computeHolderAddressManyToOne( address deployer, bytes32 implementationID ) internal pure returns (address) { return Create2.computeAddress( implementationID, CodeHashes.IMPLEMENTATION_HOLDER_CODEHASH, deployer ); } }
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.6.0; /** * @dev Contract that manages deployment and upgrades of delegatecall proxies. * * An implementation identifier can be created on the proxy manager which is * used to specify the logic address for a particular contract type, and to * upgrade the implementation as needed. * * A one-to-one proxy is a single proxy contract with an upgradeable implementation * address. * * A many-to-one proxy is a single upgradeable implementation address that may be * used by many proxy contracts. */ interface IDelegateCallProxyManager { /* ========== Events ========== */ event DeploymentApprovalGranted(address deployer); event DeploymentApprovalRevoked(address deployer); event ManyToOne_ImplementationCreated( bytes32 implementationID, address implementationAddress ); event ManyToOne_ImplementationUpdated( bytes32 implementationID, address implementationAddress ); event ManyToOne_ProxyDeployed( bytes32 implementationID, address proxyAddress ); event OneToOne_ProxyDeployed( address proxyAddress, address implementationAddress ); event OneToOne_ImplementationUpdated( address proxyAddress, address implementationAddress ); /* ========== Controls ========== */ /** * @dev Allows `deployer` to deploy many-to-one proxies. */ function approveDeployer(address deployer) external; /** * @dev Prevents `deployer` from deploying many-to-one proxies. */ function revokeDeployerApproval(address deployer) external; /* ========== Implementation Management ========== */ /** * @dev Creates a many-to-one proxy relationship. * * Deploys an implementation holder contract which stores the * implementation address for many proxies. The implementation * address can be updated on the holder to change the runtime * code used by all its proxies. * * @param implementationID ID for the implementation, used to identify the * proxies that use it. Also used as the salt in the create2 call when * deploying the implementation holder contract. * @param implementation Address with the runtime code the proxies * should use. */ function createManyToOneProxyRelationship( bytes32 implementationID, address implementation ) external; /** * @dev Lock the current implementation for `proxyAddress` so that it can never be upgraded again. */ function lockImplementationManyToOne(bytes32 implementationID) external; /** * @dev Lock the current implementation for `proxyAddress` so that it can never be upgraded again. */ function lockImplementationOneToOne(address proxyAddress) external; /** * @dev Updates the implementation address for a many-to-one * proxy relationship. * * @param implementationID Identifier for the implementation. * @param implementation Address with the runtime code the proxies * should use. */ function setImplementationAddressManyToOne( bytes32 implementationID, address implementation ) external; /** * @dev Updates the implementation address for a one-to-one proxy. * * Note: This could work for many-to-one as well if the caller * provides the implementation holder address in place of the * proxy address, as they use the same access control and update * mechanism. * * @param proxyAddress Address of the deployed proxy * @param implementation Address with the runtime code for * the proxy to use. */ function setImplementationAddressOneToOne( address proxyAddress, address implementation ) external; /* ========== Proxy Deployment ========== */ /** * @dev Deploy a proxy contract with a one-to-one relationship * with its implementation. * * The proxy will have its own implementation address which can * be updated by the proxy manager. * * @param suppliedSalt Salt provided by the account requesting deployment. * @param implementation Address of the contract with the runtime * code that the proxy should use. */ function deployProxyOneToOne( bytes32 suppliedSalt, address implementation ) external returns(address proxyAddress); /** * @dev Deploy a proxy with a many-to-one relationship with its implemenation. * * The proxy will call the implementation holder for every transaction to * determine the address to use in calls. * * @param implementationID Identifier for the proxy's implementation. * @param suppliedSalt Salt provided by the account requesting deployment. */ function deployProxyManyToOne( bytes32 implementationID, bytes32 suppliedSalt ) external returns(address proxyAddress); /* ========== Queries ========== */ /** * @dev Returns a boolean stating whether `implementationID` is locked. */ function isImplementationLocked(bytes32 implementationID) external view returns (bool); /** * @dev Returns a boolean stating whether `proxyAddress` is locked. */ function isImplementationLocked(address proxyAddress) external view returns (bool); /** * @dev Returns a boolean stating whether `deployer` is allowed to deploy many-to-one * proxies. */ function isApprovedDeployer(address deployer) external view returns (bool); /** * @dev Queries the temporary storage value `_implementationHolder`. * This is used in the constructor of the many-to-one proxy contract * so that the create2 address is static (adding constructor arguments * would change the codehash) and the implementation holder can be * stored as a constant. */ function getImplementationHolder() external view returns (address); /** * @dev Returns the address of the implementation holder contract * for `implementationID`. */ function getImplementationHolder(bytes32 implementationID) external view returns (address); /** * @dev Computes the create2 address for a one-to-one proxy requested * by `originator` using `suppliedSalt`. * * @param originator Address of the account requesting deployment. * @param suppliedSalt Salt provided by the account requesting deployment. */ function computeProxyAddressOneToOne( address originator, bytes32 suppliedSalt ) external view returns (address); /** * @dev Computes the create2 address for a many-to-one proxy for the * implementation `implementationID` requested by `originator` using * `suppliedSalt`. * * @param originator Address of the account requesting deployment. * @param implementationID The identifier for the contract implementation. * @param suppliedSalt Salt provided by the account requesting deployment. */ function computeProxyAddressManyToOne( address originator, bytes32 implementationID, bytes32 suppliedSalt ) external view returns (address); /** * @dev Computes the create2 address of the implementation holder * for `implementationID`. * * @param implementationID The identifier for the contract implementation. */ function computeHolderAddressManyToOne(bytes32 implementationID) external view returns (address); }
{ "metadata": { "useLiteralContent": false }, "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]
Deployed Bytecode
0x60806040523661001357610011610017565b005b6100115b61001f61002f565b61002f61002a610031565b6101b0565b565b60405160009081906060906001600160a01b037f000000000000000000000000ffde4785e980a99fe10e6a87a67d243664b91b25169083818181855afa9150503d806000811461009d576040519150601f19603f3d011682016040523d82523d6000602084013e6100a2565b606091505b50915091508181906101325760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156100f75781810151838201526020016100df565b50505050905090810190601f1680156101245780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b50600081806020019051602081101561014a57600080fd5b505190506001600160a01b0381166101a9576040805162461bcd60e51b815260206004820152601760248201527f4552525f4e554c4c5f494d504c454d454e544154494f4e000000000000000000604482015290519081900360640190fd5b9250505090565b3660008037600080366000845af43d6000803e8080156101cf573d6000f35b3d6000fdfea26469706673582212209b0f8ebe5564b0d1fb938189635d5a7b33088937e2d48e4ff88b4fcf7c850bb164736f6c634300060c0033
Deployed Bytecode Sourcemap
704:1052:7:-:0;;;;;;2807:11:2;:9;:11::i;:::-;704:1052:7;;2591:11:2;2253:102;2293:17;:15;:17::i;:::-;2320:28;2330:17;:15;:17::i;:::-;2320:9;:28::i;:::-;2253:102::o;1336:418:7:-;1520:36;;1395:7;;;;1499:17;;1520:21;-1:-1:-1;;;;;1520:32:7;;1395:7;1520:36;1395:7;1520:36;:32;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1484:72;;;;1570:7;1586:4;1562:30;;;;;-1:-1:-1;;;1562:30:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1598:22;1635:4;1623:29;;;;;;;;;;;;;;;-1:-1:-1;1623:29:7;;-1:-1:-1;;;;;;1666:28:7;;1658:64;;;;;-1:-1:-1;;;1658:64:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;1735:14;-1:-1:-1;;;1336:418:7;:::o;886:887:2:-;1272:14;1269:1;1266;1253:34;1486:1;1483;1467:14;1464:1;1448:14;1441:5;1428:60;1562:16;1559:1;1556;1541:38;1600:6;1667:38;;;;1738:16;1735:1;1728:27;1667:38;1686:16;1683:1;1676:27
Swarm Source
ipfs://9b0f8ebe5564b0d1fb938189635d5a7b33088937e2d48e4ff88b4fcf7c850bb1
Loading...LoadingLoading...LoadingABI for the implementation contract at 0x48923befe0b63b6611111fbc15e45a5ef8a4224f, likely using a custom proxy implementation.
Previously recorded to be on 0x5bd628141c62a901e0a83e630ce5fafa95bbdee4.Learn more about proxy contracts in our Knowledge Base
Loading...LoadingABI for the implementation contract at 0x48923befe0b63b6611111fbc15e45a5ef8a4224f, likely using a custom proxy implementation.
Previously recorded to be on 0x5bd628141c62a901e0a83e630ce5fafa95bbdee4.Learn more about proxy contracts in our Knowledge Base
Loading...LoadingLoading...LoadingLoading...LoadingLoading...LoadingLoading...LoadingLoading...LoadingOVERVIEW
DEFI5 is a passively managed, capitalization-weighted index that tracks the top 5 tokens by market cap from the DeFi market sector defined by NDX governance. It uses a high-fee AMM to rebalance gradually toward portfolio targets, which are set by a smart contract using price data from Uniswap.
Loading...Loading[ Download: CSV Export ][ Download: CSV Export ]A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.
Address QR Code
My Address - Private Name Tag or Note
My Name Tag:
Private Name Tags (up to 35 characters) can be used for easy identification of addressesPrivate Note:
A private note (up to 500 characters) can be attached to this address.
Please DO NOT store any passwords or private keys here.Compiler specific version warnings:
The compiled contract might be susceptible to FullInlinerNonExpressionSplitArgumentEvaluationOrder (low-severity), MissingSideEffectsOnSelectorAccess (low-severity), AbiReencodingHeadOverflowWithStaticArrayCleanup (medium-severity), DirtyBytesArrayToStorage (low-severity), DataLocationChangeInInternalOverride (very low-severity), NestedCalldataArrayAbiReencodingSizeValidation (very low-severity), SignedImmutables (very low-severity), ABIDecodeTwoDimensionalArrayMemory (very low-severity), KeccakCaching (medium-severity), EmptyByteArrayCopy (medium-severity), DynamicArrayCleanup (medium-severity) Solidity Compiler Bugs.
Connect a Wallet
Connecting wallet for read function is optional, useful if you want to call certain functions or simply use your wallet's node.Connect a Wallet
Connecting wallet for read function is optional, useful if you want to call certain functions or simply use your wallet's node.Connect a Wallet
Connecting wallet for read function is optional, useful if you want to call certain functions or simply use your wallet's node.SignIn
Address Cards
To use this feature, please login to your Etherscan account and return to this page.Before You Copy
Transaction Private Note
This website uses cookies to improve your experience. By continuing to use this website, you agree to its Terms and Privacy Policy.