{{ "language": "Solidity", "sources": { "@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/token/ERC20/extensions/draft-IERC20Permit.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20Permit {\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(address owner) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\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/token/ERC20/utils/SafeERC20.sol": { "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../extensions/draft-IERC20Permit.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n using Address for address;\n\n function safeTransfer(\n IERC20 token,\n address to,\n uint256 value\n ) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n function safeTransferFrom(\n IERC20 token,\n address from,\n address to,\n uint256 value\n ) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(\n IERC20 token,\n address spender,\n uint256 value\n ) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n require(\n (value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n function safeIncreaseAllowance(\n IERC20 token,\n address spender,\n uint256 value\n ) internal {\n uint256 newAllowance = token.allowance(address(this), spender) + value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n\n function safeDecreaseAllowance(\n IERC20 token,\n address spender,\n uint256 value\n ) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n uint256 newAllowance = oldAllowance - value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n }\n\n function safePermit(\n IERC20Permit token,\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal {\n uint256 nonceBefore = token.nonces(owner);\n token.permit(owner, spender, value, deadline, v, r, s);\n uint256 nonceAfter = token.nonces(owner);\n require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n if (returndata.length > 0) {\n // Return data is optional\n require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n }\n}\n" }, "@openzeppelin/contracts/utils/Address.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 Address {\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 Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n (bool success, bytes memory returndata) = target.delegatecall(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/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" }, "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol": { "content": "pragma solidity >=0.5.0;\n\ninterface IUniswapV2Factory {\n event PairCreated(address indexed token0, address indexed token1, address pair, uint);\n\n function feeTo() external view returns (address);\n function feeToSetter() external view returns (address);\n\n function getPair(address tokenA, address tokenB) external view returns (address pair);\n function allPairs(uint) external view returns (address pair);\n function allPairsLength() external view returns (uint);\n\n function createPair(address tokenA, address tokenB) external returns (address pair);\n\n function setFeeTo(address) external;\n function setFeeToSetter(address) external;\n}\n" }, "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol": { "content": "pragma solidity >=0.6.2;\n\ninterface IUniswapV2Router01 {\n function factory() external pure returns (address);\n function WETH() external pure returns (address);\n\n function addLiquidity(\n address tokenA,\n address tokenB,\n uint amountADesired,\n uint amountBDesired,\n uint amountAMin,\n uint amountBMin,\n address to,\n uint deadline\n ) external returns (uint amountA, uint amountB, uint liquidity);\n function addLiquidityETH(\n address token,\n uint amountTokenDesired,\n uint amountTokenMin,\n uint amountETHMin,\n address to,\n uint deadline\n ) external payable returns (uint amountToken, uint amountETH, uint liquidity);\n function removeLiquidity(\n address tokenA,\n address tokenB,\n uint liquidity,\n uint amountAMin,\n uint amountBMin,\n address to,\n uint deadline\n ) external returns (uint amountA, uint amountB);\n function removeLiquidityETH(\n address token,\n uint liquidity,\n uint amountTokenMin,\n uint amountETHMin,\n address to,\n uint deadline\n ) external returns (uint amountToken, uint amountETH);\n function removeLiquidityWithPermit(\n address tokenA,\n address tokenB,\n uint liquidity,\n uint amountAMin,\n uint amountBMin,\n address to,\n uint deadline,\n bool approveMax, uint8 v, bytes32 r, bytes32 s\n ) external returns (uint amountA, uint amountB);\n function removeLiquidityETHWithPermit(\n address token,\n uint liquidity,\n uint amountTokenMin,\n uint amountETHMin,\n address to,\n uint deadline,\n bool approveMax, uint8 v, bytes32 r, bytes32 s\n ) external returns (uint amountToken, uint amountETH);\n function swapExactTokensForTokens(\n uint amountIn,\n uint amountOutMin,\n address[] calldata path,\n address to,\n uint deadline\n ) external returns (uint[] memory amounts);\n function swapTokensForExactTokens(\n uint amountOut,\n uint amountInMax,\n address[] calldata path,\n address to,\n uint deadline\n ) external returns (uint[] memory amounts);\n function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)\n external\n payable\n returns (uint[] memory amounts);\n function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\n external\n returns (uint[] memory amounts);\n function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\n external\n returns (uint[] memory amounts);\n function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)\n external\n payable\n returns (uint[] memory amounts);\n\n function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);\n function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);\n function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);\n function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);\n function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);\n}\n" }, "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol": { "content": "pragma solidity >=0.6.2;\n\nimport './IUniswapV2Router01.sol';\n\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\n function removeLiquidityETHSupportingFeeOnTransferTokens(\n address token,\n uint liquidity,\n uint amountTokenMin,\n uint amountETHMin,\n address to,\n uint deadline\n ) external returns (uint amountETH);\n function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\n address token,\n uint liquidity,\n uint amountTokenMin,\n uint amountETHMin,\n address to,\n uint deadline,\n bool approveMax, uint8 v, bytes32 r, bytes32 s\n ) external returns (uint amountETH);\n\n function swapExactTokensForTokensSupportingFeeOnTransferTokens(\n uint amountIn,\n uint amountOutMin,\n address[] calldata path,\n address to,\n uint deadline\n ) external;\n function swapExactETHForTokensSupportingFeeOnTransferTokens(\n uint amountOutMin,\n address[] calldata path,\n address to,\n uint deadline\n ) external payable;\n function swapExactTokensForETHSupportingFeeOnTransferTokens(\n uint amountIn,\n uint amountOutMin,\n address[] calldata path,\n address to,\n uint deadline\n ) external;\n}\n" }, "contracts/Digits.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.10;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport \"@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol\";\nimport \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\n\nimport \"./DividendTracker.sol\";\nimport \"./interfaces/ITokenStorage.sol\";\nimport \"./interfaces/IDigits.sol\";\n\ncontract Digits is Ownable, IERC20, IDigits {\n using SafeERC20 for IERC20;\n\n /* ============ State ============ */\n\n address public constant DEAD = 0x000000000000000000000000000000000000dEaD;\n\n string private constant _name = \"Digits\";\n string private constant _symbol = \"DIGITS\";\n\n DividendTracker public immutable dividendTracker;\n IUniswapV2Router02 public immutable uniswapV2Router;\n IERC20 public immutable dai;\n ITokenStorage public tokenStorage;\n\n address public multiRewards; // Can trigger dividend distribution.\n address public marketingWallet;\n address public uniswapV2Pair;\n\n uint256 public treasuryFeeBPS = 700;\n uint256 public liquidityFeeBPS = 200;\n uint256 public dividendFeeBPS = 300;\n uint256 public totalFeeBPS = 1200;\n uint256 public swapTokensAtAmount = 100000 * (10**18);\n uint256 public lastSwapTime;\n uint256 public maxTxBPS = 49;\n uint256 public maxWalletBPS = 200;\n\n bool public isOpen = false;\n bool public swapAllToken = true;\n bool public swapEnabled = true;\n bool public taxEnabled = true;\n bool public compoundingEnabled = true;\n\n mapping(address => bool) public automatedMarketMakerPairs;\n\n uint256 private _maxTxAmount;\n uint256 private _maxWallet;\n uint256 private _totalSupply;\n\n bool private swapping;\n\n mapping(address => uint256) private _balances;\n mapping(address => mapping(address => uint256)) private _allowances;\n mapping(address => bool) private _isExcludedFromFees;\n mapping(address => bool) private _whiteList;\n mapping(address => bool) private _isExcludedFromMaxTx;\n mapping(address => bool) private _isExcludedFromMaxWallet;\n\n constructor(\n address _dai,\n address _uniswapRouter,\n address _marketingWallet,\n address[] memory whitelistAddress\n ) {\n require(_dai != address(0), \"DAI address zero\");\n require(_uniswapRouter != address(0), \"Uniswap router address zero\");\n require(\n _marketingWallet != address(0),\n \"Marketing wallet address zero\"\n );\n\n dai = IERC20(_dai);\n marketingWallet = _marketingWallet;\n includeToWhiteList(whitelistAddress);\n\n uniswapV2Router = IUniswapV2Router02(_uniswapRouter);\n uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(\n address(this),\n _dai\n );\n\n dividendTracker = new DividendTracker(\n _dai,\n address(this),\n address(uniswapV2Router)\n );\n\n _setAutomatedMarketMakerPair(uniswapV2Pair, true);\n\n dividendTracker.excludeFromDividends(address(dividendTracker), true);\n dividendTracker.excludeFromDividends(address(this), true);\n dividendTracker.excludeFromDividends(owner(), true);\n dividendTracker.excludeFromDividends(address(uniswapV2Router), true);\n dividendTracker.excludeFromDividends(address(DEAD), true);\n\n excludeFromFees(owner(), true);\n excludeFromFees(address(this), true);\n excludeFromFees(address(dividendTracker), true);\n\n excludeFromMaxTx(owner(), true);\n excludeFromMaxTx(address(this), true);\n excludeFromMaxTx(address(dividendTracker), true);\n\n excludeFromMaxWallet(owner(), true);\n excludeFromMaxWallet(address(this), true);\n excludeFromMaxWallet(address(dividendTracker), true);\n\n _mint(owner(), 1000000000 * (10**18));\n\n // Calcualte initial values, update later in setters.\n _maxTxAmount = (totalSupply() * maxTxBPS) / 10000;\n _maxWallet = (totalSupply() * maxWalletBPS) / 10000;\n }\n\n /* ============ External View Functions ============ */\n\n function name() external view returns (string memory) {\n return _name;\n }\n\n function symbol() external view returns (string memory) {\n return _symbol;\n }\n\n function decimals() external view returns (uint8) {\n return 18;\n }\n\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n function balanceOf(address account)\n public\n view\n virtual\n override\n returns (uint256)\n {\n return _balances[account];\n }\n\n function allowance(address owner, address spender)\n external\n view\n virtual\n override\n returns (uint256)\n {\n return _allowances[owner][spender];\n }\n\n function approve(address spender, uint256 amount)\n external\n virtual\n override\n returns (bool)\n {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n function withdrawableDividendOf(address account)\n external\n view\n returns (uint256)\n {\n return dividendTracker.withdrawableDividendOf(account);\n }\n\n function isExcludedFromDividends(address account)\n external\n view\n returns (bool)\n {\n return dividendTracker.isExcludedFromDividends(account);\n }\n\n function isExcludedFromFees(address account) external view returns (bool) {\n return _isExcludedFromFees[account];\n }\n\n function isExcludedFromMaxTx(address account) external view returns (bool) {\n return _isExcludedFromMaxTx[account];\n }\n\n function isExcludedFromMaxWallet(address account)\n external\n view\n returns (bool)\n {\n return _isExcludedFromMaxWallet[account];\n }\n\n /* ============ External Functions ============ */\n\n function increaseAllowance(address spender, uint256 addedValue)\n external\n returns (bool)\n {\n _approve(\n _msgSender(),\n spender,\n _allowances[_msgSender()][spender] + addedValue\n );\n return true;\n }\n\n function decreaseAllowance(address spender, uint256 subtractedValue)\n external\n returns (bool)\n {\n uint256 currentAllowance = _allowances[_msgSender()][spender];\n require(\n currentAllowance >= subtractedValue,\n \"Digits: decreased allowance < 0\"\n );\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n return true;\n }\n\n function triggerDividendDistribution() external {\n require(msg.sender == multiRewards, \"Only callable by MultiRewards\");\n\n uint256 contractTokenBalance = balanceOf(address(tokenStorage));\n\n uint256 contractDaiBalance = dai.balanceOf(address(tokenStorage));\n\n bool canSwap = contractTokenBalance >= swapTokensAtAmount;\n\n if (\n swapEnabled && // True\n canSwap && // true\n !swapping // swapping=false !false true\n ) {\n swapping = true;\n\n if (!swapAllToken) {\n contractTokenBalance = swapTokensAtAmount;\n }\n _executeSwap(contractTokenBalance, contractDaiBalance);\n\n lastSwapTime = block.timestamp;\n swapping = false;\n }\n }\n\n function transfer(address recipient, uint256 amount)\n external\n virtual\n override\n returns (bool)\n {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) external virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n uint256 currentAllowance = _allowances[sender][_msgSender()];\n require(currentAllowance >= amount, \"Digits: tx amount > allowance\");\n _approve(sender, _msgSender(), currentAllowance - amount);\n return true;\n }\n\n function claim() external {\n bool result = dividendTracker.processAccount(_msgSender());\n\n require(result, \"Digits: claim failed\");\n }\n\n function compound() external {\n require(compoundingEnabled, \"Digits: compounding not enabled\");\n bool result = dividendTracker.compoundAccount(_msgSender());\n\n require(result, \"Digits: compounding failed\");\n }\n\n /* ============ Internal/Private Functions ============ */\n\n function _transfer(\n address sender,\n address recipient,\n uint256 amount\n ) internal {\n require(\n isOpen ||\n sender == owner() ||\n recipient == owner() ||\n _whiteList[sender] ||\n _whiteList[recipient],\n \"Not Open\"\n );\n\n require(sender != address(0), \"Digits: transfer from 0 address\");\n require(recipient != address(0), \"Digits: transfer to 0 address\");\n require(\n amount <= _maxTxAmount || _isExcludedFromMaxTx[sender],\n \"TX Limit Exceeded\"\n );\n\n if (\n sender != owner() &&\n recipient != address(this) &&\n recipient != address(DEAD) &&\n recipient != uniswapV2Pair\n ) {\n uint256 currentBalance = balanceOf(recipient);\n require(\n _isExcludedFromMaxWallet[recipient] ||\n (currentBalance + amount <= _maxWallet)\n );\n }\n\n uint256 senderBalance = _balances[sender];\n require(senderBalance >= amount, \"Digits: transfer exceeds balance\");\n\n uint256 contractTokenBalance = balanceOf(address(tokenStorage));\n uint256 contractDaiBalance = dai.balanceOf(address(tokenStorage));\n\n bool canSwap = contractTokenBalance >= swapTokensAtAmount;\n\n if (\n swapEnabled && // True\n canSwap && // true\n !swapping && // swapping=false !false true\n !automatedMarketMakerPairs[sender] && // no swap on remove liquidity step 1 or DEX buy\n sender != address(uniswapV2Router) && // no swap on remove liquidity step 2\n sender != owner() &&\n recipient != owner()\n ) {\n swapping = true;\n\n if (!swapAllToken) {\n contractTokenBalance = swapTokensAtAmount;\n }\n _executeSwap(contractTokenBalance, contractDaiBalance);\n\n lastSwapTime = block.timestamp;\n swapping = false;\n }\n\n bool takeFee = false;\n\n if (\n sender == address(uniswapV2Pair) ||\n recipient == address(uniswapV2Pair)\n ) {\n takeFee = true;\n }\n\n if (_isExcludedFromFees[sender] || _isExcludedFromFees[recipient]) {\n takeFee = false;\n }\n\n if (swapping || !taxEnabled) {\n takeFee = false;\n }\n\n if (takeFee) {\n uint256 fees = (amount * totalFeeBPS) / 10000;\n amount -= fees;\n _executeTransfer(sender, address(tokenStorage), fees);\n }\n\n _executeTransfer(sender, recipient, amount);\n\n dividendTracker.setBalance(sender, balanceOf(sender));\n dividendTracker.setBalance(recipient, balanceOf(recipient));\n }\n\n function _executeTransfer(\n address sender,\n address recipient,\n uint256 amount\n ) private {\n uint256 senderBalance = _balances[sender];\n require(senderBalance >= amount, \"Digits: tx amount > balance\");\n _balances[sender] = senderBalance - amount;\n _balances[recipient] += amount;\n emit Transfer(sender, recipient, amount);\n }\n\n function _approve(\n address owner,\n address spender,\n uint256 amount\n ) private {\n require(owner != address(0), \"Digits: approve from 0 address\");\n require(spender != address(0), \"Digits: approve to 0 address\");\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n function _mint(address account, uint256 amount) private {\n require(account != address(0), \"Digits: mint to the zero address\");\n _totalSupply += amount;\n _balances[account] += amount;\n emit Transfer(address(0), account, amount);\n }\n\n function includeToWhiteList(address[] memory _users) private {\n for (uint8 i = 0; i < _users.length; i++) {\n _whiteList[_users[i]] = true;\n }\n }\n\n function _executeSwap(uint256 tokens, uint256 dais) private {\n if (tokens == 0) {\n return;\n }\n\n uint256 swapTokensMarketing = 0;\n if (address(marketingWallet) != address(0) && totalFeeBPS > 0) {\n swapTokensMarketing = (tokens * treasuryFeeBPS) / totalFeeBPS;\n }\n\n uint256 swapTokensDividends = 0;\n if (dividendTracker.totalSupply() > 0 && totalFeeBPS > 0) {\n swapTokensDividends = (tokens * dividendFeeBPS) / totalFeeBPS;\n }\n\n uint256 tokensForLiquidity = tokens -\n swapTokensMarketing -\n swapTokensDividends;\n uint256 swapTokensLiquidity = tokensForLiquidity / 2;\n uint256 addTokensLiquidity = tokensForLiquidity - swapTokensLiquidity;\n uint256 swapTokensTotal = swapTokensMarketing +\n swapTokensDividends +\n swapTokensLiquidity;\n\n uint256 initDaiBal = dai.balanceOf(address(tokenStorage));\n tokenStorage.swapTokensForDai(swapTokensTotal);\n uint256 daiSwapped = (dai.balanceOf(address(tokenStorage)) -\n initDaiBal) + dais;\n\n uint256 daiMarketing = (daiSwapped * swapTokensMarketing) /\n swapTokensTotal;\n uint256 daiDividends = (daiSwapped * swapTokensDividends) /\n swapTokensTotal;\n uint256 daiLiquidity = daiSwapped - daiMarketing - daiDividends;\n\n if (daiMarketing > 0) {\n tokenStorage.transferDai(marketingWallet, daiMarketing);\n }\n\n tokenStorage.addLiquidity(addTokensLiquidity, daiLiquidity);\n emit SwapAndAddLiquidity(\n swapTokensLiquidity,\n daiLiquidity,\n addTokensLiquidity\n );\n\n if (daiDividends > 0) {\n tokenStorage.distributeDividends(swapTokensDividends, daiDividends);\n }\n }\n\n function _setAutomatedMarketMakerPair(address pair, bool value) private {\n require(\n automatedMarketMakerPairs[pair] != value,\n \"Digits: AMM pair is same value\"\n );\n automatedMarketMakerPairs[pair] = value;\n if (value) {\n dividendTracker.excludeFromDividends(pair, true);\n }\n emit SetAutomatedMarketMakerPair(pair, value);\n }\n\n /* ============ External Owner Functions ============ */\n\n function setMultiRewardsAddress(address _multiRewards) external onlyOwner {\n require(_multiRewards != address(0), \"Cannot set address zero\");\n multiRewards = _multiRewards;\n }\n\n function setTokenStorage(address _tokenStorage) external onlyOwner {\n require(\n address(tokenStorage) == address(0),\n \"Digits: tokenStorage already set\"\n );\n\n tokenStorage = ITokenStorage(_tokenStorage);\n dividendTracker.excludeFromDividends(address(tokenStorage), true);\n excludeFromFees(address(tokenStorage), true);\n excludeFromMaxTx(address(tokenStorage), true);\n excludeFromMaxWallet(address(tokenStorage), true);\n emit SetTokenStorage(_tokenStorage);\n }\n\n function setWallet(address _marketingWallet, address _liquidityWallet)\n external\n onlyOwner\n {\n require(_marketingWallet != address(0), \"Digits: zero!\");\n require(_liquidityWallet != address(0), \"Digits: zero!\");\n\n marketingWallet = _marketingWallet;\n tokenStorage.setLiquidityWallet(_liquidityWallet);\n }\n\n function setAutomatedMarketMakerPair(address pair, bool value)\n external\n onlyOwner\n {\n require(pair != uniswapV2Pair, \"Digits: LP can not be removed\");\n _setAutomatedMarketMakerPair(pair, value);\n }\n\n function setFee(\n uint256 _treasuryFee,\n uint256 _liquidityFee,\n uint256 _dividendFee\n ) external onlyOwner {\n require(\n _treasuryFee <= 800 && _liquidityFee <= 800 && _dividendFee <= 800,\n \"Each fee must be below 8%\"\n );\n\n treasuryFeeBPS = _treasuryFee;\n liquidityFeeBPS = _liquidityFee;\n dividendFeeBPS = _dividendFee;\n totalFeeBPS = _treasuryFee + _liquidityFee + _dividendFee;\n\n emit SetFee(_treasuryFee, _liquidityFee, _dividendFee);\n }\n\n function setSwapEnabled(bool _enabled) external onlyOwner {\n swapEnabled = _enabled;\n emit SwapEnabled(_enabled);\n }\n\n function setTaxEnabled(bool _enabled) external onlyOwner {\n taxEnabled = _enabled;\n emit TaxEnabled(_enabled);\n }\n\n function setCompoundingEnabled(bool _enabled) external onlyOwner {\n compoundingEnabled = _enabled;\n\n emit CompoundingEnabled(_enabled);\n }\n\n function setMaxTxBPS(uint256 bps) external onlyOwner {\n require(bps >= 49 && bps <= 10000, \"BPS only between 49 and 10000\");\n maxTxBPS = bps;\n _maxTxAmount = (totalSupply() * maxTxBPS) / 10000;\n emit SetMaxTxBPS(bps);\n }\n\n function setMaxWalletBPS(uint256 bps) external onlyOwner {\n require(bps >= 100 && bps <= 10000, \"BPS only between 100 and 10000\");\n maxWalletBPS = bps;\n _maxWallet = (totalSupply() * maxWalletBPS) / 10000;\n emit SetMaxWalletBPS(bps);\n }\n\n function openTrading() external onlyOwner {\n isOpen = true;\n }\n\n function updateDividendSettings(\n bool _swapEnabled,\n uint256 _swapTokensAtAmount,\n bool _swapAllToken\n ) external onlyOwner {\n swapEnabled = _swapEnabled;\n swapTokensAtAmount = _swapTokensAtAmount;\n swapAllToken = _swapAllToken;\n\n emit UpdateDividendSettings(\n _swapEnabled,\n _swapTokensAtAmount,\n _swapAllToken\n );\n }\n\n function excludeFromFees(address account, bool excluded) public onlyOwner {\n require(\n _isExcludedFromFees[account] != excluded,\n \"Digits: same state value\"\n );\n _isExcludedFromFees[account] = excluded;\n emit ExcludeFromFees(account, excluded);\n }\n\n function excludeFromDividends(address account, bool excluded)\n external\n onlyOwner\n {\n dividendTracker.excludeFromDividends(account, excluded);\n }\n\n function excludeFromMaxTx(address account, bool excluded) public onlyOwner {\n _isExcludedFromMaxTx[account] = excluded;\n\n emit ExcludeFromMaxTx(account, excluded);\n }\n\n function excludeFromMaxWallet(address account, bool excluded)\n public\n onlyOwner\n {\n _isExcludedFromMaxWallet[account] = excluded;\n\n emit ExcludeFromMaxWallet(account, excluded);\n }\n\n function rescueToken(address _token, uint256 _amount) external onlyOwner {\n IERC20(_token).safeTransfer(msg.sender, _amount);\n }\n\n function rescueETH(uint256 _amount) external onlyOwner {\n payable(msg.sender).transfer(_amount);\n }\n}\n" }, "contracts/DividendTracker.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.10;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\n\nimport \"./interfaces/IDividendTracker.sol\";\n\ncontract DividendTracker is Ownable, IERC20, IDividendTracker {\n using SafeERC20 for IERC20;\n\n /* ============ State ============ */\n\n string private constant _name = \"Digits_DividendTracker\";\n string private constant _symbol = \"Digits_DividendTracker\";\n uint256 private constant minTokenBalanceForDividends = 10000 * (10**18);\n uint256 private constant magnitude = 2**128;\n\n address public immutable dai;\n address public immutable tokenAddress;\n IUniswapV2Router02 public immutable uniswapV2Router;\n\n uint256 public totalDividendsDistributed;\n uint256 public totalDividendsWithdrawn;\n\n mapping(address => bool) public excludedFromDividends;\n\n uint256 private magnifiedDividendPerShare;\n uint256 private _totalSupply;\n\n mapping(address => uint256) private _balances;\n mapping(address => int256) private magnifiedDividendCorrections;\n mapping(address => uint256) private withdrawnDividends;\n mapping(address => uint256) private lastClaimTimes;\n\n constructor(\n address _dai,\n address _tokenAddress,\n address _uniswapRouter\n ) {\n require(_dai != address(0), \"DAI address zero\");\n require(_tokenAddress != address(0), \"Token address zero\");\n require(_uniswapRouter != address(0), \"Uniswap router address zero\");\n\n dai = _dai;\n tokenAddress = _tokenAddress;\n uniswapV2Router = IUniswapV2Router02(_uniswapRouter);\n }\n\n /* ============ External Functions ============ */\n\n function distributeDividends(uint256 daiDividends) external {\n require(_totalSupply > 0, \"dividends unavailable yet\");\n if (daiDividends > 0) {\n IERC20(dai).safeTransferFrom(\n msg.sender,\n address(this),\n daiDividends\n );\n magnifiedDividendPerShare =\n magnifiedDividendPerShare +\n ((daiDividends * magnitude) / _totalSupply);\n emit DividendsDistributed(msg.sender, daiDividends);\n totalDividendsDistributed += daiDividends;\n }\n }\n\n /* ============ External Owner Functions ============ */\n\n function setBalance(address account, uint256 newBalance)\n external\n onlyOwner\n {\n if (excludedFromDividends[account]) {\n return;\n }\n if (newBalance >= minTokenBalanceForDividends) {\n _setBalance(account, newBalance);\n } else {\n _setBalance(account, 0);\n }\n }\n\n function excludeFromDividends(address account, bool excluded)\n external\n onlyOwner\n {\n require(\n excludedFromDividends[account] != excluded,\n \"Digits_DividendTracker: account already set to requested state\"\n );\n excludedFromDividends[account] = excluded;\n if (excluded) {\n _setBalance(account, 0);\n } else {\n uint256 newBalance = IERC20(tokenAddress).balanceOf(account);\n if (newBalance >= minTokenBalanceForDividends) {\n _setBalance(account, newBalance);\n } else {\n _setBalance(account, 0);\n }\n }\n emit ExcludeFromDividends(account, excluded);\n }\n\n function processAccount(address account) external onlyOwner returns (bool) {\n uint256 amount = _withdrawDividendOfUser(account);\n if (amount > 0) {\n lastClaimTimes[account] = block.timestamp;\n emit Claim(account, amount);\n return true;\n }\n return false;\n }\n\n function compoundAccount(address account)\n external\n onlyOwner\n returns (bool)\n {\n (uint256 amount, uint256 tokens) = _compoundDividendOfUser(account);\n if (amount > 0) {\n lastClaimTimes[account] = block.timestamp;\n emit Compound(account, amount, tokens);\n return true;\n }\n return false;\n }\n\n /* ============ External View Functions ============ */\n\n function isExcludedFromDividends(address account)\n external\n view\n returns (bool)\n {\n return excludedFromDividends[account];\n }\n\n function withdrawableDividendOf(address account)\n public\n view\n returns (uint256)\n {\n return accumulativeDividendOf(account) - withdrawnDividends[account];\n }\n\n function withdrawnDividendOf(address account)\n public\n view\n returns (uint256)\n {\n return withdrawnDividends[account];\n }\n\n function accumulativeDividendOf(address account)\n public\n view\n returns (uint256)\n {\n int256 a = int256(magnifiedDividendPerShare * balanceOf(account));\n int256 b = magnifiedDividendCorrections[account]; // this is an explicit int256 (signed)\n return uint256(a + b) / magnitude;\n }\n\n function getAccountInfo(address account)\n external\n view\n returns (\n address,\n uint256,\n uint256,\n uint256,\n uint256\n )\n {\n uint256 withdrawableDividends = withdrawableDividendOf(account);\n uint256 totalDividends = accumulativeDividendOf(account);\n uint256 lastClaimTime = lastClaimTimes[account];\n uint256 withdrawn = withdrawnDividendOf(account);\n return (\n account,\n withdrawableDividends,\n totalDividends,\n lastClaimTime,\n withdrawn\n );\n }\n\n function getLastClaimTime(address account) external view returns (uint256) {\n return lastClaimTimes[account];\n }\n\n function name() external view returns (string memory) {\n return _name;\n }\n\n function symbol() external view returns (string memory) {\n return _symbol;\n }\n\n function decimals() external view returns (uint8) {\n return 18;\n }\n\n function totalSupply()\n public\n view\n override(IDividendTracker, IERC20)\n returns (uint256)\n {\n return _totalSupply;\n }\n\n function balanceOf(address account) public view override returns (uint256) {\n return _balances[account];\n }\n\n function transfer(address, uint256) public pure override returns (bool) {\n revert(\"Digits_DividendTracker: method not implemented\");\n }\n\n function allowance(address, address)\n public\n pure\n override\n returns (uint256)\n {\n revert(\"Digits_DividendTracker: method not implemented\");\n }\n\n function approve(address, uint256) public pure override returns (bool) {\n revert(\"Digits_DividendTracker: method not implemented\");\n }\n\n function transferFrom(\n address,\n address,\n uint256\n ) public pure override returns (bool) {\n revert(\"Digits_DividendTracker: method not implemented\");\n }\n\n /* ============ Internal/Private Functions ============ */\n\n function _setBalance(address account, uint256 newBalance) internal {\n uint256 currentBalance = _balances[account];\n if (newBalance > currentBalance) {\n uint256 addAmount = newBalance - currentBalance;\n _mint(account, addAmount);\n } else if (newBalance < currentBalance) {\n uint256 subAmount = currentBalance - newBalance;\n _burn(account, subAmount);\n }\n }\n\n function _mint(address account, uint256 amount) private {\n require(\n account != address(0),\n \"Digits_DividendTracker: mint to the zero address\"\n );\n _totalSupply += amount;\n _balances[account] += amount;\n emit Transfer(address(0), account, amount);\n magnifiedDividendCorrections[account] =\n magnifiedDividendCorrections[account] -\n int256(magnifiedDividendPerShare * amount);\n }\n\n function _burn(address account, uint256 amount) private {\n require(\n account != address(0),\n \"Digits_DividendTracker: burn from the zero address\"\n );\n uint256 accountBalance = _balances[account];\n require(\n accountBalance >= amount,\n \"Digits_DividendTracker: burn amount exceeds balance\"\n );\n _balances[account] = accountBalance - amount;\n _totalSupply -= amount;\n emit Transfer(account, address(0), amount);\n magnifiedDividendCorrections[account] =\n magnifiedDividendCorrections[account] +\n int256(magnifiedDividendPerShare * amount);\n }\n\n function _withdrawDividendOfUser(address account)\n private\n returns (uint256)\n {\n uint256 _withdrawableDividend = withdrawableDividendOf(account);\n if (_withdrawableDividend > 0) {\n withdrawnDividends[account] += _withdrawableDividend;\n totalDividendsWithdrawn += _withdrawableDividend;\n emit DividendWithdrawn(account, _withdrawableDividend);\n\n IERC20(dai).safeTransfer(account, _withdrawableDividend);\n\n return _withdrawableDividend;\n }\n return 0;\n }\n\n function _compoundDividendOfUser(address account)\n private\n returns (uint256, uint256)\n {\n uint256 _withdrawableDividend = withdrawableDividendOf(account);\n if (_withdrawableDividend > 0) {\n withdrawnDividends[account] += _withdrawableDividend;\n totalDividendsWithdrawn += _withdrawableDividend;\n emit DividendWithdrawn(account, _withdrawableDividend);\n\n address[] memory path = new address[](2);\n path[0] = dai;\n path[1] = address(tokenAddress);\n\n bool success = false;\n uint256 tokens = 0;\n\n uint256 initTokenBal = IERC20(tokenAddress).balanceOf(account);\n IERC20(dai).approve(\n address(uniswapV2Router),\n _withdrawableDividend\n );\n try\n uniswapV2Router\n .swapExactTokensForTokensSupportingFeeOnTransferTokens(\n _withdrawableDividend,\n 0,\n path,\n address(account),\n block.timestamp\n )\n {\n success = true;\n tokens = IERC20(tokenAddress).balanceOf(account) - initTokenBal;\n } catch Error(\n string memory /*err*/\n ) {\n success = false;\n }\n\n if (!success) {\n withdrawnDividends[account] -= _withdrawableDividend;\n totalDividendsWithdrawn -= _withdrawableDividend;\n return (0, 0);\n }\n\n return (_withdrawableDividend, tokens);\n }\n return (0, 0);\n }\n}\n" }, "contracts/interfaces/IDigits.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.10;\n\ninterface IDigits {\n event SwapAndAddLiquidity(\n uint256 tokensSwapped,\n uint256 daiReceived,\n uint256 tokensIntoLiquidity\n );\n event ExcludeFromFees(address indexed account, bool isExcluded);\n event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);\n event SetFee(\n uint256 _treasuryFee,\n uint256 _liquidityFee,\n uint256 _dividendFee\n );\n event SwapEnabled(bool enabled);\n event TaxEnabled(bool enabled);\n event CompoundingEnabled(bool enabled);\n event SetTokenStorage(address _tokenStorage);\n event UpdateDividendSettings(\n bool _swapEnabled,\n uint256 _swapTokensAtAmount,\n bool _swapAllToken\n );\n event SetMaxTxBPS(uint256 bps);\n event ExcludeFromMaxTx(address account, bool excluded);\n event SetMaxWalletBPS(uint256 bps);\n event ExcludeFromMaxWallet(address account, bool excluded);\n\n function claim() external;\n\n function withdrawableDividendOf(address account)\n external\n view\n returns (uint256);\n\n function triggerDividendDistribution() external;\n}\n" }, "contracts/interfaces/IDividendTracker.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.10;\n\ninterface IDividendTracker {\n event DividendsDistributed(address indexed from, uint256 weiAmount);\n event DividendWithdrawn(address indexed to, uint256 weiAmount);\n event ExcludeFromDividends(address indexed account, bool excluded);\n event Claim(address indexed account, uint256 amount);\n event Compound(address indexed account, uint256 amount, uint256 tokens);\n\n function distributeDividends(uint256 daiDividends) external;\n\n function excludeFromDividends(address account, bool excluded) external;\n\n function setBalance(address account, uint256 newBalance) external;\n\n function totalSupply() external view returns (uint256);\n\n function isExcludedFromDividends(address account)\n external\n view\n returns (bool);\n\n function processAccount(address account) external returns (bool);\n\n function compoundAccount(address account) external returns (bool);\n\n function withdrawableDividendOf(address account)\n external\n view\n returns (uint256);\n\n function withdrawnDividendOf(address account)\n external\n view\n returns (uint256);\n\n function accumulativeDividendOf(address account)\n external\n view\n returns (uint256);\n\n function getAccountInfo(address account)\n external\n view\n returns (\n address,\n uint256,\n uint256,\n uint256,\n uint256\n );\n\n function getLastClaimTime(address account) external view returns (uint256);\n}\n" }, "contracts/interfaces/ITokenStorage.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.10;\n\ninterface ITokenStorage {\n event SendDividends(uint256 tokensSwapped, uint256 amount);\n\n function swapTokensForDai(uint256 tokens) external;\n\n function transferDai(address to, uint256 amount) external;\n\n function addLiquidity(uint256 tokens, uint256 dais) external;\n\n function distributeDividends(\n uint256 swapTokensDividends,\n uint256 daiDividends\n ) external;\n\n function setLiquidityWallet(address _liquidityWallet) external;\n}\n" } }, "settings": { "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} } }}

Digits DAO

Start building on QuickNode

Source code: