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
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 13502862 | 972 days ago | IN | Create: NFTXVaultFactoryUpgradeable | 0 ETH | 0.59234477 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
NFTXVaultFactoryUpgradeable
Compiler Version
v0.8.4+commit.c7e474f2
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2021-10-28 */ // Sources flattened with hardhat v2.6.6 https://hardhat.org // File contracts/solidity/proxy/IBeacon.sol // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev This is the interface that {BeaconProxy} expects of its beacon. */ interface IBeacon { /** * @dev Must return an address that can be used as a delegate call target. * * {BeaconProxy} will check that this address is a contract. */ function childImplementation() external view returns (address); function upgradeChildTo(address newImplementation) external; } // File contracts/solidity/interface/INFTXVaultFactory.sol pragma solidity ^0.8.0; interface INFTXVaultFactory is IBeacon { // Read functions. function numVaults() external view returns (uint256); function zapContract() external view returns (address); function feeDistributor() external view returns (address); function eligibilityManager() external view returns (address); function vault(uint256 vaultId) external view returns (address); function allVaults() external view returns (address[] memory); function vaultsForAsset(address asset) external view returns (address[] memory); function isLocked(uint256 id) external view returns (bool); function excludedFromFees(address addr) external view returns (bool); function factoryMintFee() external view returns (uint64); function factoryRandomRedeemFee() external view returns (uint64); function factoryTargetRedeemFee() external view returns (uint64); function factoryRandomSwapFee() external view returns (uint64); function factoryTargetSwapFee() external view returns (uint64); function vaultFees(uint256 vaultId) external view returns (uint256, uint256, uint256, uint256, uint256); event NewFeeDistributor(address oldDistributor, address newDistributor); event NewZapContract(address oldZap, address newZap); event FeeExclusion(address feeExcluded, bool excluded); event NewEligibilityManager(address oldEligManager, address newEligManager); event NewVault(uint256 indexed vaultId, address vaultAddress, address assetAddress); event UpdateVaultFees(uint256 vaultId, uint256 mintFee, uint256 randomRedeemFee, uint256 targetRedeemFee, uint256 randomSwapFee, uint256 targetSwapFee); event DisableVaultFees(uint256 vaultId); event UpdateFactoryFees(uint256 mintFee, uint256 randomRedeemFee, uint256 targetRedeemFee, uint256 randomSwapFee, uint256 targetSwapFee); // Write functions. function __NFTXVaultFactory_init(address _vaultImpl, address _feeDistributor) external; function createVault( string calldata name, string calldata symbol, address _assetAddress, bool is1155, bool allowAllItems ) external returns (uint256); function setFeeDistributor(address _feeDistributor) external; function setEligibilityManager(address _eligibilityManager) external; function setZapContract(address _zapContract) external; function setFeeExclusion(address _excludedAddr, bool excluded) external; function setFactoryFees( uint256 mintFee, uint256 randomRedeemFee, uint256 targetRedeemFee, uint256 randomSwapFee, uint256 targetSwapFee ) external; function setVaultFees( uint256 vaultId, uint256 mintFee, uint256 randomRedeemFee, uint256 targetRedeemFee, uint256 randomSwapFee, uint256 targetSwapFee ) external; function disableVaultFees(uint256 vaultId) external; } // File contracts/solidity/interface/INFTXLPStaking.sol pragma solidity ^0.8.0; interface INFTXLPStaking { function nftxVaultFactory() external view returns (address); function rewardDistTokenImpl() external view returns (address); function stakingTokenProvider() external view returns (address); function vaultToken(address _stakingToken) external view returns (address); function stakingToken(address _vaultToken) external view returns (address); function rewardDistributionToken(uint256 vaultId) external view returns (address); function newRewardDistributionToken(uint256 vaultId) external view returns (address); function oldRewardDistributionToken(uint256 vaultId) external view returns (address); function unusedRewardDistributionToken(uint256 vaultId) external view returns (address); function rewardDistributionTokenAddr(address stakingToken, address rewardToken) external view returns (address); // Write functions. function __NFTXLPStaking__init(address _stakingTokenProvider) external; function setNFTXVaultFactory(address newFactory) external; function setStakingTokenProvider(address newProvider) external; function addPoolForVault(uint256 vaultId) external; function updatePoolForVault(uint256 vaultId) external; function updatePoolForVaults(uint256[] calldata vaultId) external; function receiveRewards(uint256 vaultId, uint256 amount) external returns (bool); function deposit(uint256 vaultId, uint256 amount) external; function timelockDepositFor(uint256 vaultId, address account, uint256 amount, uint256 timelockLength) external; function exit(uint256 vaultId, uint256 amount) external; function rescue(uint256 vaultId) external; function withdraw(uint256 vaultId, uint256 amount) external; function claimRewards(uint256 vaultId) external; } // File contracts/solidity/interface/INFTXFeeDistributor.sol pragma solidity ^0.8.0; interface INFTXFeeDistributor { struct FeeReceiver { uint256 allocPoint; address receiver; bool isContract; } function nftxVaultFactory() external returns (address); function lpStaking() external returns (address); function treasury() external returns (address); function defaultTreasuryAlloc() external returns (uint256); function defaultLPAlloc() external returns (uint256); function allocTotal(uint256 vaultId) external returns (uint256); function specificTreasuryAlloc(uint256 vaultId) external returns (uint256); // Write functions. function __FeeDistributor__init__(address _lpStaking, address _treasury) external; function rescueTokens(address token) external; function distribute(uint256 vaultId) external; function addReceiver(uint256 _vaultId, uint256 _allocPoint, address _receiver, bool _isContract) external; function initializeVaultReceivers(uint256 _vaultId) external; function changeMultipleReceiverAlloc( uint256[] memory _vaultIds, uint256[] memory _receiverIdxs, uint256[] memory allocPoints ) external; function changeMultipleReceiverAddress( uint256[] memory _vaultIds, uint256[] memory _receiverIdxs, address[] memory addresses, bool[] memory isContracts ) external; function changeReceiverAlloc(uint256 _vaultId, uint256 _idx, uint256 _allocPoint) external; function changeReceiverAddress(uint256 _vaultId, uint256 _idx, address _address, bool _isContract) external; function removeReceiver(uint256 _vaultId, uint256 _receiverIdx) external; // Configuration functions. function setTreasuryAddress(address _treasury) external; function setDefaultTreasuryAlloc(uint256 _allocPoint) external; function setSpecificTreasuryAlloc(uint256 _vaultId, uint256 _allocPoint) external; function setLPStakingAddress(address _lpStaking) external; function setNFTXVaultFactory(address _factory) external; function setDefaultLPAlloc(uint256 _allocPoint) external; } // File contracts/solidity/proxy/ClonesUpgradeable.sol pragma solidity ^0.8.0; /** * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for * deploying minimal proxy contracts, also known as "clones". * * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies * > a minimal bytecode implementation that delegates all calls to a known, fixed address. * * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2` * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the * deterministic method. * * _Available since v3.4._ */ library ClonesUpgradeable { /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`. * * This function uses the create opcode, which should never revert. */ function clone(address implementation) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, implementation)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create(0, ptr, 0x37) } require(instance != address(0), "ERC1167: create failed"); } /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `implementation` and `salt` multiple time will revert, since * the clones cannot be deployed twice at the same address. */ function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, implementation)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create2(0, ptr, 0x37, salt) } require(instance != address(0), "ERC1167: create2 failed"); } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address implementation, bytes32 salt, address deployer) internal pure returns (address predicted) { // solhint-disable-next-line no-inline-assembly assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, implementation)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000) mstore(add(ptr, 0x38), shl(0x60, deployer)) mstore(add(ptr, 0x4c), salt) mstore(add(ptr, 0x6c), keccak256(ptr, 0x37)) predicted := keccak256(add(ptr, 0x37), 0x55) } } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) { return predictDeterministicAddress(implementation, salt, address(this)); } } // File contracts/solidity/proxy/Proxy.sol pragma solidity ^0.8.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 virtual { // 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 view virtual 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 virtual { _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 () external payable virtual { _fallback(); } /** * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data * is empty. */ receive () external payable virtual { _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 { } } // File contracts/solidity/util/Address.sol pragma solidity ^0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // 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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File contracts/solidity/proxy/BeaconProxy.sol pragma solidity ^0.8.0; /** * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}. * * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't * conflict with the storage layout of the implementation behind the proxy. * * _Available since v3.4._ */ contract BeaconProxy is Proxy { /** * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor. */ bytes32 private constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; /** * @dev Initializes the proxy with `beacon`. * * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity * constructor. * * Requirements: * * - `beacon` must be a contract with the interface {IBeacon}. */ constructor(address beacon, bytes memory data) payable { assert(_BEACON_SLOT == bytes32(uint256(keccak256("eip1967.proxy.beacon")) - 1)); _setBeacon(beacon, data); } /** * @dev Returns the current beacon address. */ function _beacon() internal view virtual returns (address beacon) { bytes32 slot = _BEACON_SLOT; // solhint-disable-next-line no-inline-assembly assembly { beacon := sload(slot) } } /** * @dev Returns the current implementation address of the associated beacon. */ function _implementation() internal view virtual override returns (address) { return IBeacon(_beacon()).childImplementation(); } /** * @dev Changes the proxy to use a new beacon. * * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. * * Requirements: * * - `beacon` must be a contract. * - The implementation returned by `beacon` must be a contract. */ function _setBeacon(address beacon, bytes memory data) internal virtual { require( Address.isContract(beacon), "BeaconProxy: beacon is not a contract" ); require( Address.isContract(IBeacon(beacon).childImplementation()), "BeaconProxy: beacon implementation is not a contract" ); bytes32 slot = _BEACON_SLOT; // solhint-disable-next-line no-inline-assembly assembly { sstore(slot, beacon) } if (data.length > 0) { Address.functionDelegateCall(_implementation(), data, "BeaconProxy: function call failed"); } } } // File contracts/solidity/proxy/Initializable.sol // solhint-disable-next-line compiler-version pragma solidity ^0.8.0; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. */ bool private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Modifier to protect an initializer function from being invoked twice. */ modifier initializer() { require(_initializing || !_initialized, "Initializable: contract is already initialized"); bool isTopLevelCall = !_initializing; if (isTopLevelCall) { _initializing = true; _initialized = true; } _; if (isTopLevelCall) { _initializing = false; } } } // File contracts/solidity/util/ContextUpgradeable.sol pragma solidity ^0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract ContextUpgradeable is Initializable { function __Context_init() internal initializer { __Context_init_unchained(); } function __Context_init_unchained() internal initializer { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } uint256[50] private __gap; } // File contracts/solidity/util/OwnableUpgradeable.sol pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal initializer { __Context_init_unchained(); __Ownable_init_unchained(); } function __Ownable_init_unchained() internal initializer { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual 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; } uint256[49] private __gap; } // File contracts/solidity/proxy/UpgradeableBeacon.sol pragma solidity ^0.8.0; /** * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their * implementation contract, which is where they will delegate all function calls. * * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon. */ contract UpgradeableBeacon is IBeacon, OwnableUpgradeable { address private _childImplementation; /** * @dev Emitted when the child implementation returned by the beacon is changed. */ event Upgraded(address indexed childImplementation); /** * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the * beacon. */ function __UpgradeableBeacon__init(address childImplementation_) public initializer { _setChildImplementation(childImplementation_); } /** * @dev Returns the current child implementation address. */ function childImplementation() public view virtual override returns (address) { return _childImplementation; } /** * @dev Upgrades the beacon to a new implementation. * * Emits an {Upgraded} event. * * Requirements: * * - msg.sender must be the owner of the contract. * - `newChildImplementation` must be a contract. */ function upgradeChildTo(address newChildImplementation) public virtual override onlyOwner { _setChildImplementation(newChildImplementation); } /** * @dev Sets the implementation contract address for this beacon * * Requirements: * * - `newChildImplementation` must be a contract. */ function _setChildImplementation(address newChildImplementation) private { require(Address.isContract(newChildImplementation), "UpgradeableBeacon: child implementation is not a contract"); _childImplementation = newChildImplementation; emit Upgraded(newChildImplementation); } } // File contracts/solidity/util/SafeMathUpgradeable.sol pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler * now has built in overflow checking. */ library SafeMathUpgradeable { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. */ function toInt256(uint256 value) internal pure returns (int256) { require(value < 2**255, "SafeCast: value doesn't fit in an int256"); return int256(value); } } // File contracts/solidity/util/PausableUpgradeable.sol pragma solidity ^0.8.0; contract PausableUpgradeable is OwnableUpgradeable { function __Pausable_init() internal initializer { __Ownable_init(); } event SetPaused(uint256 lockId, bool paused); event SetIsGuardian(address addr, bool isGuardian); mapping(address => bool) public isGuardian; mapping(uint256 => bool) public isPaused; // 0 : createVault // 1 : mint // 2 : redeem // 3 : swap // 4 : flashloan function onlyOwnerIfPaused(uint256 lockId) public view virtual { require(!isPaused[lockId] || msg.sender == owner(), "Paused"); } function unpause(uint256 lockId) public virtual onlyOwner { isPaused[lockId] = false; emit SetPaused(lockId, false); } function pause(uint256 lockId) public virtual { require(isGuardian[msg.sender], "Can't pause"); isPaused[lockId] = true; emit SetPaused(lockId, true); } function setIsGuardian(address addr, bool _isGuardian) public virtual onlyOwner { isGuardian[addr] = _isGuardian; emit SetIsGuardian(addr, _isGuardian); } } // File contracts/solidity/interface/INFTXEligibility.sol pragma solidity ^0.8.0; interface INFTXEligibility { // Read functions. function name() external pure returns (string memory); function finalized() external view returns (bool); function targetAsset() external pure returns (address); function checkAllEligible(uint256[] calldata tokenIds) external view returns (bool); function checkEligible(uint256[] calldata tokenIds) external view returns (bool[] memory); function checkAllIneligible(uint256[] calldata tokenIds) external view returns (bool); function checkIsEligible(uint256 tokenId) external view returns (bool); // Write functions. function __NFTXEligibility_init_bytes(bytes calldata configData) external; function beforeMintHook(uint256[] calldata tokenIds) external; function afterMintHook(uint256[] calldata tokenIds) external; function beforeRedeemHook(uint256[] calldata tokenIds) external; function afterRedeemHook(uint256[] calldata tokenIds) external; } // File contracts/solidity/token/IERC20Upgradeable.sol pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20Upgradeable { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } // File contracts/solidity/interface/INFTXVault.sol pragma solidity ^0.8.0; interface INFTXVault is IERC20Upgradeable { function manager() external view returns (address); function assetAddress() external view returns (address); function vaultFactory() external view returns (INFTXVaultFactory); function eligibilityStorage() external view returns (INFTXEligibility); function is1155() external view returns (bool); function allowAllItems() external view returns (bool); function enableMint() external view returns (bool); function enableRandomRedeem() external view returns (bool); function enableTargetRedeem() external view returns (bool); function enableRandomSwap() external view returns (bool); function enableTargetSwap() external view returns (bool); function vaultId() external view returns (uint256); function nftIdAt(uint256 holdingsIndex) external view returns (uint256); function allHoldings() external view returns (uint256[] memory); function totalHoldings() external view returns (uint256); function mintFee() external view returns (uint256); function randomRedeemFee() external view returns (uint256); function targetRedeemFee() external view returns (uint256); function randomSwapFee() external view returns (uint256); function targetSwapFee() external view returns (uint256); function vaultFees() external view returns (uint256, uint256, uint256, uint256, uint256); event VaultInit( uint256 indexed vaultId, address assetAddress, bool is1155, bool allowAllItems ); event ManagerSet(address manager); event EligibilityDeployed(uint256 moduleIndex, address eligibilityAddr); // event CustomEligibilityDeployed(address eligibilityAddr); event EnableMintUpdated(bool enabled); event EnableRandomRedeemUpdated(bool enabled); event EnableTargetRedeemUpdated(bool enabled); event EnableRandomSwapUpdated(bool enabled); event EnableTargetSwapUpdated(bool enabled); event Minted(uint256[] nftIds, uint256[] amounts, address to); event Redeemed(uint256[] nftIds, uint256[] specificIds, address to); event Swapped( uint256[] nftIds, uint256[] amounts, uint256[] specificIds, uint256[] redeemedIds, address to ); function __NFTXVault_init( string calldata _name, string calldata _symbol, address _assetAddress, bool _is1155, bool _allowAllItems ) external; function finalizeVault() external; function setVaultMetadata( string memory name_, string memory symbol_ ) external; function setVaultFeatures( bool _enableMint, bool _enableRandomRedeem, bool _enableTargetRedeem, bool _enableRandomSwap, bool _enableTargetSwap ) external; function setFees( uint256 _mintFee, uint256 _randomRedeemFee, uint256 _targetRedeemFee, uint256 _randomSwapFee, uint256 _targetSwapFee ) external; function disableVaultFees() external; // This function allows for an easy setup of any eligibility module contract from the EligibilityManager. // It takes in ABI encoded parameters for the desired module. This is to make sure they can all follow // a similar interface. function deployEligibilityStorage( uint256 moduleIndex, bytes calldata initData ) external returns (address); // The manager has control over options like fees and features function setManager(address _manager) external; function mint( uint256[] calldata tokenIds, uint256[] calldata amounts /* ignored for ERC721 vaults */ ) external returns (uint256); function mintTo( uint256[] calldata tokenIds, uint256[] calldata amounts, /* ignored for ERC721 vaults */ address to ) external returns (uint256); function redeem(uint256 amount, uint256[] calldata specificIds) external returns (uint256[] calldata); function redeemTo( uint256 amount, uint256[] calldata specificIds, address to ) external returns (uint256[] calldata); function swap( uint256[] calldata tokenIds, uint256[] calldata amounts, /* ignored for ERC721 vaults */ uint256[] calldata specificIds ) external returns (uint256[] calldata); function swapTo( uint256[] calldata tokenIds, uint256[] calldata amounts, /* ignored for ERC721 vaults */ uint256[] calldata specificIds, address to ) external returns (uint256[] calldata); function allValidNFTs(uint256[] calldata tokenIds) external view returns (bool); } // File contracts/solidity/interface/INFTXEligibilityManager.sol pragma solidity ^0.8.0; interface INFTXEligibilityManager { function nftxVaultFactory() external returns (address); function eligibilityImpl() external returns (address); function deployEligibility(uint256 vaultId, bytes calldata initData) external returns (address); } // File contracts/solidity/interface/IERC165Upgradeable.sol pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165Upgradeable { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File contracts/solidity/interface/IERC3156Upgradeable.sol pragma solidity ^0.8.0; /** * @dev Interface of the ERC3156 FlashBorrower, as defined in * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156]. */ interface IERC3156FlashBorrowerUpgradeable { /** * @dev Receive a flash loan. * @param initiator The initiator of the loan. * @param token The loan currency. * @param amount The amount of tokens lent. * @param fee The additional amount of tokens to repay. * @param data Arbitrary data structure, intended to contain user-defined parameters. * @return The keccak256 hash of "ERC3156FlashBorrower.onFlashLoan" */ function onFlashLoan( address initiator, address token, uint256 amount, uint256 fee, bytes calldata data ) external returns (bytes32); } /** * @dev Interface of the ERC3156 FlashLender, as defined in * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156]. */ interface IERC3156FlashLenderUpgradeable { /** * @dev The amount of currency available to be lended. * @param token The loan currency. * @return The amount of `token` that can be borrowed. */ function maxFlashLoan( address token ) external view returns (uint256); /** * @dev The fee to be charged for a given loan. * @param token The loan currency. * @param amount The amount of tokens lent. * @return The amount of `token` to be charged for the loan, on top of the returned principal. */ function flashFee( address token, uint256 amount ) external view returns (uint256); /** * @dev Initiate a flash loan. * @param receiver The receiver of the tokens in the loan, and the receiver of the callback. * @param token The loan currency. * @param amount The amount of tokens lent. * @param data Arbitrary data structure, intended to contain user-defined parameters. */ function flashLoan( IERC3156FlashBorrowerUpgradeable receiver, address token, uint256 amount, bytes calldata data ) external returns (bool); } // File contracts/solidity/token/IERC20Metadata.sol pragma solidity ^0.8.0; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20Upgradeable { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } // File contracts/solidity/token/ERC20Upgradeable.sol pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20Metadata { mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ function __ERC20_init(string memory name_, string memory symbol_) internal initializer { __Context_init_unchained(); __ERC20_init_unchained(name_, symbol_); } function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer { _name = name_; _symbol = symbol_; } function _setMetadata(string memory name_, string memory symbol_) internal { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); _approve(sender, _msgSender(), currentAllowance - amount); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); _approve(_msgSender(), spender, currentAllowance - subtractedValue); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); _balances[sender] = senderBalance - amount; _balances[recipient] += amount; emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); _balances[account] = accountBalance - amount; _totalSupply -= amount; emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } uint256[45] private __gap; } // File contracts/solidity/token/ERC20FlashMintUpgradeable.sol pragma solidity ^0.8.0; /** * @dev Implementation of the ERC3156 Flash loans extension, as defined in * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156]. * * Adds the {flashLoan} method, which provides flash loan support at the token * level. By default there is no fee, but this can be changed by overriding {flashFee}. */ abstract contract ERC20FlashMintUpgradeable is Initializable, ERC20Upgradeable, IERC3156FlashLenderUpgradeable { function __ERC20FlashMint_init() internal initializer { __Context_init_unchained(); __ERC20FlashMint_init_unchained(); } function __ERC20FlashMint_init_unchained() internal initializer { } bytes32 constant private RETURN_VALUE = keccak256("ERC3156FlashBorrower.onFlashLoan"); /** * @dev Returns the maximum amount of tokens available for loan. * @param token The address of the token that is requested. * @return The amont of token that can be loaned. */ function maxFlashLoan(address token) public view override returns (uint256) { return token == address(this) ? type(uint256).max - totalSupply() : 0; } /** * @dev Returns the fee applied when doing flash loans. By default this * implementation has 0 fees. This function can be overloaded to make * the flash loan mechanism deflationary. * @param token The token to be flash loaned. * @param amount The amount of tokens to be loaned. * @return The fees applied to the corresponding flash loan. */ function flashFee(address token, uint256 amount) public view virtual override returns (uint256) { require(token == address(this), "ERC20FlashMint: wrong token"); // silence warning about unused variable without the addition of bytecode. amount; return 0; } /** * @dev Performs a flash loan. New tokens are minted and sent to the * `receiver`, who is required to implement the {IERC3156FlashBorrower} * interface. By the end of the flash loan, the receiver is expected to own * amount + fee tokens and have them approved back to the token contract itself so * they can be burned. * @param receiver The receiver of the flash loan. Should implement the * {IERC3156FlashBorrower.onFlashLoan} interface. * @param token The token to be flash loaned. Only `address(this)` is * supported. * @param amount The amount of tokens to be loaned. * @param data An arbitrary datafield that is passed to the receiver. * @return `true` is the flash loan was successfull. */ function flashLoan( IERC3156FlashBorrowerUpgradeable receiver, address token, uint256 amount, bytes memory data ) public virtual override returns (bool) { uint256 fee = flashFee(token, amount); _mint(address(receiver), amount); require(receiver.onFlashLoan(msg.sender, token, amount, fee, data) == RETURN_VALUE, "ERC20FlashMint: invalid return value"); uint256 currentAllowance = allowance(address(receiver), address(this)); require(currentAllowance >= amount + fee, "ERC20FlashMint: allowance does not allow refund"); _approve(address(receiver), address(this), currentAllowance - amount - fee); _burn(address(receiver), amount + fee); return true; } uint256[50] private __gap; } // File contracts/solidity/token/IERC721ReceiverUpgradeable.sol pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721ReceiverUpgradeable { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`. */ function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4); } // File contracts/solidity/token/ERC721SafeHolderUpgradeable.sol pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC721Receiver} interface. * * Accepts all token transfers. * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}. */ contract ERC721SafeHolderUpgradeable is IERC721ReceiverUpgradeable { /** * @dev See {IERC721Receiver-onERC721Received}. * * Always returns `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address, uint256, bytes memory ) public virtual override returns (bytes4) { return this.onERC721Received.selector; } } // File contracts/solidity/token/IERC1155ReceiverUpgradeable.sol pragma solidity ^0.8.0; /** * @dev _Available since v3.1._ */ interface IERC1155ReceiverUpgradeable is IERC165Upgradeable { /** @dev Handles the receipt of a single ERC1155 token type. This function is called at the end of a `safeTransferFrom` after the balance has been updated. To accept the transfer, this must return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` (i.e. 0xf23a6e61, or its own function selector). @param operator The address which initiated the transfer (i.e. msg.sender) @param from The address which previously owned the token @param id The ID of the token being transferred @param value The amount of tokens being transferred @param data Additional data with no specified format @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns(bytes4); /** @dev Handles the receipt of a multiple ERC1155 token types. This function is called at the end of a `safeBatchTransferFrom` after the balances have been updated. To accept the transfer(s), this must return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` (i.e. 0xbc197c81, or its own function selector). @param operator The address which initiated the batch transfer (i.e. msg.sender) @param from The address which previously owned the token @param ids An array containing ids of each token being transferred (order and length must match values array) @param values An array containing amounts of each token being transferred (order and length must match ids array) @param data Additional data with no specified format @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns(bytes4); } // File contracts/solidity/util/ERC165Upgradeable.sol pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165Upgradeable is IERC165Upgradeable { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165Upgradeable).interfaceId; } } // File contracts/solidity/token/ERC1155ReceiverUpgradeable.sol pragma solidity ^0.8.0; /** * @dev _Available since v3.1._ */ abstract contract ERC1155ReceiverUpgradeable is ERC165Upgradeable, IERC1155ReceiverUpgradeable { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) { return interfaceId == type(IERC1155ReceiverUpgradeable).interfaceId || super.supportsInterface(interfaceId); } } // File contracts/solidity/token/ERC1155SafeHolderUpgradeable.sol pragma solidity ^0.8.0; /** * @dev _Available since v3.1._ */ abstract contract ERC1155SafeHolderUpgradeable is ERC1155ReceiverUpgradeable { function onERC1155Received(address operator, address, uint256, uint256, bytes memory) public virtual override returns (bytes4) { return this.onERC1155Received.selector; } function onERC1155BatchReceived(address operator, address, uint256[] memory, uint256[] memory, bytes memory) public virtual override returns (bytes4) { return this.onERC1155BatchReceived.selector; } } // File contracts/solidity/token/IERC721Upgradeable.sol pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721Upgradeable is IERC165Upgradeable { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; } // File contracts/solidity/token/IERC1155Upgradeable.sol pragma solidity ^0.8.0; /** * @dev Required interface of an ERC1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[EIP]. * * _Available since v3.1._ */ interface IERC1155Upgradeable is IERC165Upgradeable { /** * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the amount of tokens of token type `id` owned by `account`. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the caller. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data) external; } // File contracts/solidity/util/ReentrancyGuardUpgradeable.sol pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuardUpgradeable is Initializable { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; function __ReentrancyGuard_init() internal initializer { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal initializer { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } uint256[49] private __gap; } // File contracts/solidity/util/EnumerableSetUpgradeable.sol pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. */ library EnumerableSetUpgradeable { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping (bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } } // File contracts/solidity/NFTXVaultUpgradeable.sol pragma solidity ^0.8.0; // Authors: @0xKiwi_ and @alexgausman. contract NFTXVaultUpgradeable is OwnableUpgradeable, ERC20FlashMintUpgradeable, ReentrancyGuardUpgradeable, ERC721SafeHolderUpgradeable, ERC1155SafeHolderUpgradeable, INFTXVault { using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet; uint256 constant base = 10**18; uint256 public override vaultId; address public override manager; address public override assetAddress; INFTXVaultFactory public override vaultFactory; INFTXEligibility public override eligibilityStorage; uint256 randNonce; uint256 private UNUSED_FEE1; uint256 private UNUSED_FEE2; uint256 private UNUSED_FEE3; bool public override is1155; bool public override allowAllItems; bool public override enableMint; bool public override enableRandomRedeem; bool public override enableTargetRedeem; EnumerableSetUpgradeable.UintSet holdings; mapping(uint256 => uint256) quantity1155; bool public override enableRandomSwap; bool public override enableTargetSwap; function __NFTXVault_init( string memory _name, string memory _symbol, address _assetAddress, bool _is1155, bool _allowAllItems ) public override virtual initializer { __Ownable_init(); __ERC20_init(_name, _symbol); require(_assetAddress != address(0), "Asset != address(0)"); assetAddress = _assetAddress; vaultFactory = INFTXVaultFactory(msg.sender); vaultId = vaultFactory.numVaults(); is1155 = _is1155; allowAllItems = _allowAllItems; emit VaultInit(vaultId, _assetAddress, _is1155, _allowAllItems); setVaultFeatures(true /*enableMint*/, true /*enableRandomRedeem*/, true /*enableTargetRedeem*/, true /*enableRandomSwap*/, true /*enableTargetSwap*/); } function finalizeVault() external override virtual { setManager(address(0)); } // Added in v1.0.3. function setVaultMetadata( string memory name_, string memory symbol_ ) public override virtual { onlyPrivileged(); _setMetadata(name_, symbol_); } function setVaultFeatures( bool _enableMint, bool _enableRandomRedeem, bool _enableTargetRedeem, bool _enableRandomSwap, bool _enableTargetSwap ) public override virtual { onlyPrivileged(); enableMint = _enableMint; enableRandomRedeem = _enableRandomRedeem; enableTargetRedeem = _enableTargetRedeem; enableRandomSwap = _enableRandomSwap; enableTargetSwap = _enableTargetSwap; emit EnableMintUpdated(_enableMint); emit EnableRandomRedeemUpdated(_enableRandomRedeem); emit EnableTargetRedeemUpdated(_enableTargetRedeem); emit EnableRandomSwapUpdated(_enableRandomSwap); emit EnableTargetSwapUpdated(_enableTargetSwap); } function assignDefaultFeatures() external { require(msg.sender == 0xDEA9196Dcdd2173D6E369c2AcC0faCc83fD9346a, "Not dev"); enableRandomSwap = enableRandomRedeem; enableTargetSwap = enableTargetRedeem; emit EnableRandomSwapUpdated(enableRandomSwap); emit EnableTargetSwapUpdated(enableTargetSwap); } function setFees( uint256 _mintFee, uint256 _randomRedeemFee, uint256 _targetRedeemFee, uint256 _randomSwapFee, uint256 _targetSwapFee ) public override virtual { onlyPrivileged(); vaultFactory.setVaultFees(vaultId, _mintFee, _randomRedeemFee, _targetRedeemFee, _randomSwapFee, _targetSwapFee); } function disableVaultFees() public override virtual { onlyPrivileged(); vaultFactory.disableVaultFees(vaultId); } // This function allows for an easy setup of any eligibility module contract from the EligibilityManager. // It takes in ABI encoded parameters for the desired module. This is to make sure they can all follow // a similar interface. function deployEligibilityStorage( uint256 moduleIndex, bytes calldata initData ) external override virtual returns (address) { onlyPrivileged(); require( address(eligibilityStorage) == address(0), "NFTXVault: eligibility already set" ); INFTXEligibilityManager eligManager = INFTXEligibilityManager( vaultFactory.eligibilityManager() ); address _eligibility = eligManager.deployEligibility( moduleIndex, initData ); eligibilityStorage = INFTXEligibility(_eligibility); // Toggle this to let the contract know to check eligibility now. allowAllItems = false; emit EligibilityDeployed(moduleIndex, _eligibility); return _eligibility; } // // This function allows for the manager to set their own arbitrary eligibility contract. // // Once eligiblity is set, it cannot be unset or changed. // Disabled for launch. // function setEligibilityStorage(address _newEligibility) public virtual { // onlyPrivileged(); // require( // address(eligibilityStorage) == address(0), // "NFTXVault: eligibility already set" // ); // eligibilityStorage = INFTXEligibility(_newEligibility); // // Toggle this to let the contract know to check eligibility now. // allowAllItems = false; // emit CustomEligibilityDeployed(address(_newEligibility)); // } // The manager has control over options like fees and features function setManager(address _manager) public override virtual { onlyPrivileged(); manager = _manager; emit ManagerSet(_manager); } function mint( uint256[] calldata tokenIds, uint256[] calldata amounts /* ignored for ERC721 vaults */ ) external override virtual returns (uint256) { return mintTo(tokenIds, amounts, msg.sender); } function mintTo( uint256[] memory tokenIds, uint256[] memory amounts, /* ignored for ERC721 vaults */ address to ) public override virtual nonReentrant returns (uint256) { onlyOwnerIfPaused(1); require(enableMint, "Minting not enabled"); // Take the NFTs. uint256 count = receiveNFTs(tokenIds, amounts); // Mint to the user. _mint(to, base * count); uint256 totalFee = mintFee() * count; _chargeAndDistributeFees(to, totalFee); emit Minted(tokenIds, amounts, to); return count; } function redeem(uint256 amount, uint256[] calldata specificIds) external override virtual returns (uint256[] memory) { return redeemTo(amount, specificIds, msg.sender); } function redeemTo(uint256 amount, uint256[] memory specificIds, address to) public override virtual nonReentrant returns (uint256[] memory) { onlyOwnerIfPaused(2); require( amount == specificIds.length || enableRandomRedeem, "NFTXVault: Random redeem not enabled" ); require( specificIds.length == 0 || enableTargetRedeem, "NFTXVault: Target redeem not enabled" ); // We burn all from sender and mint to fee receiver to reduce costs. _burn(msg.sender, base * amount); // Pay the tokens + toll. uint256 totalFee = (targetRedeemFee() * specificIds.length) + ( randomRedeemFee() * (amount - specificIds.length) ); _chargeAndDistributeFees(msg.sender, totalFee); // Withdraw from vault. uint256[] memory redeemedIds = withdrawNFTsTo(amount, specificIds, to); emit Redeemed(redeemedIds, specificIds, to); return redeemedIds; } function swap( uint256[] calldata tokenIds, uint256[] calldata amounts, /* ignored for ERC721 vaults */ uint256[] calldata specificIds ) external override virtual returns (uint256[] memory) { return swapTo(tokenIds, amounts, specificIds, msg.sender); } function swapTo( uint256[] memory tokenIds, uint256[] memory amounts, /* ignored for ERC721 vaults */ uint256[] memory specificIds, address to ) public override virtual nonReentrant returns (uint256[] memory) { onlyOwnerIfPaused(3); uint256 count; if (is1155) { for (uint256 i = 0; i < tokenIds.length; i++) { uint256 amount = amounts[i]; require(amount > 0, "NFTXVault: transferring < 1"); count += amount; } } else { count = tokenIds.length; } require( count == specificIds.length || enableRandomSwap, "NFTXVault: Random swap disabled" ); require( specificIds.length == 0 || enableTargetSwap, "NFTXVault: Target swap disabled" ); uint256 totalFee = (targetSwapFee() * specificIds.length) + ( randomSwapFee() * (count - specificIds.length) ); _chargeAndDistributeFees(msg.sender, totalFee); // Give the NFTs first, so the user wont get the same thing back, just to be nice. uint256[] memory ids = withdrawNFTsTo(count, specificIds, to); receiveNFTs(tokenIds, amounts); emit Swapped(tokenIds, amounts, specificIds, ids, to); return ids; } function flashLoan( IERC3156FlashBorrowerUpgradeable receiver, address token, uint256 amount, bytes memory data ) public override virtual returns (bool) { onlyOwnerIfPaused(4); return super.flashLoan(receiver, token, amount, data); } function mintFee() public view override virtual returns (uint256) { (uint256 _mintFee, , , ,) = vaultFactory.vaultFees(vaultId); return _mintFee; } function randomRedeemFee() public view override virtual returns (uint256) { (, uint256 _randomRedeemFee, , ,) = vaultFactory.vaultFees(vaultId); return _randomRedeemFee; } function targetRedeemFee() public view override virtual returns (uint256) { (, , uint256 _targetRedeemFee, ,) = vaultFactory.vaultFees(vaultId); return _targetRedeemFee; } function randomSwapFee() public view override virtual returns (uint256) { (, , , uint256 _randomSwapFee, ) = vaultFactory.vaultFees(vaultId); return _randomSwapFee; } function targetSwapFee() public view override virtual returns (uint256) { (, , , ,uint256 _targetSwapFee) = vaultFactory.vaultFees(vaultId); return _targetSwapFee; } function vaultFees() public view override virtual returns (uint256, uint256, uint256, uint256, uint256) { return vaultFactory.vaultFees(vaultId); } function allValidNFTs(uint256[] memory tokenIds) public view override virtual returns (bool) { if (allowAllItems) { return true; } INFTXEligibility _eligibilityStorage = eligibilityStorage; if (address(_eligibilityStorage) == address(0)) { return false; } return _eligibilityStorage.checkAllEligible(tokenIds); } function nftIdAt(uint256 holdingsIndex) external view override virtual returns (uint256) { return holdings.at(holdingsIndex); } // Added in v1.0.3. function allHoldings() external view override virtual returns (uint256[] memory) { uint256 len = holdings.length(); uint256[] memory idArray = new uint256[](len); for (uint256 i = 0; i < len; i++) { idArray[i] = holdings.at(i); } return idArray; } // Added in v1.0.3. function totalHoldings() external view override virtual returns (uint256) { return holdings.length(); } // Added in v1.0.3. function version() external pure returns (string memory) { return "v1.0.5"; } // We set a hook to the eligibility module (if it exists) after redeems in case anything needs to be modified. function afterRedeemHook(uint256[] memory tokenIds) internal virtual { INFTXEligibility _eligibilityStorage = eligibilityStorage; if (address(_eligibilityStorage) == address(0)) { return; } _eligibilityStorage.afterRedeemHook(tokenIds); } function receiveNFTs(uint256[] memory tokenIds, uint256[] memory amounts) internal virtual returns (uint256) { require(allValidNFTs(tokenIds), "NFTXVault: not eligible"); if (is1155) { // This is technically a check, so placing it before the effect. IERC1155Upgradeable(assetAddress).safeBatchTransferFrom( msg.sender, address(this), tokenIds, amounts, "" ); uint256 count; for (uint256 i = 0; i < tokenIds.length; i++) { uint256 tokenId = tokenIds[i]; uint256 amount = amounts[i]; require(amount > 0, "NFTXVault: transferring < 1"); if (quantity1155[tokenId] == 0) { holdings.add(tokenId); } quantity1155[tokenId] += amount; count += amount; } return count; } else { address _assetAddress = assetAddress; for (uint256 i = 0; i < tokenIds.length; i++) { uint256 tokenId = tokenIds[i]; // We may already own the NFT here so we check in order: // Does the vault own it? // - If so, check if its in holdings list // - If so, we reject. This means the NFT has already been claimed for. // - If not, it means we have not yet accounted for this NFT, so we continue. // -If not, we "pull" it from the msg.sender and add to holdings. transferFromERC721(_assetAddress, tokenId); holdings.add(tokenId); } return tokenIds.length; } } function withdrawNFTsTo( uint256 amount, uint256[] memory specificIds, address to ) internal virtual returns (uint256[] memory) { bool _is1155 = is1155; address _assetAddress = assetAddress; uint256[] memory redeemedIds = new uint256[](amount); for (uint256 i = 0; i < amount; i++) { // This will always be fine considering the validations made above. uint256 tokenId = i < specificIds.length ? specificIds[i] : getRandomTokenIdFromVault(); redeemedIds[i] = tokenId; if (_is1155) { quantity1155[tokenId] -= 1; if (quantity1155[tokenId] == 0) { holdings.remove(tokenId); } IERC1155Upgradeable(_assetAddress).safeTransferFrom( address(this), to, tokenId, 1, "" ); } else { holdings.remove(tokenId); transferERC721(_assetAddress, to, tokenId); } } afterRedeemHook(redeemedIds); return redeemedIds; } function _chargeAndDistributeFees(address user, uint256 amount) internal virtual { // Do not charge fees if the zap contract is calling // Added in v1.0.3. Changed to mapping in v1.0.5. if (vaultFactory.excludedFromFees(msg.sender)) { return; } // Mint fees directly to the distributor and distribute. if (amount > 0) { address feeDistributor = vaultFactory.feeDistributor(); // Changed to a _transfer() in v1.0.3. _transfer(user, feeDistributor, amount); INFTXFeeDistributor(feeDistributor).distribute(vaultId); } } function transferERC721(address assetAddr, address to, uint256 tokenId) internal virtual { address kitties = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d; address punks = 0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB; bytes memory data; if (assetAddr == kitties) { // Changed in v1.0.4. data = abi.encodeWithSignature("transfer(address,uint256)", to, tokenId); } else if (assetAddr == punks) { // CryptoPunks. data = abi.encodeWithSignature("transferPunk(address,uint256)", to, tokenId); } else { // Default. data = abi.encodeWithSignature("safeTransferFrom(address,address,uint256)", address(this), to, tokenId); } (bool success,) = address(assetAddr).call(data); require(success); } function transferFromERC721(address assetAddr, uint256 tokenId) internal virtual { address kitties = 0x06012c8cf97BEaD5deAe237070F9587f8E7A266d; address punks = 0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB; bytes memory data; if (assetAddr == kitties) { // Cryptokitties. data = abi.encodeWithSignature("transferFrom(address,address,uint256)", msg.sender, address(this), tokenId); } else if (assetAddr == punks) { // CryptoPunks. // Fix here for frontrun attack. Added in v1.0.2. bytes memory punkIndexToAddress = abi.encodeWithSignature("punkIndexToAddress(uint256)", tokenId); (bool checkSuccess, bytes memory result) = address(assetAddr).staticcall(punkIndexToAddress); (address owner) = abi.decode(result, (address)); require(checkSuccess && owner == msg.sender, "Not the owner"); data = abi.encodeWithSignature("buyPunk(uint256)", tokenId); } else { // Default. // Allow other contracts to "push" into the vault, safely. // If we already have the token requested, make sure we don't have it in the list to prevent duplicate minting. if (IERC721Upgradeable(assetAddress).ownerOf(tokenId) == address(this)) { require(!holdings.contains(tokenId), "Trying to use an owned NFT"); return; } else { data = abi.encodeWithSignature("safeTransferFrom(address,address,uint256)", msg.sender, address(this), tokenId); } } (bool success, bytes memory resultData) = address(assetAddr).call(data); require(success, string(resultData)); } function getRandomTokenIdFromVault() internal virtual returns (uint256) { uint256 randomIndex = uint256( keccak256( abi.encodePacked( blockhash(block.number - 1), randNonce, block.coinbase, block.difficulty, block.timestamp ) ) ) % holdings.length(); randNonce += 1; return holdings.at(randomIndex); } function onlyPrivileged() internal view { if (manager == address(0)) { require(msg.sender == owner(), "Not owner"); } else { require(msg.sender == manager, "Not manager"); } } function onlyOwnerIfPaused(uint256 lockId) internal view { require(!vaultFactory.isLocked(lockId) || msg.sender == owner(), "Paused"); } } // File contracts/solidity/NFTXVaultFactoryUpgradeable.sol pragma solidity ^0.8.0; // Authors: @0xKiwi_ and @alexgausman. contract NFTXVaultFactoryUpgradeable is PausableUpgradeable, UpgradeableBeacon, INFTXVaultFactory { uint256 private NOT_USED1; // Removed, no longer needed. address public override zapContract; address public override feeDistributor; address public override eligibilityManager; mapping(uint256 => address) private NOT_USED2; // Removed, no longer needed. mapping(address => address[]) _vaultsForAsset; address[] internal vaults; // v1.0.1 mapping(address => bool) public override excludedFromFees; // v1.0.2 struct VaultFees { bool active; uint64 mintFee; uint64 randomRedeemFee; uint64 targetRedeemFee; uint64 randomSwapFee; uint64 targetSwapFee; } mapping(uint256 => VaultFees) private _vaultFees; uint64 public override factoryMintFee; uint64 public override factoryRandomRedeemFee; uint64 public override factoryTargetRedeemFee; uint64 public override factoryRandomSwapFee; uint64 public override factoryTargetSwapFee; function __NFTXVaultFactory_init(address _vaultImpl, address _feeDistributor) public override initializer { __Pausable_init(); // We use a beacon proxy so that every child contract follows the same implementation code. __UpgradeableBeacon__init(_vaultImpl); setFeeDistributor(_feeDistributor); setFactoryFees(0.1 ether, 0.05 ether, 0.1 ether, 0.05 ether, 0.1 ether); } function assignFees() public { require(factoryMintFee == 0 && factoryTargetRedeemFee == 0, "Assigned"); factoryMintFee = uint64(0.1 ether); factoryRandomRedeemFee = uint64(0.05 ether); factoryTargetRedeemFee = uint64(0.1 ether); factoryRandomSwapFee = uint64(0.05 ether); factoryTargetSwapFee = uint64(0.1 ether); emit UpdateFactoryFees(0.1 ether, 0.05 ether, 0.1 ether, 0.05 ether, 0.1 ether); } function createVault( string memory name, string memory symbol, address _assetAddress, bool is1155, bool allowAllItems ) external virtual override returns (uint256) { onlyOwnerIfPaused(0); require(feeDistributor != address(0), "NFTX: Fee receiver unset"); require(childImplementation() != address(0), "NFTX: Vault implementation unset"); address vaultAddr = deployVault(name, symbol, _assetAddress, is1155, allowAllItems); uint256 _vaultId = vaults.length; _vaultsForAsset[_assetAddress].push(vaultAddr); vaults.push(vaultAddr); INFTXFeeDistributor(feeDistributor).initializeVaultReceivers(_vaultId); emit NewVault(_vaultId, vaultAddr, _assetAddress); return _vaultId; } function setFactoryFees( uint256 mintFee, uint256 randomRedeemFee, uint256 targetRedeemFee, uint256 randomSwapFee, uint256 targetSwapFee ) public onlyOwner virtual override { require(mintFee <= 1 ether, "Cannot > 1 ether"); require(randomRedeemFee <= 1 ether, "Cannot > 1 ether"); require(targetRedeemFee <= 1 ether, "Cannot > 1 ether"); require(randomSwapFee <= 1 ether, "Cannot > 1 ether"); require(targetSwapFee <= 1 ether, "Cannot > 1 ether"); factoryMintFee = uint64(mintFee); factoryRandomRedeemFee = uint64(randomRedeemFee); factoryTargetRedeemFee = uint64(targetRedeemFee); factoryRandomSwapFee = uint64(randomSwapFee); factoryTargetSwapFee = uint64(targetSwapFee); emit UpdateFactoryFees(mintFee, randomRedeemFee, targetRedeemFee, randomSwapFee, targetSwapFee); } function setVaultFees( uint256 vaultId, uint256 mintFee, uint256 randomRedeemFee, uint256 targetRedeemFee, uint256 randomSwapFee, uint256 targetSwapFee ) public virtual override { if (msg.sender != owner()) { address vaultAddr = vaults[vaultId]; require(msg.sender == vaultAddr, "Not from vault"); } require(mintFee <= 1 ether, "Cannot > 1 ether"); require(randomRedeemFee <= 1 ether, "Cannot > 1 ether"); require(targetRedeemFee <= 1 ether, "Cannot > 1 ether"); require(randomSwapFee <= 1 ether, "Cannot > 1 ether"); require(targetSwapFee <= 1 ether, "Cannot > 1 ether"); _vaultFees[vaultId] = VaultFees( true, uint64(mintFee), uint64(randomRedeemFee), uint64(targetRedeemFee), uint64(randomSwapFee), uint64(targetSwapFee) ); emit UpdateVaultFees(vaultId, mintFee, randomRedeemFee, targetRedeemFee, randomSwapFee, targetSwapFee); } function disableVaultFees(uint256 vaultId) public virtual override { if (msg.sender != owner()) { address vaultAddr = vaults[vaultId]; require(msg.sender == vaultAddr, "Not vault"); } delete _vaultFees[vaultId]; emit DisableVaultFees(vaultId); } function setFeeDistributor(address _feeDistributor) public onlyOwner virtual override { require(_feeDistributor != address(0)); emit NewFeeDistributor(feeDistributor, _feeDistributor); feeDistributor = _feeDistributor; } function setZapContract(address _zapContract) public onlyOwner virtual override { emit NewZapContract(zapContract, _zapContract); zapContract = _zapContract; } function setFeeExclusion(address _excludedAddr, bool excluded) public onlyOwner virtual override { emit FeeExclusion(_excludedAddr, excluded); excludedFromFees[_excludedAddr] = excluded; } function setEligibilityManager(address _eligibilityManager) external onlyOwner virtual override { emit NewEligibilityManager(eligibilityManager, _eligibilityManager); eligibilityManager = _eligibilityManager; } function vaultFees(uint256 vaultId) external view virtual override returns (uint256, uint256, uint256, uint256, uint256) { VaultFees memory fees = _vaultFees[vaultId]; if (fees.active) { return ( uint256(fees.mintFee), uint256(fees.randomRedeemFee), uint256(fees.targetRedeemFee), uint256(fees.randomSwapFee), uint256(fees.targetSwapFee) ); } return (uint256(factoryMintFee), uint256(factoryRandomRedeemFee), uint256(factoryTargetRedeemFee), uint256(factoryRandomSwapFee), uint256(factoryTargetSwapFee)); } function isLocked(uint256 lockId) external view override virtual returns (bool) { return isPaused[lockId]; } function vaultsForAsset(address assetAddress) external view override virtual returns (address[] memory) { return _vaultsForAsset[assetAddress]; } function vault(uint256 vaultId) external view override virtual returns (address) { return vaults[vaultId]; } function allVaults() external view override virtual returns (address[] memory) { return vaults; } function numVaults() external view override virtual returns (uint256) { return vaults.length; } function deployVault( string memory name, string memory symbol, address _assetAddress, bool is1155, bool allowAllItems ) internal returns (address) { address newBeaconProxy = address(new BeaconProxy(address(this), "")); NFTXVaultUpgradeable(newBeaconProxy).__NFTXVault_init(name, symbol, _assetAddress, is1155, allowAllItems); // Manager for configuration. NFTXVaultUpgradeable(newBeaconProxy).setManager(msg.sender); // Owner for administrative functions. NFTXVaultUpgradeable(newBeaconProxy).transferOwnership(owner()); return newBeaconProxy; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"DisableVaultFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"feeExcluded","type":"address"},{"indexed":false,"internalType":"bool","name":"excluded","type":"bool"}],"name":"FeeExclusion","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldEligManager","type":"address"},{"indexed":false,"internalType":"address","name":"newEligManager","type":"address"}],"name":"NewEligibilityManager","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldDistributor","type":"address"},{"indexed":false,"internalType":"address","name":"newDistributor","type":"address"}],"name":"NewFeeDistributor","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"vaultId","type":"uint256"},{"indexed":false,"internalType":"address","name":"vaultAddress","type":"address"},{"indexed":false,"internalType":"address","name":"assetAddress","type":"address"}],"name":"NewVault","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldZap","type":"address"},{"indexed":false,"internalType":"address","name":"newZap","type":"address"}],"name":"NewZapContract","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"bool","name":"isGuardian","type":"bool"}],"name":"SetIsGuardian","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"lockId","type":"uint256"},{"indexed":false,"internalType":"bool","name":"paused","type":"bool"}],"name":"SetPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"mintFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"randomRedeemFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"targetRedeemFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"randomSwapFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"targetSwapFee","type":"uint256"}],"name":"UpdateFactoryFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"vaultId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"mintFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"randomRedeemFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"targetRedeemFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"randomSwapFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"targetSwapFee","type":"uint256"}],"name":"UpdateVaultFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"childImplementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[{"internalType":"address","name":"_vaultImpl","type":"address"},{"internalType":"address","name":"_feeDistributor","type":"address"}],"name":"__NFTXVaultFactory_init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"childImplementation_","type":"address"}],"name":"__UpgradeableBeacon__init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"allVaults","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"assignFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"childImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"address","name":"_assetAddress","type":"address"},{"internalType":"bool","name":"is1155","type":"bool"},{"internalType":"bool","name":"allowAllItems","type":"bool"}],"name":"createVault","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"disableVaultFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eligibilityManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"excludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factoryMintFee","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factoryRandomRedeemFee","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factoryRandomSwapFee","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factoryTargetRedeemFee","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factoryTargetSwapFee","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeDistributor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isGuardian","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"lockId","type":"uint256"}],"name":"isLocked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"isPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numVaults","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"lockId","type":"uint256"}],"name":"onlyOwnerIfPaused","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"lockId","type":"uint256"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_eligibilityManager","type":"address"}],"name":"setEligibilityManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"mintFee","type":"uint256"},{"internalType":"uint256","name":"randomRedeemFee","type":"uint256"},{"internalType":"uint256","name":"targetRedeemFee","type":"uint256"},{"internalType":"uint256","name":"randomSwapFee","type":"uint256"},{"internalType":"uint256","name":"targetSwapFee","type":"uint256"}],"name":"setFactoryFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeDistributor","type":"address"}],"name":"setFeeDistributor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_excludedAddr","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"setFeeExclusion","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bool","name":"_isGuardian","type":"bool"}],"name":"setIsGuardian","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"},{"internalType":"uint256","name":"mintFee","type":"uint256"},{"internalType":"uint256","name":"randomRedeemFee","type":"uint256"},{"internalType":"uint256","name":"targetRedeemFee","type":"uint256"},{"internalType":"uint256","name":"randomSwapFee","type":"uint256"},{"internalType":"uint256","name":"targetSwapFee","type":"uint256"}],"name":"setVaultFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_zapContract","type":"address"}],"name":"setZapContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"lockId","type":"uint256"}],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newChildImplementation","type":"address"}],"name":"upgradeChildTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"vaultId","type":"uint256"}],"name":"vaultFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"assetAddress","type":"address"}],"name":"vaultsForAsset","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"zapContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
117843:8116:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;125052:111;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;118791:45;;;;;-1:-1:-1;;;118791:45:0;;;;;;;;;13758:18:1;13746:31;;;13728:50;;13716:2;13701:18;118791:45:0;13683:101:1;41051:42:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;6482:14:1;;6475:22;6457:41;;6445:2;6430:18;41051:42:0;6412:92:1;118068:38:0;;;;;-1:-1:-1;;;;;118068:38:0;;;;;;-1:-1:-1;;;;;4506:55:1;;;4488:74;;4476:2;4461:18;118068:38:0;4443:125:1;41580:184:0;;;;;;:::i;:::-;;:::i;:::-;;118113:42;;;;;-1:-1:-1;;;;;118113:42:0;;;32799:156;;;;;;:::i;:::-;;:::i;121609:1098::-;;;;;;:::i;:::-;;:::i;123945:672::-;;;;;;:::i;:::-;;:::i;:::-;;;;6891:25:1;;;6947:2;6932:18;;6925:34;;;;6975:18;;;6968:34;;;;7033:2;7018:18;;7011:34;7076:3;7061:19;;7054:35;6878:3;6863:19;123945:672:0;6845:250:1;41772:177:0;;;;;;:::i;:::-;;:::i;118026:35::-;;;;;-1:-1:-1;;;;;118026:35:0;;;125171:109;125259:6;:13;125171:109;;;12277:25:1;;;12265:2;12250:18;125171:109:0;12232:76:1;123485:211:0;;;;;;:::i;:::-;;:::i;118945:418::-;;;;;;:::i;:::-;;:::i;123704:233::-;;;;;;:::i;:::-;;:::i;118843:43::-;;;;;-1:-1:-1;;;118843:43:0;;;;;;30727:148;;;:::i;118739:45::-;;;;;;;;;;;;41248:143;;;;;;:::i;:::-;;:::i;124922:122::-;;;;;;:::i;:::-;;:::i;30076:87::-;30149:6;;-1:-1:-1;;;;;30149:6:0;30076:87;;124755:159;;;;;;:::i;:::-;;:::i;120668:933::-;;;;;;:::i;:::-;;:::i;118695:37::-;;;;;;;;;41100:40;;;;;;:::i;:::-;;;;;;;;;;;;;;;;122715:312;;;;;;:::i;:::-;;:::i;119371:466::-;;;:::i;123035:252::-;;;;;;:::i;:::-;;:::i;32399:124::-;32495:20;;-1:-1:-1;;;;;32495:20:0;32399:124;;118353:57;;;;;;:::i;:::-;;;;;;;;;;;;;;;;32162:148;;;;;;:::i;:::-;;:::i;119845:815::-;;;;;;:::i;:::-;;:::i;31030:244::-;;;;;;:::i;:::-;;:::i;124625:122::-;;;;;;:::i;:::-;124699:4;124723:16;;;:8;:16;;;;;;;;;124625:122;41399:173;;;;;;:::i;:::-;;:::i;118893:43::-;;;;;;;;;123295:182;;;;;;:::i;:::-;;:::i;125052:111::-;125113:16;125149:6;125142:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;125142:13:0;;;;;;;;;;;;;;;;;;;;;;;125052:111;:::o;41580:184::-;41656:10;41645:22;;;;:10;:22;;;;;;;;41637:46;;;;-1:-1:-1;;;41637:46:0;;9389:2:1;41637:46:0;;;9371:21:1;9428:2;9408:18;;;9401:30;9467:13;9447:18;;;9440:41;9498:18;;41637:46:0;;;;;;;;;41694:16;;;;:8;:16;;;;;;;;;:23;;-1:-1:-1;;41694:23:0;41713:4;41694:23;;;;;;41733;;12481:25:1;;;12522:18;;;12515:50;41733:23:0;;12454:18:1;41733:23:0;;;;;;;;41580:184;:::o;32799:156::-;30149:6;;-1:-1:-1;;;;;30149:6:0;28459:10;30296:23;30288:68;;;;-1:-1:-1;;;30288:68:0;;11972:2:1;30288:68:0;;;11954:21:1;;;11991:18;;;11984:30;12050:34;12030:18;;;12023:62;12102:18;;30288:68:0;11944:182:1;30288:68:0;32900:47:::1;32924:22;32900:23;:47::i;:::-;32799:156:::0;:::o;121609:1098::-;30149:6;;-1:-1:-1;;;;;30149:6:0;121865:10;:21;121861:154;;121903:17;121923:6;121930:7;121923:15;;;;;;-1:-1:-1;;;121923:15:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;121923:15:0;;-1:-1:-1;121961:10:0;:23;;121953:50;;;;-1:-1:-1;;;121953:50:0;;10082:2:1;121953:50:0;;;10064:21:1;10121:2;10101:18;;;10094:30;10160:16;10140:18;;;10133:44;10194:18;;121953:50:0;10054:164:1;121953:50:0;121861:154;;122044:7;122033;:18;;122025:47;;;;-1:-1:-1;;;122025:47:0;;11627:2:1;122025:47:0;;;11609:21:1;11666:2;11646:18;;;11639:30;-1:-1:-1;;;11685:18:1;;;11678:46;11741:18;;122025:47:0;11599:166:1;122025:47:0;122110:7;122091:15;:26;;122083:55;;;;-1:-1:-1;;;122083:55:0;;11627:2:1;122083:55:0;;;11609:21:1;11666:2;11646:18;;;11639:30;-1:-1:-1;;;11685:18:1;;;11678:46;11741:18;;122083:55:0;11599:166:1;122083:55:0;122176:7;122157:15;:26;;122149:55;;;;-1:-1:-1;;;122149:55:0;;11627:2:1;122149:55:0;;;11609:21:1;11666:2;11646:18;;;11639:30;-1:-1:-1;;;11685:18:1;;;11678:46;11741:18;;122149:55:0;11599:166:1;122149:55:0;122240:7;122223:13;:24;;122215:53;;;;-1:-1:-1;;;122215:53:0;;11627:2:1;122215:53:0;;;11609:21:1;11666:2;11646:18;;;11639:30;-1:-1:-1;;;11685:18:1;;;11678:46;11741:18;;122215:53:0;11599:166:1;122215:53:0;122304:7;122287:13;:24;;122279:53;;;;-1:-1:-1;;;122279:53:0;;11627:2:1;122279:53:0;;;11609:21:1;11666:2;11646:18;;;11639:30;-1:-1:-1;;;11685:18:1;;;11678:46;11741:18;;122279:53:0;11599:166:1;122279:53:0;122367:219;;;;;;;;122391:4;122367:219;;;;;;122418:7;122367:219;;;;;;122448:15;122367:219;;;;;;122486:15;122367:219;;;;;;122524:13;122367:219;;;;;;122561:13;122367:219;;;;;122345:10;:19;122356:7;122345:19;;;;;;;;;;;:241;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;122602:97;122618:7;122627;122636:15;122653;122670:13;122685;122602:97;;;;;;;;;;13331:25:1;;;13387:2;13372:18;;13365:34;;;;13430:2;13415:18;;13408:34;;;;13473:2;13458:18;;13451:34;13516:3;13501:19;;13494:35;13560:3;13545:19;;13538:35;13318:3;13303:19;;13285:294;122602:97:0;;;;;;;;121609:1098;;;;;;:::o;123945:672::-;124021:7;124101:19;;;:10;:19;;;;;;;;124077:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;124021:7;;;;;;;;124131:298;;124197:4;:12;;;124189:21;;124238:4;:20;;;124230:29;;124287:4;:20;;;124279:29;;124336:4;:18;;;124328:27;;124383:4;:18;;;124375:27;;124163:254;;;;;;;;;;;;;124131:298;-1:-1:-1;;124465:14:0;;124587:20;;124465:14;;;;;-1:-1:-1;124490:22:0;;;;;;-1:-1:-1;;;;124523:22:0;;;;;-1:-1:-1;;;;124556:20:0;;;;;;-1:-1:-1;124587:20:0;123945:672;;;;;;;;:::o;41772:177::-;30149:6;;-1:-1:-1;;;;;30149:6:0;28459:10;30296:23;30288:68;;;;-1:-1:-1;;;30288:68:0;;11972:2:1;30288:68:0;;;11954:21:1;;;11991:18;;;11984:30;12050:34;12030:18;;;12023:62;12102:18;;30288:68:0;11944:182:1;30288:68:0;-1:-1:-1;;;;;41863:16:0;::::1;;::::0;;;:10:::1;:16;::::0;;;;;;;;:30;;-1:-1:-1;;41863:30:0::1;::::0;::::1;;::::0;;::::1;::::0;;;41909:32;;5073:74:1;;;5163:18;;;5156:50;41909:32:0::1;::::0;5046:18:1;41909:32:0::1;;;;;;;41772:177:::0;;:::o;123485:211::-;30149:6;;-1:-1:-1;;;;;30149:6:0;28459:10;30296:23;30288:68;;;;-1:-1:-1;;;30288:68:0;;11972:2:1;30288:68:0;;;11954:21:1;;;11991:18;;;11984:30;12050:34;12030:18;;;12023:62;12102:18;;30288:68:0;11944:182:1;30288:68:0;123598:37:::1;::::0;;-1:-1:-1;;;;;5091:55:1;;5073:74;;5190:14;;5183:22;5178:2;5163:18;;5156:50;123598:37:0::1;::::0;5046:18:1;123598:37:0::1;;;;;;;-1:-1:-1::0;;;;;123646:31:0;;;::::1;;::::0;;;:16:::1;:31;::::0;;;;:42;;-1:-1:-1;;123646:42:0::1;::::0;::::1;;::::0;;;::::1;::::0;;123485:211::o;118945:418::-;27200:13;;;;;;;;:30;;-1:-1:-1;27218:12:0;;;;27217:13;27200:30;27192:89;;;;-1:-1:-1;;;27192:89:0;;10425:2:1;27192:89:0;;;10407:21:1;10464:2;10444:18;;;10437:30;10503:34;10483:18;;;10476:62;-1:-1:-1;;;10554:18:1;;;10547:44;10608:19;;27192:89:0;10397:236:1;27192:89:0;27294:19;27317:13;;;;;;27316:14;27341:101;;;;27376:13;:20;;-1:-1:-1;;27411:19:0;;;;;27341:101;119062:17:::1;:15;:17::i;:::-;119191:37;119217:10;119191:25;:37::i;:::-;119239:34;119257:15;119239:17;:34::i;:::-;119284:71;119299:9;119310:10;119322:9;119333:10;119345:9;119284:14;:71::i;:::-;27472:14:::0;27468:68;;;27519:5;27503:21;;-1:-1:-1;;27503:21:0;;;27468:68;118945:418;;;:::o;123704:233::-;30149:6;;-1:-1:-1;;;;;30149:6:0;28459:10;30296:23;30288:68;;;;-1:-1:-1;;;30288:68:0;;11972:2:1;30288:68:0;;;11954:21:1;;;11991:18;;;11984:30;12050:34;12030:18;;;12023:62;12102:18;;30288:68:0;11944:182:1;30288:68:0;123838:18:::1;::::0;123816:62:::1;::::0;;-1:-1:-1;;;;;123838:18:0;;::::1;4808:34:1::0;;4878:15;;;4873:2;4858:18;;4851:43;123816:62:0::1;::::0;4720:18:1;123816:62:0::1;;;;;;;123889:18;:40:::0;;-1:-1:-1;;;;;;123889:40:0::1;-1:-1:-1::0;;;;;123889:40:0;;;::::1;::::0;;;::::1;::::0;;123704:233::o;30727:148::-;30149:6;;-1:-1:-1;;;;;30149:6:0;28459:10;30296:23;30288:68;;;;-1:-1:-1;;;30288:68:0;;11972:2:1;30288:68:0;;;11954:21:1;;;11991:18;;;11984:30;12050:34;12030:18;;;12023:62;12102:18;;30288:68:0;11944:182:1;30288:68:0;30818:6:::1;::::0;30797:40:::1;::::0;30834:1:::1;::::0;-1:-1:-1;;;;;30818:6:0::1;::::0;30797:40:::1;::::0;30834:1;;30797:40:::1;30848:6;:19:::0;;-1:-1:-1;;;;;;30848:19:0::1;::::0;;30727:148::o;41248:143::-;41331:16;;;;:8;:16;;;;;;;;41330:17;;:42;;-1:-1:-1;30149:6:0;;-1:-1:-1;;;;;30149:6:0;41351:10;:21;41330:42;41322:61;;;;-1:-1:-1;;;41322:61:0;;7975:2:1;41322:61:0;;;7957:21:1;8014:1;7994:18;;;7987:29;8052:8;8032:18;;;8025:36;8078:18;;41322:61:0;7947:155:1;124922:122:0;124994:7;125021:6;125028:7;125021:15;;;;;;-1:-1:-1;;;125021:15:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;125021:15:0;;124922:122;-1:-1:-1;;124922:122:0:o;124755:159::-;-1:-1:-1;;;;;124877:29:0;;;;;;:15;:29;;;;;;;;;124870:36;;;;;;;;;;;;;;;;;124841:16;;124870:36;;;124877:29;124870:36;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;124870:36:0;;;;;;;;;;;;;;;;;;;;;;;124755:159;;;:::o;120668:933::-;30149:6;;-1:-1:-1;;;;;30149:6:0;28459:10;30296:23;30288:68;;;;-1:-1:-1;;;30288:68:0;;11972:2:1;30288:68:0;;;11954:21:1;;;11991:18;;;11984:30;12050:34;12030:18;;;12023:62;12102:18;;30288:68:0;11944:182:1;30288:68:0;120924:7:::1;120913;:18;;120905:47;;;::::0;-1:-1:-1;;;120905:47:0;;11627:2:1;120905:47:0::1;::::0;::::1;11609:21:1::0;11666:2;11646:18;;;11639:30;-1:-1:-1;;;11685:18:1;;;11678:46;11741:18;;120905:47:0::1;11599:166:1::0;120905:47:0::1;120990:7;120971:15;:26;;120963:55;;;::::0;-1:-1:-1;;;120963:55:0;;11627:2:1;120963:55:0::1;::::0;::::1;11609:21:1::0;11666:2;11646:18;;;11639:30;-1:-1:-1;;;11685:18:1;;;11678:46;11741:18;;120963:55:0::1;11599:166:1::0;120963:55:0::1;121056:7;121037:15;:26;;121029:55;;;::::0;-1:-1:-1;;;121029:55:0;;11627:2:1;121029:55:0::1;::::0;::::1;11609:21:1::0;11666:2;11646:18;;;11639:30;-1:-1:-1;;;11685:18:1;;;11678:46;11741:18;;121029:55:0::1;11599:166:1::0;121029:55:0::1;121120:7;121103:13;:24;;121095:53;;;::::0;-1:-1:-1;;;121095:53:0;;11627:2:1;121095:53:0::1;::::0;::::1;11609:21:1::0;11666:2;11646:18;;;11639:30;-1:-1:-1;;;11685:18:1;;;11678:46;11741:18;;121095:53:0::1;11599:166:1::0;121095:53:0::1;121184:7;121167:13;:24;;121159:53;;;::::0;-1:-1:-1;;;121159:53:0;;11627:2:1;121159:53:0::1;::::0;::::1;11609:21:1::0;11666:2;11646:18;;;11639:30;-1:-1:-1;;;11685:18:1;;;11678:46;11741:18;;121159:53:0::1;11599:166:1::0;121159:53:0::1;121225:14;:32:::0;;::::1;::::0;;::::1;-1:-1:-1::0;;121268:48:0;;;;;;;;;;::::1;;;121386:44:::0;;-1:-1:-1;;;121327:48:0;;::::1;;121386:44:::0;;;-1:-1:-1;;;121386:44:0;;::::1;;;::::0;;;121441:20:::1;:44:::0;;-1:-1:-1;;121441:44:0::1;::::0;;::::1;::::0;;;::::1;::::0;;121503:90:::1;::::0;;6891:25:1;;;6947:2;6932:18;;6925:34;;;6975:18;;;6968:34;;;7033:2;7018:18;;7011:34;;;7076:3;7061:19;;7054:35;;;121503:90:0::1;::::0;6878:3:1;6863:19;121503:90:0::1;;;;;;;120668:933:::0;;;;;:::o;122715:312::-;30149:6;;-1:-1:-1;;;;;30149:6:0;122797:10;:21;122793:149;;122835:17;122855:6;122862:7;122855:15;;;;;;-1:-1:-1;;;122855:15:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;122855:15:0;;-1:-1:-1;122893:10:0;:23;;122885:45;;;;-1:-1:-1;;;122885:45:0;;9052:2:1;122885:45:0;;;9034:21:1;9091:1;9071:18;;;9064:29;9129:11;9109:18;;;9102:39;9158:18;;122885:45:0;9024:158:1;122885:45:0;122793:149;;122959:19;;;;:10;:19;;;;;;;122952:26;;;;;;;;;;-1:-1:-1;;122952:26:0;;;122994:25;;;;;122970:7;12277:25:1;;12265:2;12250:18;;12232:76;119371:466:0;119419:14;;;;:19;:50;;;;-1:-1:-1;119442:22:0;;-1:-1:-1;;;119442:22:0;;;;:27;119419:50;119411:71;;;;-1:-1:-1;;;119411:71:0;;8716:2:1;119411:71:0;;;8698:21:1;8755:1;8735:18;;;8728:29;8793:10;8773:18;;;8766:38;8821:18;;119411:71:0;8688:157:1;119411:71:0;119645:41;119493:14;119645:41;119697:20;:40;;119517:9;-1:-1:-1;;119697:40:0;;;;;;;;119755:74;;;6891:25:1;;;119570:10:0;6947:2:1;6932:18;;6925:34;;;6975:18;;;6968:34;;;7033:2;7018:18;;7011:34;7076:3;7061:19;;7054:35;;;;119755:74:0;;;;;;6878:3:1;119755:74:0;;;119371:466::o;123035:252::-;30149:6;;-1:-1:-1;;;;;30149:6:0;28459:10;30296:23;30288:68;;;;-1:-1:-1;;;30288:68:0;;11972:2:1;30288:68:0;;;11954:21:1;;;11991:18;;;11984:30;12050:34;12030:18;;;12023:62;12102:18;;30288:68:0;11944:182:1;30288:68:0;-1:-1:-1;;;;;123140:29:0;::::1;123132:38;;;::::0;::::1;;123204:14;::::0;123186:50:::1;::::0;;-1:-1:-1;;;;;123204:14:0;;::::1;4808:34:1::0;;4878:15;;;4873:2;4858:18;;4851:43;123186:50:0::1;::::0;4720:18:1;123186:50:0::1;;;;;;;123247:14;:32:::0;;-1:-1:-1;;;;;;123247:32:0::1;-1:-1:-1::0;;;;;123247:32:0;;;::::1;::::0;;;::::1;::::0;;123035:252::o;32162:148::-;27200:13;;;;;;;;:30;;-1:-1:-1;27218:12:0;;;;27217:13;27200:30;27192:89;;;;-1:-1:-1;;;27192:89:0;;10425:2:1;27192:89:0;;;10407:21:1;10464:2;10444:18;;;10437:30;10503:34;10483:18;;;10476:62;-1:-1:-1;;;10554:18:1;;;10547:44;10608:19;;27192:89:0;10397:236:1;27192:89:0;27294:19;27317:13;;;;;;27316:14;27341:101;;;;27376:13;:20;;-1:-1:-1;;27411:19:0;;;;;27341:101;32257:45:::1;32281:20;32257:23;:45::i;:::-;27472:14:::0;27468:68;;;27519:5;27503:21;;-1:-1:-1;;27503:21:0;;;27468:68;32162:148;;:::o;119845:815::-;120051:7;120071:20;120089:1;120071:17;:20::i;:::-;120110:14;;-1:-1:-1;;;;;120110:14:0;120102:65;;;;-1:-1:-1;;;120102:65:0;;9729:2:1;120102:65:0;;;9711:21:1;9768:2;9748:18;;;9741:30;9807:26;9787:18;;;9780:54;9851:18;;120102:65:0;9701:174:1;120102:65:0;120219:1;120186:21;32495:20;;-1:-1:-1;;;;;32495:20:0;;32399:124;120186:21;-1:-1:-1;;;;;120186:35:0;;;120178:80;;;;-1:-1:-1;;;120178:80:0;;11266:2:1;120178:80:0;;;11248:21:1;;;11285:18;;;11278:30;11344:34;11324:18;;;11317:62;11396:18;;120178:80:0;11238:182:1;120178:80:0;120269:17;120289:63;120301:4;120307:6;120315:13;120330:6;120338:13;120289:11;:63::i;:::-;120382:6;:13;;-1:-1:-1;;;;;120406:30:0;;;120363:16;120406:30;;;:15;:30;;;;;;;;:46;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;120406:46:0;;;;;;;;120463:22;;;;;;;;;;;;;;;;;;;;;;;;;;120516:14;;120496:70;;;;;;;;12277:25:1;;;120406:46:0;;-1:-1:-1;120382:13:0;;120516:14;;;120496:60;;12250:18:1;;120496:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;120582:44:0;;;-1:-1:-1;;;;;4826:15:1;;;4808:34;;4878:15;;4873:2;4858:18;;4851:43;120591:8:0;;-1:-1:-1;120582:44:0;;-1:-1:-1;4720:18:1;120582:44:0;;;;;;;120644:8;119845:815;-1:-1:-1;;;;;;;119845:815:0:o;31030:244::-;30149:6;;-1:-1:-1;;;;;30149:6:0;28459:10;30296:23;30288:68;;;;-1:-1:-1;;;30288:68:0;;11972:2:1;30288:68:0;;;11954:21:1;;;11991:18;;;11984:30;12050:34;12030:18;;;12023:62;12102:18;;30288:68:0;11944:182:1;30288:68:0;-1:-1:-1;;;;;31119:22:0;::::1;31111:73;;;::::0;-1:-1:-1;;;31111:73:0;;8309:2:1;31111:73:0::1;::::0;::::1;8291:21:1::0;8348:2;8328:18;;;8321:30;8387:34;8367:18;;;8360:62;8458:8;8438:18;;;8431:36;8484:19;;31111:73:0::1;8281:228:1::0;31111:73:0::1;31221:6;::::0;31200:38:::1;::::0;-1:-1:-1;;;;;31200:38:0;;::::1;::::0;31221:6:::1;::::0;31200:38:::1;::::0;31221:6:::1;::::0;31200:38:::1;31249:6;:17:::0;;-1:-1:-1;;;;;;31249:17:0::1;-1:-1:-1::0;;;;;31249:17:0;;;::::1;::::0;;;::::1;::::0;;31030:244::o;41399:173::-;30149:6;;-1:-1:-1;;;;;30149:6:0;28459:10;30296:23;30288:68;;;;-1:-1:-1;;;30288:68:0;;11972:2:1;30288:68:0;;;11954:21:1;;;11991:18;;;11984:30;12050:34;12030:18;;;12023:62;12102:18;;30288:68:0;11944:182:1;30288:68:0;41519:5:::1;41500:16:::0;;;:8:::1;:16;::::0;;;;;;;:24;;-1:-1:-1;;41500:24:0::1;::::0;;41540;;12481:25:1;;;12522:18;;;12515:50;;;;41540:24:0::1;::::0;12454:18:1;41540:24:0::1;12436:135:1::0;123295:182:0;30149:6;;-1:-1:-1;;;;;30149:6:0;28459:10;30296:23;30288:68;;;;-1:-1:-1;;;30288:68:0;;11972:2:1;30288:68:0;;;11954:21:1;;;11991:18;;;11984:30;12050:34;12030:18;;;12023:62;12102:18;;30288:68:0;11944:182:1;30288:68:0;123406:11:::1;::::0;123391:41:::1;::::0;;-1:-1:-1;;;;;123406:11:0;;::::1;4808:34:1::0;;4878:15;;;4873:2;4858:18;;4851:43;123391:41:0::1;::::0;4720:18:1;123391:41:0::1;;;;;;;123443:11;:26:::0;;-1:-1:-1;;;;;;123443:26:0::1;-1:-1:-1::0;;;;;123443:26:0;;;::::1;::::0;;;::::1;::::0;;123295:182::o;33144:308::-;15721:20;;33228:112;;;;-1:-1:-1;;;33228:112:0;;10840:2:1;33228:112:0;;;10822:21:1;10879:2;10859:18;;;10852:30;10918:34;10898:18;;;10891:62;10989:27;10969:18;;;10962:55;11034:19;;33228:112:0;10812:247:1;33228:112:0;33351:20;:45;;-1:-1:-1;;;;;;33351:45:0;-1:-1:-1;;;;;33351:45:0;;;;;;;;33412:32;;;;-1:-1:-1;;33412:32:0;33144:308;:::o;40850:83::-;27200:13;;;;;;;;:30;;-1:-1:-1;27218:12:0;;;;27217:13;27200:30;27192:89;;;;-1:-1:-1;;;27192:89:0;;10425:2:1;27192:89:0;;;10407:21:1;10464:2;10444:18;;;10437:30;10503:34;10483:18;;;10476:62;-1:-1:-1;;;10554:18:1;;;10547:44;10608:19;;27192:89:0;10397:236:1;27192:89:0;27294:19;27317:13;;;;;;27316:14;27341:101;;;;27376:13;:20;;-1:-1:-1;;27411:19:0;;;;;27341:101;40909:16:::1;:14;:16::i;:::-;27472:14:::0;27468:68;;;27519:5;27503:21;;-1:-1:-1;;27503:21:0;;;40850:83;:::o;125292:664::-;125481:7;125501:22;125558:4;125534:34;;;;;:::i;:::-;-1:-1:-1;;;;;5446:55:1;;;5428:74;;5538:2;5533;5518:18;;5511:30;;;-1:-1:-1;5557:18:1;;;5550:32;5614:2;5599:18;125534:34:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;125580:105:0;;;;;125501:68;;-1:-1:-1;;;;;;125580:53:0;;;;;:105;;125634:4;;125640:6;;125648:13;;125663:6;;125671:13;;125580:105;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;125735:59:0;;;;;125783:10;125735:59;;;4488:74:1;-1:-1:-1;;;;;125735:47:0;;;-1:-1:-1;125735:47:0;;-1:-1:-1;4461:18:1;;125735:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;125874:14;-1:-1:-1;;;;;125853:54:0;;125908:7;30149:6;;-1:-1:-1;;;;;30149:6:0;;30076:87;125908:7;125853:63;;;;;;;;;;-1:-1:-1;;;;;4506:55:1;;;125853:63:0;;;4488:74:1;4461:18;;125853:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;125934:14:0;;125292:664;-1:-1:-1;;;;;;;;;125292:664:0:o;29662:129::-;27200:13;;;;;;;;:30;;-1:-1:-1;27218:12:0;;;;27217:13;27200:30;27192:89;;;;-1:-1:-1;;;27192:89:0;;10425:2:1;27192:89:0;;;10407:21:1;10464:2;10444:18;;;10437:30;10503:34;10483:18;;;10476:62;-1:-1:-1;;;10554:18:1;;;10547:44;10608:19;;27192:89:0;10397:236:1;27192:89:0;27294:19;27317:13;;;;;;27316:14;27341:101;;;;27376:13;:20;;-1:-1:-1;;27411:19:0;;;;;27341:101;29720:26:::1;:24;:26::i;:::-;29757;:24;:26::i;28308:65::-:0;27200:13;;;;;;;;:30;;-1:-1:-1;27218:12:0;;;;27217:13;27200:30;27192:89;;;;-1:-1:-1;;;27192:89:0;;10425:2:1;27192:89:0;;;10407:21:1;10464:2;10444:18;;;10437:30;10503:34;10483:18;;;10476:62;-1:-1:-1;;;10554:18:1;;;10547:44;10608:19;;27192:89:0;10397:236:1;27192:89:0;27294:19;27317:13;;;;;;27316:14;27341:101;;;;27376:13;:20;;-1:-1:-1;;27411:19:0;;;;;27468:68;;;;27519:5;27503:21;;-1:-1:-1;;27503:21:0;;;28308:65;:::o;29799:196::-;27200:13;;;;;;;;:30;;-1:-1:-1;27218:12:0;;;;27217:13;27200:30;27192:89;;;;-1:-1:-1;;;27192:89:0;;10425:2:1;27192:89:0;;;10407:21:1;10464:2;10444:18;;;10437:30;10503:34;10483:18;;;10476:62;-1:-1:-1;;;10554:18:1;;;10547:44;10608:19;;27192:89:0;10397:236:1;27192:89:0;27294:19;27317:13;;;;;;27316:14;27341:101;;;;27376:13;:20;;-1:-1:-1;;27411:19:0;;;;;27341:101;29910:6:::1;:18:::0;;-1:-1:-1;;;;;;29910:18:0::1;28459:10:::0;29910:18;;::::1;::::0;;;29944:43:::1;::::0;28459:10;;29867:17:::1;::::0;29944:43:::1;::::0;29867:17;;29944:43:::1;27454:1;27472:14:::0;27468:68;;;27519:5;27503:21;;-1:-1:-1;;27503:21:0;;;29799:196;:::o;-1:-1:-1:-;;;;;;;;:::o;14:196:1:-;82:20;;-1:-1:-1;;;;;131:54:1;;121:65;;111:2;;200:1;197;190:12;111:2;63:147;;;:::o;215:160::-;280:20;;336:13;;329:21;319:32;;309:2;;365:1;362;355:12;380:739;423:5;476:3;469:4;461:6;457:17;453:27;443:2;;498:5;491;484:20;443:2;538:6;525:20;564:18;601:2;597;594:10;591:2;;;607:18;;:::i;:::-;682:2;676:9;650:2;736:13;;-1:-1:-1;;732:22:1;;;756:2;728:31;724:40;712:53;;;780:18;;;800:22;;;777:46;774:2;;;826:18;;:::i;:::-;866:10;862:2;855:22;901:2;893:6;886:18;947:3;940:4;935:2;927:6;923:15;919:26;916:35;913:2;;;968:5;961;954:20;913:2;1036;1029:4;1021:6;1017:17;1010:4;1002:6;998:17;985:54;1059:15;;;1076:4;1055:26;1048:41;;;;-1:-1:-1;1063:6:1;433:686;-1:-1:-1;;;433:686:1:o;1124:196::-;1183:6;1236:2;1224:9;1215:7;1211:23;1207:32;1204:2;;;1257:6;1249;1242:22;1204:2;1285:29;1304:9;1285:29;:::i;:::-;1275:39;1194:126;-1:-1:-1;;;1194:126:1:o;1325:270::-;1393:6;1401;1454:2;1442:9;1433:7;1429:23;1425:32;1422:2;;;1475:6;1467;1460:22;1422:2;1503:29;1522:9;1503:29;:::i;:::-;1493:39;;1551:38;1585:2;1574:9;1570:18;1551:38;:::i;:::-;1541:48;;1412:183;;;;;:::o;1600:264::-;1665:6;1673;1726:2;1714:9;1705:7;1701:23;1697:32;1694:2;;;1747:6;1739;1732:22;1694:2;1775:29;1794:9;1775:29;:::i;:::-;1765:39;;1823:35;1854:2;1843:9;1839:18;1823:35;:::i;1869:785::-;1978:6;1986;1994;2002;2010;2063:3;2051:9;2042:7;2038:23;2034:33;2031:2;;;2085:6;2077;2070:22;2031:2;2130:9;2117:23;2159:18;2200:2;2192:6;2189:14;2186:2;;;2221:6;2213;2206:22;2186:2;2249:50;2291:7;2282:6;2271:9;2267:22;2249:50;:::i;:::-;2239:60;;2352:2;2341:9;2337:18;2324:32;2308:48;;2381:2;2371:8;2368:16;2365:2;;;2402:6;2394;2387:22;2365:2;;2430:52;2474:7;2463:8;2452:9;2448:24;2430:52;:::i;:::-;2420:62;;;2501:38;2535:2;2524:9;2520:18;2501:38;:::i;:::-;2491:48;;2558:35;2589:2;2578:9;2574:18;2558:35;:::i;:::-;2548:45;;2612:36;2643:3;2632:9;2628:19;2612:36;:::i;:::-;2602:46;;2021:633;;;;;;;;:::o;2659:190::-;2718:6;2771:2;2759:9;2750:7;2746:23;2742:32;2739:2;;;2792:6;2784;2777:22;2739:2;-1:-1:-1;2820:23:1;;2729:120;-1:-1:-1;2729:120:1:o;2854:464::-;2949:6;2957;2965;2973;2981;3034:3;3022:9;3013:7;3009:23;3005:33;3002:2;;;3056:6;3048;3041:22;3002:2;-1:-1:-1;;3084:23:1;;;3154:2;3139:18;;3126:32;;-1:-1:-1;3205:2:1;3190:18;;3177:32;;3256:2;3241:18;;3228:32;;-1:-1:-1;3307:3:1;3292:19;3279:33;;-1:-1:-1;2992:326:1;-1:-1:-1;2992:326:1:o;3323:533::-;3427:6;3435;3443;3451;3459;3467;3520:3;3508:9;3499:7;3495:23;3491:33;3488:2;;;3542:6;3534;3527:22;3488:2;-1:-1:-1;;3570:23:1;;;3640:2;3625:18;;3612:32;;-1:-1:-1;3691:2:1;3676:18;;3663:32;;3742:2;3727:18;;3714:32;;-1:-1:-1;3793:3:1;3778:19;;3765:33;;-1:-1:-1;3845:3:1;3830:19;3817:33;;-1:-1:-1;3478:378:1;-1:-1:-1;3478:378:1:o;3861:476::-;3903:3;3941:5;3935:12;3968:6;3963:3;3956:19;3993:3;4005:162;4019:6;4016:1;4013:13;4005:162;;;4081:4;4137:13;;;4133:22;;4127:29;4109:11;;;4105:20;;4098:59;4034:12;4005:162;;;4185:6;4182:1;4179:13;4176:2;;;4251:3;4244:4;4235:6;4230:3;4226:16;4222:27;4215:40;4176:2;-1:-1:-1;4319:2:1;4298:15;-1:-1:-1;;4294:29:1;4285:39;;;;4326:4;4281:50;;3911:426;-1:-1:-1;;3911:426:1:o;5628:684::-;5799:2;5851:21;;;5921:13;;5824:18;;;5943:22;;;5770:4;;5799:2;6022:15;;;;5996:2;5981:18;;;5770:4;6068:218;6082:6;6079:1;6076:13;6068:218;;;6147:13;;-1:-1:-1;;;;;6143:62:1;6131:75;;6261:15;;;;6226:12;;;;6104:1;6097:9;6068:218;;;-1:-1:-1;6303:3:1;;5779:533;-1:-1:-1;;;;;;5779:533:1:o;7100:668::-;7369:3;7358:9;7351:22;7332:4;7396:46;7437:3;7426:9;7422:19;7414:6;7396:46;:::i;:::-;7490:9;7482:6;7478:22;7473:2;7462:9;7458:18;7451:50;7518:33;7544:6;7536;7518:33;:::i;:::-;-1:-1:-1;;;;;7587:55:1;;;;7582:2;7567:18;;7560:83;-1:-1:-1;;7686:14:1;;7679:22;7674:2;7659:18;;7652:50;7746:14;7739:22;7733:3;7718:19;;;7711:51;7510:41;7341:427;-1:-1:-1;;7341:427:1:o;13789:184::-;-1:-1:-1;;;13838:1:1;13831:88;13938:4;13935:1;13928:15;13962:4;13959:1;13952:15
Swarm Source
ipfs://b4c25ed475b0d5fa74722db27c4676f87b56cb8234e6ddf055e311d2993d16d0
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.