Warning! Contract bytecode has been changed and doesn't match the verified one. Therefore, interaction with this smart contract may be risky.
- Contract name:
- ReleaseRegistry
- Optimization enabled
- true
- Compiler version
- v0.8.15+commit.e14f2714
- Optimization runs
- 200
- Verified at
- 2023-04-26T21:33:24.578013Z
contracts/ReleaseRegistry.sol
// SPDX-License-Identifier: AGPL-3.0 pragma solidity ^0.8.15; import "@openzeppelin/contracts/access/Ownable.sol"; import "./IVault.sol"; contract ReleaseRegistry is Ownable { /// @notice Number of vault releases in this registry. uint256 public numReleases; /// @notice Address of a given vault release index. mapping(uint256 => address) public releases; event NewRelease( uint256 indexed releaseId, address template, string apiVersion ); event NewClone(address indexed vault); /** @notice Returns the api version of the latest release. @dev Throws if no releases are registered yet. @return The api version of the latest release. */ function latestRelease() external view returns (string memory) { return IVault(releases[numReleases - 1]).apiVersion(); // dev: no release } /** @notice Add a previously deployed Vault as the template contract for the latest release, to be used by further "forwarder-style" delegatecall proxy contracts that can be deployed from the registry through other methods (to save gas). @dev Throws if caller isn't owner. Throws if the api version is the same as the previous release. Emits a NewRelease event. @param _vault The vault that will be used as the template contract for the next release. */ function newRelease(address _vault) external onlyOwner { // Check if the release is different from the current one // NOTE: This doesn't check for strict semver-style linearly increasing release versions uint256 releaseId = numReleases; // Next id in series if (releaseId > 0) { require( keccak256( bytes(IVault(releases[releaseId - 1]).apiVersion()) ) != keccak256(bytes(IVault(_vault).apiVersion())), "same api version" ); } // Update latest release releases[releaseId] = _vault; numReleases = releaseId + 1; // Log the release for external listeners (e.g. Graph) emit NewRelease(releaseId, _vault, IVault(_vault).apiVersion()); } function _newProxyVault( address _token, address _governance, address _rewards, address _guardian, string memory _name, string memory _symbol, uint256 _releaseTarget ) internal returns (address) { address vault; { address release = releases[_releaseTarget]; require(release != address(0), "unknown release"); vault = _clone(release); emit NewClone(vault); } // NOTE: Must initialize the Vault atomically with deploying it IVault(vault).initialize( _token, _governance, _rewards, _name, _symbol, _guardian ); return vault; } /// @notice Deploy a new vault with the latest vault release. /// @dev See other newVault() function for more details. function newVault( address _token, address _guardian, address _rewards, string calldata _name, string calldata _symbol ) external returns (address) { return newVault( _token, msg.sender, _guardian, _rewards, _name, _symbol, 0 ); } /** @notice Create a new vault for the given token using the latest release in the registry, as a simple "forwarder-style" delegatecall proxy to the latest release. @dev Throws if no releases are registered yet. Note that this vault will not be automatically endorsed. @param _token The token that may be deposited into the new Vault. @param _governance vault governance @param _guardian The address authorized for guardian interactions in the new Vault. @param _rewards The address to use for collecting rewards in the new Vault @param _name Specify a custom Vault name. Set to empty string for default choice. @param _symbol Specify a custom Vault symbol name. Set to empty string for default choice. @param _releaseDelta Specify the number of releases prior to the latest to use as a target. Default is latest. @return The address of the newly-deployed vault */ function newVault( address _token, address _governance, address _guardian, address _rewards, string calldata _name, string calldata _symbol, uint256 _releaseDelta ) public returns (address) { // NOTE: Underflow if no releases created yet, or targeting prior to release history uint256 releaseTarget = numReleases - 1 - _releaseDelta; // dev: no releases address vault = _newProxyVault( _token, _governance, _rewards, _guardian, _name, _symbol, releaseTarget ); return vault; } function _clone(address _target) internal returns (address _newVault) { // Copied from https://github.com/optionality/clone-factory/blob/master/contracts/CloneFactory.sol bytes20 addressBytes = bytes20(address(_target)); assembly { // EIP-1167 bytecode let clone_code := mload(0x40) mstore( clone_code, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000 ) mstore(add(clone_code, 0x14), addressBytes) mstore( add(clone_code, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000 ) _newVault := create(0, clone_code, 0x37) } } }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
contracts/IVault.sol
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.15; interface IVault { function token() external view returns (address); function apiVersion() external view returns (string memory); function governance() external view returns (address); function initialize( address _token, address _governance, address _rewards, string calldata _name, string calldata _symbol, address _guardian ) external; }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
contracts/IVault.sol
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.15; interface IVault { function token() external view returns (address); function apiVersion() external view returns (string memory); function governance() external view returns (address); function initialize( address _token, address _governance, address _rewards, string calldata _name, string calldata _symbol, address _guardian ) external; }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
contracts/IVault.sol
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.15; interface IVault { function token() external view returns (address); function apiVersion() external view returns (string memory); function governance() external view returns (address); function initialize( address _token, address _governance, address _rewards, string calldata _name, string calldata _symbol, address _guardian ) external; }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
contracts/IVault.sol
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.15; interface IVault { function token() external view returns (address); function apiVersion() external view returns (string memory); function governance() external view returns (address); function initialize( address _token, address _governance, address _rewards, string calldata _name, string calldata _symbol, address _guardian ) external; }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
contracts/IVault.sol
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.15; interface IVault { function token() external view returns (address); function apiVersion() external view returns (string memory); function governance() external view returns (address); function initialize( address _token, address _governance, address _rewards, string calldata _name, string calldata _symbol, address _guardian ) external; }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
contracts/IVault.sol
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.15; interface IVault { function token() external view returns (address); function apiVersion() external view returns (string memory); function governance() external view returns (address); function initialize( address _token, address _governance, address _rewards, string calldata _name, string calldata _symbol, address _guardian ) external; }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
contracts/IVault.sol
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.15; interface IVault { function token() external view returns (address); function apiVersion() external view returns (string memory); function governance() external view returns (address); function initialize( address _token, address _governance, address _rewards, string calldata _name, string calldata _symbol, address _guardian ) external; }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
contracts/IVault.sol
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.15; interface IVault { function token() external view returns (address); function apiVersion() external view returns (string memory); function governance() external view returns (address); function initialize( address _token, address _governance, address _rewards, string calldata _name, string calldata _symbol, address _guardian ) external; }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
contracts/IVault.sol
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.15; interface IVault { function token() external view returns (address); function apiVersion() external view returns (string memory); function governance() external view returns (address); function initialize( address _token, address _governance, address _rewards, string calldata _name, string calldata _symbol, address _guardian ) external; }
@openzeppelin/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
@openzeppelin/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
contracts/IVault.sol
// SPDX-License-Identifier: GPL-3.0 pragma solidity ^0.8.15; interface IVault { function token() external view returns (address); function apiVersion() external view returns (string memory); function governance() external view returns (address); function initialize( address _token, address _governance, address _rewards, string calldata _name, string calldata _symbol, address _guardian ) external; }
Contract ABI
[{"type":"event","name":"NewClone","inputs":[{"type":"address","name":"vault","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"NewRelease","inputs":[{"type":"uint256","name":"releaseId","internalType":"uint256","indexed":true},{"type":"address","name":"template","internalType":"address","indexed":false},{"type":"string","name":"apiVersion","internalType":"string","indexed":false}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"function","stateMutability":"view","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"latestRelease","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"newRelease","inputs":[{"type":"address","name":"_vault","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"newVault","inputs":[{"type":"address","name":"_token","internalType":"address"},{"type":"address","name":"_guardian","internalType":"address"},{"type":"address","name":"_rewards","internalType":"address"},{"type":"string","name":"_name","internalType":"string"},{"type":"string","name":"_symbol","internalType":"string"}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"newVault","inputs":[{"type":"address","name":"_token","internalType":"address"},{"type":"address","name":"_governance","internalType":"address"},{"type":"address","name":"_guardian","internalType":"address"},{"type":"address","name":"_rewards","internalType":"address"},{"type":"string","name":"_name","internalType":"string"},{"type":"string","name":"_symbol","internalType":"string"},{"type":"uint256","name":"_releaseDelta","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"numReleases","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"owner","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"releases","inputs":[{"type":"uint256","name":"","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"renounceOwnership","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"transferOwnership","inputs":[{"type":"address","name":"newOwner","internalType":"address"}]}]
Contract Creation Code
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
Deployed ByteCode
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