File size: 70,263 Bytes
f998fcd |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
{
"language": "Solidity",
"sources": {
"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol": {
"content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorV3Interface {\n function decimals() external view returns (uint8);\n\n function description() external view returns (string memory);\n\n function version() external view returns (uint256);\n\n // getRoundData and latestRoundData should both raise \"No data present\"\n // if they do not have data to report, instead of returning unset values\n // which could be misinterpreted as actual reported values.\n function getRoundData(uint80 _roundId)\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n );\n\n function latestRoundData()\n external\n view\n returns (\n uint80 roundId,\n int256 answer,\n uint256 startedAt,\n uint256 updatedAt,\n uint80 answeredInRound\n );\n}\n"
},
"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol": {
"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n function __Ownable_init() internal onlyInitializing {\n __Ownable_init_unchained();\n }\n\n function __Ownable_init_unchained() internal onlyInitializing {\n _transferOwnership(_msgSender());\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n _checkOwner();\n _;\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if the sender is not the owner.\n */\n function _checkOwner() internal view virtual {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[49] private __gap;\n}\n"
},
"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": {
"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n /**\n * @dev Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n */\n uint8 private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized(uint8 version);\n\n /**\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\n */\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\n );\n _initialized = 1;\n if (isTopLevelCall) {\n _initializing = true;\n }\n _;\n if (isTopLevelCall) {\n _initializing = false;\n emit Initialized(1);\n }\n }\n\n /**\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n *\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\n * initialization step. This is essential to configure modules that are added through upgrades and that require\n * initialization.\n *\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n */\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n _initialized = version;\n _initializing = true;\n _;\n _initializing = false;\n emit Initialized(version);\n }\n\n /**\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n */\n modifier onlyInitializing() {\n require(_initializing, \"Initializable: contract is not initializing\");\n _;\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n */\n function _disableInitializers() internal virtual {\n require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized < type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n}\n"
},
"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": {
"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n"
},
"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol": {
"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n function __Context_init() internal onlyInitializing {\n }\n\n function __Context_init_unchained() internal onlyInitializing {\n }\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n\n /**\n * @dev This empty reserved space is put in place to allow future versions to add new\n * variables without shifting down storage in the inheritance chain.\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n */\n uint256[50] private __gap;\n}\n"
},
"@openzeppelin/contracts/access/Ownable.sol": {
"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor() {\n _transferOwnership(_msgSender());\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n _checkOwner();\n _;\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if the sender is not the owner.\n */\n function _checkOwner() internal view virtual {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n}\n"
},
"@openzeppelin/contracts/proxy/Clones.sol": {
"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/Clones.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\n * deploying minimal proxy contracts, also known as \"clones\".\n *\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\n *\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\n * deterministic method.\n *\n * _Available since v3.4._\n */\nlibrary Clones {\n /**\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n *\n * This function uses the create opcode, which should never revert.\n */\n function clone(address implementation) internal returns (address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n instance := create(0, ptr, 0x37)\n }\n require(instance != address(0), \"ERC1167: create failed\");\n }\n\n /**\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n *\n * This function uses the create2 opcode and a `salt` to deterministically deploy\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\n * the clones cannot be deployed twice at the same address.\n */\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n instance := create2(0, ptr, 0x37, salt)\n }\n require(instance != address(0), \"ERC1167: create2 failed\");\n }\n\n /**\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n */\n function predictDeterministicAddress(\n address implementation,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n /// @solidity memory-safe-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n mstore(add(ptr, 0x14), shl(0x60, implementation))\n mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)\n mstore(add(ptr, 0x38), shl(0x60, deployer))\n mstore(add(ptr, 0x4c), salt)\n mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))\n predicted := keccak256(add(ptr, 0x37), 0x55)\n }\n }\n\n /**\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n */\n function predictDeterministicAddress(address implementation, bytes32 salt)\n internal\n view\n returns (address predicted)\n {\n return predictDeterministicAddress(implementation, salt, address(this));\n }\n}\n"
},
"@openzeppelin/contracts/token/ERC20/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(\n address from,\n address to,\n uint256 amount\n ) external returns (bool);\n}\n"
},
"@openzeppelin/contracts/utils/Context.sol": {
"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n}\n"
},
"contracts/factories/FactoryRSCPrepayment.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.4;\n\nimport \"@openzeppelin/contracts/proxy/Clones.sol\";\nimport \"contracts/revenue-share-contracts/BaseRSCPrepayment.sol\";\nimport \"contracts/revenue-share-contracts/RSCPrepayment.sol\";\nimport \"contracts/revenue-share-contracts/RSCPrepaymentUSD.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\n\n\ncontract XLARSCPrepaymentFactory is Ownable {\n address payable public immutable contractImplementation;\n address payable public immutable contractImplementationUsd;\n\n uint256 constant version = 1;\n uint256 public platformFee;\n address payable public platformWallet;\n\n struct RSCCreateData {\n string name;\n address controller;\n address distributor;\n bool immutableController;\n bool autoEthDistribution;\n uint256 minAutoDistributeAmount;\n address payable investor;\n uint256 investedAmount;\n uint256 interestRate;\n uint256 residualInterestRate;\n address payable [] initialRecipients;\n uint256[] percentages;\n string[] names;\n address[] supportedErc20addresses;\n address[] erc20PriceFeeds;\n }\n\n struct RSCCreateUsdData {\n string name;\n address controller;\n address distributor;\n bool immutableController;\n bool autoEthDistribution;\n uint256 minAutoDistributeAmount;\n address payable investor;\n uint256 investedAmount;\n uint256 interestRate;\n uint256 residualInterestRate;\n address ethUsdPriceFeed;\n address payable [] initialRecipients;\n uint256[] percentages;\n string[] names;\n address[] supportedErc20addresses;\n address[] erc20PriceFeeds;\n }\n\n event RSCPrepaymentCreated(\n address contractAddress,\n address controller,\n address distributor,\n string name,\n uint256 version,\n bool immutableController,\n bool autoEthDistribution,\n uint256 minAutoDistributeAmount,\n uint256 investedAmount,\n uint256 interestRate,\n uint256 residualInterestRate\n );\n\n event RSCPrepaymentUsdCreated(\n address contractAddress,\n address controller,\n address distributor,\n string name,\n uint256 version,\n bool immutableController,\n bool autoEthDistribution,\n uint256 minAutoDistributeAmount,\n uint256 investedAmount,\n uint256 interestRate,\n uint256 residualInterestRate,\n address ethUsdPriceFeed\n );\n\n event PlatformFeeChanged(\n uint256 oldFee,\n uint256 newFee\n );\n\n event PlatformWalletChanged(\n address payable oldPlatformWallet,\n address payable newPlatformWallet\n );\n\n constructor() {\n contractImplementation = payable(new XLARSCPrepayment());\n contractImplementationUsd = payable(new XLARSCPrepaymentUsd());\n }\n\n /**\n * @dev Public function for creating clone proxy pointing to RSC Investor\n * @param _data Initial data for creating new RSC Prepayment ETH contract\n * @return Address of new contract\n */\n function createRSCPrepayment(RSCCreateData memory _data) external returns(address) {\n address payable clone = payable(Clones.clone(contractImplementation));\n\n BaseRSCPrepayment.InitContractSetting memory contractSettings = BaseRSCPrepayment.InitContractSetting(\n msg.sender,\n _data.distributor,\n _data.controller,\n _data.immutableController,\n _data.autoEthDistribution,\n _data.minAutoDistributeAmount,\n platformFee,\n address(this),\n _data.supportedErc20addresses,\n _data.erc20PriceFeeds\n );\n\n XLARSCPrepayment(clone).initialize(\n contractSettings,\n _data.investor,\n _data.investedAmount,\n _data.interestRate,\n _data.residualInterestRate,\n _data.initialRecipients,\n _data.percentages,\n _data.names\n );\n\n emit RSCPrepaymentCreated(\n clone,\n _data.controller,\n _data.distributor,\n _data.name,\n version,\n _data.immutableController,\n _data.autoEthDistribution,\n _data.minAutoDistributeAmount,\n _data.investedAmount,\n _data.interestRate,\n _data.residualInterestRate\n );\n\n return clone;\n }\n\n /**\n * @dev Public function for creating clone proxy pointing to RSC Investor\n * @param _data Initial data for creating new RSC Prepayment USD contract\n * @return Address of new contract\n */\n function createRSCPrepaymentUsd(RSCCreateUsdData memory _data) external returns(address) {\n address payable clone = payable(Clones.clone(contractImplementationUsd));\n\n BaseRSCPrepayment.InitContractSetting memory contractSettings = BaseRSCPrepayment.InitContractSetting(\n msg.sender,\n _data.distributor,\n _data.controller,\n _data.immutableController,\n _data.autoEthDistribution,\n _data.minAutoDistributeAmount,\n platformFee,\n address(this),\n _data.supportedErc20addresses,\n _data.erc20PriceFeeds\n );\n\n XLARSCPrepaymentUsd(clone).initialize(\n contractSettings,\n _data.investor,\n _data.investedAmount,\n _data.interestRate,\n _data.residualInterestRate,\n _data.ethUsdPriceFeed,\n _data.initialRecipients,\n _data.percentages,\n _data.names\n );\n\n emit RSCPrepaymentUsdCreated(\n clone,\n _data.controller,\n _data.distributor,\n _data.name,\n version,\n _data.immutableController,\n _data.autoEthDistribution,\n _data.minAutoDistributeAmount,\n _data.investedAmount,\n _data.interestRate,\n _data.residualInterestRate,\n _data.ethUsdPriceFeed\n );\n\n return clone;\n }\n\n /**\n * @dev Only Owner function for setting platform fee\n * @param _fee Percentage define platform fee 100% == 10000\n */\n function setPlatformFee(uint256 _fee) external onlyOwner {\n emit PlatformFeeChanged(platformFee, _fee);\n platformFee = _fee;\n }\n\n /**\n * @dev Only Owner function for setting platform fee\n * @param _platformWallet New ETH wallet which will receive ETH\n */\n function setPlatformWallet(address payable _platformWallet) external onlyOwner {\n emit PlatformWalletChanged(platformWallet, _platformWallet);\n platformWallet = _platformWallet;\n }\n}\n"
},
"contracts/interfaces/IFeeFactory.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.4;\n\ninterface IFeeFactory {\n function platformWallet() external returns(address payable);\n}\n"
},
"contracts/revenue-share-contracts/BaseRSCPrepayment.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.4;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\nimport \"../interfaces/IFeeFactory.sol\";\n\n\ncontract BaseRSCPrepayment is OwnableUpgradeable {\n address public distributor;\n address public controller;\n bool public immutableController;\n bool public autoEthDistribution;\n uint256 public minAutoDistributionAmount;\n uint256 public platformFee;\n IFeeFactory public factory;\n\n uint256 public interestRate;\n uint256 public residualInterestRate;\n\n address payable public investor;\n uint256 public investedAmount;\n uint256 public investorAmountToReceive;\n uint256 public investorReceivedAmount;\n\n address payable [] public recipients;\n mapping(address => uint256) public recipientsPercentage;\n uint256 public numberOfRecipients;\n\n struct InitContractSetting {\n address owner;\n address distributor;\n address controller;\n bool immutableController;\n bool autoEthDistribution;\n uint256 minAutoDistributionAmount;\n uint256 platformFee;\n address factoryAddress;\n address[] supportedErc20addresses;\n address[] erc20PriceFeeds;\n }\n\n event SetRecipients(address payable [] recipients, uint256[] percentages, string[] names);\n event DistributeToken(address token, uint256 amount);\n event DistributorChanged(address oldDistributor, address newDistributor);\n event ControllerChanged(address oldController, address newController);\n\n // Throw when if sender is not distributor\n error OnlyDistributorError();\n\n // Throw when sender is not controller\n error OnlyControllerError();\n\n // Throw when transaction fails\n error TransferFailedError();\n\n // Throw when submitted recipient with address(0)\n error NullAddressRecipientError();\n\n // Throw if recipient is already in contract\n error RecipientAlreadyAddedError();\n\n // Throw when arrays are submit without same length\n error InconsistentDataLengthError();\n\n // Throw when sum of percentage is not 100%\n error InvalidPercentageError();\n\n // Throw when RSC doesnt have any ERC20 balance for given token\n error Erc20ZeroBalanceError();\n\n // Throw when distributor address is same as submit one\n error DistributorAlreadyConfiguredError();\n\n // Throw when distributor address is same as submit one\n error ControllerAlreadyConfiguredError();\n\n // Throw when change is triggered for immutable controller\n error ImmutableControllerError();\n\n /**\n * @dev Throws if sender is not distributor\n */\n modifier onlyDistributor {\n if (msg.sender != distributor) {\n revert OnlyDistributorError();\n }\n _;\n }\n\n /**\n * @dev Checks whether sender is controller\n */\n modifier onlyController {\n if (msg.sender != controller) {\n revert OnlyControllerError();\n }\n _;\n }\n\n fallback() external payable {\n if (autoEthDistribution && msg.value >= minAutoDistributionAmount) {\n _redistributeEth(msg.value);\n }\n }\n\n receive() external payable {\n if (autoEthDistribution && msg.value >= minAutoDistributionAmount) {\n _redistributeEth(msg.value);\n }\n }\n\n /**\n * @notice Internal function to redistribute ETH based on percentages assign to the recipients\n * @param _valueToDistribute ETH amount to be distribute\n */\n function _redistributeEth(uint256 _valueToDistribute) internal virtual {}\n\n\n /**\n * @notice External function to redistribute ETH based on percentages assign to the recipients\n */\n function redistributeEth() external onlyDistributor {\n _redistributeEth(address(this).balance);\n }\n\n /**\n * @notice Internal function to check whether percentages are equal to 100%\n * @return valid boolean indicating whether sum of percentage == 100%\n */\n function _percentageIsValid() internal view returns (bool valid){\n uint256 recipientsLength = recipients.length;\n uint256 percentageSum;\n\n for (uint256 i = 0; i < recipientsLength;) {\n address recipient = recipients[i];\n percentageSum += recipientsPercentage[recipient];\n unchecked {i++;}\n }\n\n return percentageSum == 10000;\n }\n\n /**\n * @notice Internal function for adding recipient to revenue share\n * @param _recipient Fixed amount of token user want to buy\n * @param _percentage code of the affiliation partner\n */\n function _addRecipient(address payable _recipient, uint256 _percentage) internal {\n if (_recipient == address(0)) {\n revert NullAddressRecipientError();\n }\n if (recipientsPercentage[_recipient] != 0) {\n revert RecipientAlreadyAddedError();\n }\n recipients.push(_recipient);\n recipientsPercentage[_recipient] = _percentage;\n }\n\n /**\n * @notice function for removing all recipients\n */\n function _removeAll() internal {\n if (numberOfRecipients == 0) {\n return;\n }\n\n for (uint256 i = 0; i < numberOfRecipients;) {\n address recipient = recipients[i];\n recipientsPercentage[recipient] = 0;\n unchecked{i++;}\n }\n delete recipients;\n numberOfRecipients = 0;\n }\n\n /**\n * @notice Internal function to set recipients in one TX\n * @param _newRecipients Addresses to be added as a new recipients\n * @param _percentages new percentages for recipients\n * @param _names recipients names\n */\n function _setRecipients(\n address payable [] memory _newRecipients,\n uint256[] memory _percentages,\n string[] memory _names\n ) internal {\n uint256 newRecipientsLength = _newRecipients.length;\n if (\n newRecipientsLength != _percentages.length &&\n newRecipientsLength != _names.length\n ) {\n revert InconsistentDataLengthError();\n }\n\n _removeAll();\n\n for (uint256 i = 0; i < newRecipientsLength;) {\n _addRecipient(_newRecipients[i], _percentages[i]);\n unchecked{i++;}\n }\n\n numberOfRecipients = newRecipientsLength;\n if (_percentageIsValid() == false) {\n revert InvalidPercentageError();\n }\n emit SetRecipients(_newRecipients, _percentages, _names);\n }\n\n /**\n * @notice External function for setting recipients\n * @param _newRecipients Addresses to be added\n * @param _percentages new percentages for recipients\n * @param _names names for recipients\n */\n function setRecipients(\n address payable [] memory _newRecipients,\n uint256[] memory _percentages,\n string[] memory _names\n ) public onlyController {\n _setRecipients(_newRecipients, _percentages, _names);\n }\n\n /**\n * @notice External function to set distributor address\n * @param _distributor address of new distributor\n */\n function setDistributor(address _distributor) external onlyOwner {\n if (_distributor == distributor) {\n revert DistributorAlreadyConfiguredError();\n }\n emit DistributorChanged(distributor, _distributor);\n distributor = _distributor;\n }\n\n /**\n * @notice External function to set controller address, if set to address(0), unable to change it\n * @param _controller address of new controller\n */\n function setController(address _controller) external onlyOwner {\n if (controller == address(0) || immutableController) {\n revert ImmutableControllerError();\n }\n emit ControllerChanged(controller, _controller);\n controller = _controller;\n }\n}\n"
},
"contracts/revenue-share-contracts/RSCPrepayment.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.4;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\nimport \"./BaseRSCPrepayment.sol\";\n\n\ncontract XLARSCPrepayment is Initializable, BaseRSCPrepayment {\n\n mapping(address => address) tokenEthPriceFeeds;\n event TokenPriceFeedSet(address token, address priceFeed);\n\n // Throws when trying to fetch ETH price for token without oracle\n error TokenMissingEthPriceOracle();\n\n /**\n * @dev Constructor function, can be called only once\n * @param _settings Contract settings, check InitContractSetting struct\n * @param _investor Address who invested money and is gonna receive interested rates\n * @param _investedAmount Amount of invested money from investor\n * @param _interestRate Percentage how much more investor will receive upon his investment amount\n * @param _residualInterestRate Percentage how much investor will get after his investment is fulfilled\n * @param _initialRecipients Addresses to be added as a initial recipients\n * @param _percentages percentages for recipients\n * @param _names recipients names\n */\n function initialize(\n InitContractSetting memory _settings,\n address payable _investor,\n uint256 _investedAmount,\n uint256 _interestRate,\n uint256 _residualInterestRate,\n address payable [] memory _initialRecipients,\n uint256[] memory _percentages,\n string[] memory _names\n ) public initializer {\n // Contract settings\n controller = _settings.controller;\n distributor = _settings.distributor;\n immutableController = _settings.immutableController;\n autoEthDistribution = _settings.autoEthDistribution;\n minAutoDistributionAmount = _settings.minAutoDistributionAmount;\n factory = IFeeFactory(_settings.factoryAddress);\n platformFee = _settings.platformFee;\n _transferOwnership(_settings.owner);\n uint256 supportedErc20Length = _settings.supportedErc20addresses.length;\n if (supportedErc20Length != _settings.erc20PriceFeeds.length) {\n revert InconsistentDataLengthError();\n }\n for (uint256 i = 0; i < supportedErc20Length;) {\n _setTokenEthPriceFeed(_settings.supportedErc20addresses[i], _settings.erc20PriceFeeds[i]);\n unchecked{i++;}\n }\n\n // Investor setting\n investor = _investor;\n investedAmount = _investedAmount;\n interestRate = _interestRate;\n residualInterestRate = _residualInterestRate;\n investorAmountToReceive = _investedAmount + _investedAmount / 10000 * interestRate;\n\n // Recipients settings\n _setRecipients(_initialRecipients, _percentages, _names);\n }\n\n /**\n * @notice Internal function to redistribute ETH based on percentages assign to the recipients\n * @param _valueToDistribute ETH amount to be distribute\n */\n function _redistributeEth(uint256 _valueToDistribute) internal override {\n // Platform Fee\n if (platformFee > 0) {\n uint256 fee = _valueToDistribute / 10000 * platformFee;\n _valueToDistribute -= fee;\n address payable platformWallet = factory.platformWallet();\n (bool success,) = platformWallet.call{value: fee}(\"\");\n if (success == false) {\n revert TransferFailedError();\n }\n }\n\n // Distribute to investor\n uint256 investorRemainingAmount = investorAmountToReceive - investorReceivedAmount;\n uint256 amountToDistribute;\n if (investorRemainingAmount == 0) {\n // Investor was already fulfilled and is now receiving residualInterestRate\n uint256 investorInterest = _valueToDistribute / 10000 * residualInterestRate;\n amountToDistribute = _valueToDistribute - investorInterest;\n (bool success,) = payable(investor).call{value: investorInterest}(\"\");\n if (success == false) {\n revert TransferFailedError();\n }\n\n } else {\n // Investor was not yet fully fulfill, we first fulfill him, and then distribute share to recipients\n if (_valueToDistribute <= investorRemainingAmount) {\n // We can send whole msg.value to investor\n (bool success,) = payable(investor).call{value: _valueToDistribute}(\"\");\n if (success == false) {\n revert TransferFailedError();\n }\n investorReceivedAmount += _valueToDistribute;\n return;\n } else {\n // msg.value is more than investor will receive, so we send him his part and redistribute the rest\n uint256 investorInterestBonus = (_valueToDistribute - investorRemainingAmount) / 10000 * residualInterestRate;\n (bool success,) = payable(investor).call{value: investorRemainingAmount + investorInterestBonus}(\"\");\n if (success == false) {\n revert TransferFailedError();\n }\n amountToDistribute = _valueToDistribute - investorRemainingAmount - investorInterestBonus;\n investorReceivedAmount += investorRemainingAmount;\n }\n }\n\n // Distribute to recipients\n uint256 recipientsLength = recipients.length;\n for (uint256 i = 0; i < recipientsLength;) {\n address payable recipient = recipients[i];\n uint256 percentage = recipientsPercentage[recipient];\n uint256 amountToReceive = amountToDistribute / 10000 * percentage;\n (bool success,) = payable(recipient).call{value: amountToReceive}(\"\");\n if (success == false) {\n revert TransferFailedError();\n }\n unchecked{i++;}\n }\n }\n\n /**\n * @notice External function to redistribute ERC20 token based on percentages assign to the recipients\n * @param _token Address of the ERC20 token to be distribute\n */\n function redistributeToken(address _token) external onlyDistributor {\n IERC20 erc20Token = IERC20(_token);\n uint256 contractBalance = erc20Token.balanceOf(address(this));\n if (contractBalance == 0) {\n revert Erc20ZeroBalanceError();\n }\n\n // Platform Fee\n if (platformFee > 0) {\n uint256 fee = contractBalance / 10000 * platformFee;\n contractBalance -= fee;\n address payable platformWallet = factory.platformWallet();\n erc20Token.transfer(platformWallet, fee);\n }\n\n // Distribute to investor\n uint256 investorRemainingAmount = investorAmountToReceive - investorReceivedAmount;\n uint256 investorRemainingAmountToken = _convertEthToToken(_token, investorRemainingAmount);\n\n uint256 amountToDistribute;\n\n if (investorRemainingAmount == 0) {\n // Investor was already fulfilled and is now receiving residualInterestRate\n uint256 investorInterest = contractBalance / 10000 * residualInterestRate;\n amountToDistribute = contractBalance - investorInterest;\n erc20Token.transfer(investor, investorInterest);\n } else {\n // Investor was not yet fully fulfill, we first fulfill him, and then distribute share to recipients\n if (contractBalance <= investorRemainingAmountToken) {\n // We can send whole contract erc20 balance to investor\n erc20Token.transfer(investor, contractBalance);\n investorReceivedAmount += _convertTokenToEth(_token, contractBalance);\n emit DistributeToken(_token, contractBalance);\n return;\n } else {\n // contractBalance is more than investor will receive, so we send him his part and redistribute the rest\n uint256 investorInterestBonus = (contractBalance - investorRemainingAmountToken) / 10000 * residualInterestRate;\n erc20Token.transfer(investor, investorRemainingAmountToken + investorInterestBonus);\n amountToDistribute = contractBalance - investorRemainingAmountToken - investorInterestBonus;\n investorReceivedAmount += investorRemainingAmount;\n }\n }\n\n // Distribute to recipients\n uint256 recipientsLength = recipients.length;\n for (uint256 i = 0; i < recipientsLength;) {\n address payable recipient = recipients[i];\n uint256 percentage = recipientsPercentage[recipient];\n uint256 amountToReceive = amountToDistribute / 10000 * percentage;\n erc20Token.transfer(recipient, amountToReceive);\n unchecked{i++;}\n }\n emit DistributeToken(_token, contractBalance);\n }\n\n /**\n * @notice internal function that returns erc20/eth price from external oracle\n * @param _token Address of the token\n */\n function _getTokenEthPrice(address _token) private view returns (uint256) {\n address tokenOracleAddress = tokenEthPriceFeeds[_token];\n if (tokenOracleAddress == address(0)) {\n revert TokenMissingEthPriceOracle();\n }\n AggregatorV3Interface tokenEthPriceFeed = AggregatorV3Interface(tokenOracleAddress);\n (,int256 price,,,) = tokenEthPriceFeed.latestRoundData();\n return uint256(price);\n }\n\n /**\n * @notice Internal function to convert ETH value to ETH value\n * @param _token token address\n * @param _tokenValue Token value to be converted to USD\n */\n function _convertTokenToEth(address _token, uint256 _tokenValue) internal view returns (uint256) {\n return (_getTokenEthPrice(_token) * _tokenValue) / 1e18;\n }\n\n /**\n * @notice Internal function to convert Eth value to token value\n * @param _token token address\n * @param _ethValue Eth value to be converted\n */\n function _convertEthToToken(address _token, uint256 _ethValue) internal view returns (uint256) {\n return (_ethValue * 1e25 / _getTokenEthPrice(_token) * 1e25) / 1e32;\n }\n\n /**\n * @notice External function for setting price feed oracle for token\n * @param _token address of token\n * @param _priceFeed address of ETH price feed for given token\n */\n function setTokenEthPriceFeed(address _token, address _priceFeed) external onlyOwner {\n _setTokenEthPriceFeed(_token, _priceFeed);\n }\n\n /**\n * @notice internal function for setting price feed oracle for token\n * @param _token address of token\n * @param _priceFeed address of ETH price feed for given token\n */\n function _setTokenEthPriceFeed(address _token, address _priceFeed) internal {\n tokenEthPriceFeeds[_token] = _priceFeed;\n emit TokenPriceFeedSet(_token, _priceFeed);\n }\n}\n"
},
"contracts/revenue-share-contracts/RSCPrepaymentUSD.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.4;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport \"./BaseRSCPrepayment.sol\";\n\n\ncontract XLARSCPrepaymentUsd is Initializable, BaseRSCPrepayment {\n\n mapping(address => address) tokenUsdPriceFeeds;\n AggregatorV3Interface internal ethUsdPriceFeed;\n\n event TokenPriceFeedSet(address token, address priceFeed);\n event EthPriceFeedSet(address oldEthPriceFeed, address newEthPriceFeed);\n\n // Throws when trying to fetch USD price for token without oracle\n error TokenMissingPriceOracle();\n\n /**\n * @dev Constructor function, can be called only once\n * @param _settings Contract settings, check InitContractSetting struct\n * @param _investor Address who invested money and is gonna receive interested rates\n * @param _investedAmount Amount of invested money from investor\n * @param _interestRate Percentage how much more investor will receive upon his investment amount\n * @param _residualInterestRate Percentage how much investor will get after his investment is fulfilled\n * @param _ethUsdPriceFeed oracle address for ETH / USD price\n * @param _initialRecipients Addresses to be added as a initial recipients\n * @param _percentages percentages for recipients\n * @param _names recipients names\n */\n function initialize(\n InitContractSetting memory _settings,\n address payable _investor,\n uint256 _investedAmount,\n uint256 _interestRate,\n uint256 _residualInterestRate,\n address _ethUsdPriceFeed,\n address payable [] memory _initialRecipients,\n uint256[] memory _percentages,\n string[] memory _names\n ) public initializer {\n // Contract settings\n controller = _settings.controller;\n distributor = _settings.distributor;\n immutableController = _settings.immutableController;\n autoEthDistribution = _settings.autoEthDistribution;\n minAutoDistributionAmount = _settings.minAutoDistributionAmount;\n factory = IFeeFactory(_settings.factoryAddress);\n platformFee = _settings.platformFee;\n ethUsdPriceFeed = AggregatorV3Interface(_ethUsdPriceFeed);\n _transferOwnership(_settings.owner);\n uint256 supportedErc20Length = _settings.supportedErc20addresses.length;\n if (supportedErc20Length != _settings.erc20PriceFeeds.length) {\n revert InconsistentDataLengthError();\n }\n for (uint256 i = 0; i < supportedErc20Length;) {\n _setTokenUsdPriceFeed(_settings.supportedErc20addresses[i], _settings.erc20PriceFeeds[i]);\n unchecked{i++;}\n }\n\n\n // Investor setting\n investor = _investor;\n investedAmount = _investedAmount;\n interestRate = _interestRate;\n residualInterestRate = _residualInterestRate;\n investorAmountToReceive = _investedAmount + _investedAmount / 10000 * interestRate;\n\n // Recipients settings\n _setRecipients(_initialRecipients, _percentages, _names);\n }\n\n /**\n * @notice Internal function to redistribute ETH based on percentages assign to the recipients\n * @param _valueToDistribute ETH amount to be distribute\n */\n function _redistributeEth(uint256 _valueToDistribute) internal override {\n // Platform Fee\n if (platformFee > 0) {\n uint256 fee = _valueToDistribute / 10000 * platformFee;\n _valueToDistribute -= fee;\n address payable platformWallet = factory.platformWallet();\n (bool success,) = platformWallet.call{value: fee}(\"\");\n if (success == false) {\n revert TransferFailedError();\n }\n }\n\n // Distribute to investor\n uint256 investorRemainingAmount = investorAmountToReceive - investorReceivedAmount;\n uint256 investorRemainingAmountEth = _convertUsdToEth(investorRemainingAmount);\n uint256 amountToDistribute;\n\n if (investorRemainingAmount == 0) {\n // Investor was already fulfilled and is not receiving residualInterestRate\n uint256 investorInterest = _valueToDistribute / 10000 * residualInterestRate;\n amountToDistribute = _valueToDistribute - investorInterest;\n (bool success,) = payable(investor).call{value: investorInterest}(\"\");\n if (success == false) {\n revert TransferFailedError();\n }\n\n } else {\n // Investor was not yet fully fulfill, we first fulfill him, and then distribute share to recipients\n if (_valueToDistribute <= investorRemainingAmountEth) {\n // We can send whole _valueToDistribute to investor\n (bool success,) = payable(investor).call{value: _valueToDistribute}(\"\");\n if (success == false) {\n revert TransferFailedError();\n }\n investorReceivedAmount += _convertEthToUsd(_valueToDistribute);\n return;\n } else {\n // msg.value is more than investor will receive, so we send him his part and redistribute the rest\n uint256 investorInterestBonus = (_valueToDistribute - investorRemainingAmountEth) / 10000 * residualInterestRate;\n (bool success,) = payable(investor).call{value: investorRemainingAmountEth + investorInterestBonus}(\"\");\n if (success == false) {\n revert TransferFailedError();\n }\n amountToDistribute = _valueToDistribute - investorRemainingAmountEth - investorInterestBonus;\n investorReceivedAmount += investorRemainingAmount;\n }\n }\n\n uint256 recipientsLength = recipients.length;\n for (uint256 i = 0; i < recipientsLength;) {\n address payable recipient = recipients[i];\n uint256 percentage = recipientsPercentage[recipient];\n uint256 amountToReceive = amountToDistribute / 10000 * percentage;\n (bool success,) = payable(recipient).call{value: amountToReceive}(\"\");\n if (success == false) {\n revert TransferFailedError();\n }\n unchecked{i++;}\n }\n }\n\n /**\n * @notice Internal function to convert ETH value to Usd value\n * @param _ethValue ETH value to be converted\n */\n function _convertEthToUsd(uint256 _ethValue) internal view returns (uint256) {\n return (_getEthUsdPrice() * _ethValue) / 1e18;\n }\n\n /**\n * @notice Internal function to convert USD value to ETH value\n * @param _usdValue Usd value to be converted\n */\n function _convertUsdToEth(uint256 _usdValue) internal view returns (uint256) {\n return (_usdValue * 1e25 / _getEthUsdPrice() * 1e25) / 1e32;\n }\n\n /**\n * @notice Internal function to convert Token value to Usd value\n * @param _token token address\n * @param _tokenValue Token value to be converted to USD\n */\n function _convertTokenToUsd(address _token, uint256 _tokenValue) internal view returns (uint256) {\n return (_getTokenUsdPrice(_token) * _tokenValue) / 1e18;\n }\n\n /**\n * @notice Internal function to convert USD value to ETH value\n * @param _token token address\n * @param _usdValue Usd value to be converted\n */\n function _convertUsdToToken(address _token, uint256 _usdValue) internal view returns (uint256) {\n return (_usdValue * 1e25 / _getTokenUsdPrice(_token) * 1e25) / 1e32;\n }\n\n /**\n * @notice internal function that returns eth/usd price from external oracle\n */\n function _getEthUsdPrice() private view returns (uint256) {\n (,int256 price,,,) = ethUsdPriceFeed.latestRoundData();\n return uint256(price * 1e10);\n }\n\n /**\n * @notice internal function that returns erc20/usd price from external oracle\n * @param _token Address of the token\n */\n function _getTokenUsdPrice(address _token) private view returns (uint256) {\n address tokenOracleAddress = tokenUsdPriceFeeds[_token];\n if (tokenOracleAddress == address(0)) {\n revert TokenMissingPriceOracle();\n }\n AggregatorV3Interface tokenUsdPriceFeed = AggregatorV3Interface(tokenOracleAddress);\n (,int256 price,,,) = tokenUsdPriceFeed.latestRoundData();\n return uint256(price * 1e10);\n }\n\n /**\n * @notice External function to redistribute ERC20 token based on percentages assign to the recipients\n * @param _token Address of the token to be distributed\n */\n function redistributeToken(address _token) external onlyDistributor {\n IERC20 erc20Token = IERC20(_token);\n uint256 contractBalance = erc20Token.balanceOf(address(this));\n if (contractBalance == 0) {\n revert Erc20ZeroBalanceError();\n }\n\n // Platform Fee\n if (platformFee > 0) {\n uint256 fee = contractBalance / 10000 * platformFee;\n contractBalance -= fee;\n address payable platformWallet = factory.platformWallet();\n erc20Token.transfer(platformWallet, fee);\n }\n\n // Distribute to investor\n uint256 investorRemainingAmount = investorAmountToReceive - investorReceivedAmount;\n uint256 investorRemainingAmountToken = _convertUsdToToken(_token, investorRemainingAmount);\n\n uint256 amountToDistribute;\n\n if (investorRemainingAmount == 0) {\n // Investor was already fulfilled and is now receiving residualInterestRate\n uint256 investorInterest = contractBalance / 10000 * residualInterestRate;\n amountToDistribute = contractBalance - investorInterest;\n erc20Token.transfer(investor, investorInterest);\n } else {\n // Investor was not yet fully fulfill, we first fulfill him, and then distribute share to recipients\n if (contractBalance <= investorRemainingAmountToken) {\n // We can send whole contract erc20 balance to investor\n erc20Token.transfer(investor, contractBalance);\n investorReceivedAmount += _convertTokenToUsd(_token, contractBalance);\n emit DistributeToken(_token, contractBalance);\n return;\n } else {\n // contractBalance is more than investor will receive, so we send him his part and redistribute the rest\n uint256 investorInterestBonus = (contractBalance - investorRemainingAmountToken) / 10000 * residualInterestRate;\n erc20Token.transfer(investor, investorRemainingAmountToken + investorInterestBonus);\n amountToDistribute = contractBalance - investorRemainingAmountToken - investorInterestBonus;\n investorReceivedAmount += investorRemainingAmount;\n }\n }\n\n // Distribute to recipients\n uint256 recipientsLength = recipients.length;\n for (uint256 i = 0; i < recipientsLength;) {\n address payable recipient = recipients[i];\n uint256 percentage = recipientsPercentage[recipient];\n uint256 amountToReceive = amountToDistribute / 10000 * percentage;\n erc20Token.transfer(recipient, amountToReceive);\n unchecked{i++;}\n }\n emit DistributeToken(_token, contractBalance);\n }\n\n /**\n * @notice External function for setting price feed oracle for token\n * @param _token address of token\n * @param _priceFeed address of USD price feed for given token\n */\n function setTokenUsdPriceFeed(address _token, address _priceFeed) external onlyOwner {\n _setTokenUsdPriceFeed(_token, _priceFeed);\n }\n\n /**\n * @notice Internal function for setting price feed oracle for token\n * @param _token address of token\n * @param _priceFeed address of USD price feed for given token\n */\n function _setTokenUsdPriceFeed(address _token, address _priceFeed) internal {\n tokenUsdPriceFeeds[_token] = _priceFeed;\n emit TokenPriceFeedSet(_token, _priceFeed);\n }\n\n /**\n * @notice External function for setting price feed oracle for ETH\n * @param _priceFeed address of USD price feed for ETH\n */\n function setEthPriceFeed(address _priceFeed) external onlyOwner {\n emit EthPriceFeedSet(address(ethUsdPriceFeed), _priceFeed);\n ethUsdPriceFeed = AggregatorV3Interface(_priceFeed);\n }\n}\n"
}
},
"settings": {
"optimizer": {
"enabled": true,
"runs": 10000
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"libraries": {}
}
} |