{{ "language": "Solidity", "sources": { "contracts/Boardroom.sol": { "content": "pragma solidity ^0.6.0;\n//pragma experimental ABIEncoderV2;\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\nimport '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';\n\nimport './lib/Safe112.sol';\nimport './owner/Operator.sol';\nimport './utils/ContractGuard.sol';\nimport './interfaces/IBasisAsset.sol';\n\ncontract Boardroom is ContractGuard, Operator {\n using SafeERC20 for IERC20;\n using Address for address;\n using SafeMath for uint256;\n using Safe112 for uint112;\n\n /* ========== DATA STRUCTURES ========== */\n\n struct Boardseat {\n uint256 appointmentTime;\n uint256 shares;\n }\n\n struct BoardSnapshot {\n uint256 timestamp;\n uint256 rewardReceived;\n uint256 totalShares;\n }\n\n /* ========== STATE VARIABLES ========== */\n\n IERC20 private cash;\n IERC20 private share;\n\n mapping(address => Boardseat) private directors;\n BoardSnapshot[] private boardHistory;\n\n /* ========== CONSTRUCTOR ========== */\n\n constructor(IERC20 _cash, IERC20 _share) public {\n cash = _cash;\n share = _share;\n\n BoardSnapshot memory genesisSnapshot = BoardSnapshot(now, 0, 0);\n boardHistory.push(genesisSnapshot);\n }\n\n /* ========== Modifiers =============== */\n modifier directorExists {\n require(\n directors[msg.sender].shares > 0,\n 'Boardroom: The director does not exist'\n );\n _;\n }\n\n /* ========== VIEW FUNCTIONS ========== */\n\n function totalShare() public view returns (uint256) {\n return boardHistory[boardHistory.length.sub(1)].totalShares;\n }\n\n function getShareOf(address director) public view returns (uint256) {\n return directors[director].shares;\n }\n\n function getAppointmentTimeOf(address director)\n public\n view\n returns (uint256)\n {\n return directors[director].appointmentTime;\n }\n\n function getCashEarningsOf(address director) public view returns (uint256) {\n uint256 totalRewards = 0;\n if (getShareOf(director) <= 0) {\n return totalRewards;\n }\n\n for (uint256 i = boardHistory.length; i > 0; i = i.sub(1)) {\n BoardSnapshot memory snapshot = boardHistory[i.sub(1)];\n\n if (snapshot.timestamp < getAppointmentTimeOf(director)) {\n break;\n }\n\n uint256 snapshotRewards = snapshot\n .rewardReceived\n .mul(getShareOf(director))\n .div(snapshot.totalShares);\n totalRewards = totalRewards.add(snapshotRewards);\n }\n return totalRewards;\n }\n\n /* ========== MUTATIVE FUNCTIONS ========== */\n\n function claimDividends() public onlyOneBlock {\n uint256 totalRewards = getCashEarningsOf(msg.sender);\n directors[msg.sender].appointmentTime = now;\n\n if (totalRewards > 0) {\n cash.safeTransfer(msg.sender, totalRewards);\n emit RewardPaid(msg.sender, totalRewards);\n }\n }\n\n function stake(uint256 amount) external {\n require(amount > 0, 'Boardroom: Cannot stake 0');\n\n // Claim all outstanding dividends before making state changes\n claimDividends();\n\n // Update director's boardseat\n Boardseat memory director = directors[msg.sender];\n director.shares = director.shares.add(amount);\n directors[msg.sender] = director;\n\n // Update latest snapshot\n uint256 snapshotIndex = boardHistory.length.sub(1);\n boardHistory[snapshotIndex].totalShares = totalShare().add(amount);\n\n share.safeTransferFrom(msg.sender, address(this), amount);\n emit Staked(msg.sender, amount);\n }\n\n function withdraw(uint256 amount) public directorExists {\n require(amount > 0, 'Boardroom: Cannot withdraw 0');\n\n // Claim all outstanding dividends before making state changes\n claimDividends();\n\n // Update director's boardseat\n uint256 directorShare = getShareOf(msg.sender);\n require(\n directorShare >= amount,\n 'Boardroom: withdraw request greater than staked amount'\n );\n directors[msg.sender].shares = directorShare.sub(amount);\n\n // Update latest snapshot\n uint256 snapshotIndex = boardHistory.length.sub(1);\n boardHistory[snapshotIndex].totalShares = totalShare().sub(amount);\n\n share.safeTransfer(msg.sender, amount);\n emit Withdrawn(msg.sender, amount);\n }\n\n function exit() external {\n withdraw(getShareOf(msg.sender));\n }\n\n function allocateSeigniorage(uint256 amount)\n external\n onlyOneBlock\n onlyOperator\n {\n require(amount > 0, 'Boardroom: Cannot allocate 0');\n\n // Create & add new snapshot\n BoardSnapshot memory newSnapshot = BoardSnapshot({\n timestamp: now,\n rewardReceived: amount,\n totalShares: totalShare()\n });\n boardHistory.push(newSnapshot);\n\n cash.safeTransferFrom(msg.sender, address(this), amount);\n\n emit RewardAdded(msg.sender, amount);\n }\n\n /* ========== EVENTS ========== */\n\n event Staked(address indexed user, uint256 amount);\n event Withdrawn(address indexed user, uint256 amount);\n event RewardPaid(address indexed user, uint256 reward);\n event RewardAdded(address indexed user, uint256 reward);\n}\n" }, "@openzeppelin/contracts/token/ERC20/IERC20.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\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 `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, 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 `sender` to `recipient` 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(address sender, address recipient, uint256 amount) external returns (bool);\n\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" }, "@openzeppelin/contracts/token/ERC20/SafeERC20.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\nimport \"./IERC20.sol\";\nimport \"../../math/SafeMath.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 SafeMath for uint256;\n using Address for address;\n\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) 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(IERC20 token, address spender, uint256 value) 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 // solhint-disable-next-line max-line-length\n require((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(IERC20 token, address spender, uint256 value) internal {\n uint256 newAllowance = token.allowance(address(this), spender).add(value);\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n uint256 newAllowance = token.allowance(address(this), spender).sub(value, \"SafeERC20: decreased allowance below zero\");\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\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) { // Return data is optional\n // solhint-disable-next-line max-line-length\n require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n }\n}\n" }, "contracts/lib/Safe112.sol": { "content": "pragma solidity ^0.6.0;\n\nlibrary Safe112 {\n function add(uint112 a, uint112 b) internal pure returns (uint256) {\n uint256 c = a + b;\n require(c >= a, 'Safe112: addition overflow');\n\n return c;\n }\n\n function sub(uint112 a, uint112 b) internal pure returns (uint256) {\n return sub(a, b, 'Safe112: subtraction overflow');\n }\n\n function sub(\n uint112 a,\n uint112 b,\n string memory errorMessage\n ) internal pure returns (uint112) {\n require(b <= a, errorMessage);\n uint112 c = a - b;\n\n return c;\n }\n\n function mul(uint112 a, uint112 b) internal pure returns (uint256) {\n if (a == 0) {\n return 0;\n }\n\n uint256 c = a * b;\n require(c / a == b, 'Safe112: multiplication overflow');\n\n return c;\n }\n\n function div(uint112 a, uint112 b) internal pure returns (uint256) {\n return div(a, b, 'Safe112: division by zero');\n }\n\n function div(\n uint112 a,\n uint112 b,\n string memory errorMessage\n ) internal pure returns (uint112) {\n // Solidity only automatically asserts when dividing by 0\n require(b > 0, errorMessage);\n uint112 c = a / b;\n\n return c;\n }\n\n function mod(uint112 a, uint112 b) internal pure returns (uint256) {\n return mod(a, b, 'Safe112: modulo by zero');\n }\n\n function mod(\n uint112 a,\n uint112 b,\n string memory errorMessage\n ) internal pure returns (uint112) {\n require(b != 0, errorMessage);\n return a % b;\n }\n}\n" }, "contracts/owner/Operator.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '@openzeppelin/contracts/GSN/Context.sol';\nimport '@openzeppelin/contracts/access/Ownable.sol';\n\ncontract Operator is Context, Ownable {\n address private _operator;\n\n event OperatorTransferred(\n address indexed previousOperator,\n address indexed newOperator\n );\n\n constructor() internal {\n _operator = _msgSender();\n emit OperatorTransferred(address(0), _operator);\n }\n\n function operator() public view returns (address) {\n return _operator;\n }\n\n modifier onlyOperator() {\n require(\n _operator == msg.sender,\n 'operator: caller is not the operator'\n );\n _;\n }\n\n function isOperator() public view returns (bool) {\n return _msgSender() == _operator;\n }\n\n function transferOperator(address newOperator_) public onlyOwner {\n _transferOperator(newOperator_);\n }\n\n function _transferOperator(address newOperator_) internal {\n require(\n newOperator_ != address(0),\n 'operator: zero address given for new operator'\n );\n emit OperatorTransferred(address(0), newOperator_);\n _operator = newOperator_;\n }\n}\n" }, "contracts/utils/ContractGuard.sol": { "content": "pragma solidity ^0.6.12;\n\ncontract ContractGuard {\n mapping(uint256 => mapping(address => bool)) private _status;\n\n modifier onlyOneBlock() {\n require(\n !_status[block.number][tx.origin],\n 'ContractGuard: one block, one function'\n );\n\n _;\n\n _status[block.number][tx.origin] = true;\n }\n}\n" }, "contracts/interfaces/IBasisAsset.sol": { "content": "pragma solidity ^0.6.0;\n\ninterface IBasisAsset {\n function mint(address recipient, uint256 amount) external returns (bool);\n\n function burn(uint256 amount) external;\n\n function burnFrom(address from, uint256 amount) external;\n\n function isOperator() external returns (bool);\n\n function operator() external view returns (address);\n}\n" }, "@openzeppelin/contracts/math/SafeMath.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeMath {\n /**\n * @dev Returns the addition of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `+` operator.\n *\n * Requirements:\n *\n * - Addition cannot overflow.\n */\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\n uint256 c = a + b;\n require(c >= a, \"SafeMath: addition overflow\");\n\n return c;\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n return sub(a, b, \"SafeMath: subtraction overflow\");\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n * overflow (when the result is negative).\n *\n * Counterpart to Solidity's `-` operator.\n *\n * Requirements:\n *\n * - Subtraction cannot overflow.\n */\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n require(b <= a, errorMessage);\n uint256 c = a - b;\n\n return c;\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, reverting on\n * overflow.\n *\n * Counterpart to Solidity's `*` operator.\n *\n * Requirements:\n *\n * - Multiplication cannot overflow.\n */\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) {\n return 0;\n }\n\n uint256 c = a * b;\n require(c / a == b, \"SafeMath: multiplication overflow\");\n\n return c;\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers. Reverts on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\n return div(a, b, \"SafeMath: division by zero\");\n }\n\n /**\n * @dev Returns the integer division of two unsigned integers. Reverts with custom message on\n * division by zero. The result is rounded towards zero.\n *\n * Counterpart to Solidity's `/` operator. Note: this function uses a\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\n * uses an invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n require(b > 0, errorMessage);\n uint256 c = a / b;\n // assert(a == b * c + a % b); // There is no case in which this doesn't hold\n\n return c;\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * Reverts when dividing by zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n return mod(a, b, \"SafeMath: modulo by zero\");\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n * Reverts with custom message when dividing by zero.\n *\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\n * opcode (which leaves remaining gas untouched) while Solidity uses an\n * invalid opcode to revert (consuming all remaining gas).\n *\n * Requirements:\n *\n * - The divisor cannot be zero.\n */\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n require(b != 0, errorMessage);\n return a % b;\n }\n}\n" }, "@openzeppelin/contracts/utils/Address.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.2;\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 function isContract(address account) internal view returns (bool) {\n // This method relies in extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n // solhint-disable-next-line no-inline-assembly\n assembly { size := extcodesize(account) }\n return size > 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 // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\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(address target, bytes memory data, string memory errorMessage) 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(address target, bytes memory data, uint256 value) 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(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n return _functionCallWithValue(target, data, value, errorMessage);\n }\n\n function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {\n require(isContract(target), \"Address: call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);\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\n // solhint-disable-next-line no-inline-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/GSN/Context.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.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 GSN 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 payable) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes memory) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n}\n" }, "@openzeppelin/contracts/access/Ownable.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\nimport \"../GSN/Context.sol\";\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 */\ncontract 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 () internal {\n address msgSender = _msgSender();\n _owner = msgSender;\n emit OwnershipTransferred(address(0), msgSender);\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(_owner == _msgSender(), \"Ownable: caller is not the owner\");\n _;\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 emit OwnershipTransferred(_owner, address(0));\n _owner = 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 emit OwnershipTransferred(_owner, newOwner);\n _owner = newOwner;\n }\n}\n" }, "contracts/test/Tester.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\nimport '../Treasury.sol';\nimport '../Boardroom.sol';\nimport '../owner/Operator.sol';\n\ncontract Tester is Operator {\n Treasury public treasury;\n Boardroom public boardroom;\n\n constructor(address _treasury, address _boardroom) public {\n treasury = Treasury(_treasury);\n boardroom = Boardroom(_boardroom);\n }\n\n event OKOnlyOperator(address caller);\n\n function OnlyOperator() public onlyOperator {\n emit OKOnlyOperator(msg.sender);\n }\n\n function actionTreasury() public {\n treasury.allocateSeigniorage();\n treasury.allocateSeigniorage(); // should revert\n }\n\n function actionBoardroom(address share, uint256 amount) public {\n IERC20(share).approve(address(boardroom), amount);\n boardroom.stake(amount);\n boardroom.withdraw(amount); // should revert\n }\n}\n" }, "contracts/Treasury.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\nimport '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';\nimport '@openzeppelin/contracts/utils/ReentrancyGuard.sol';\n\nimport './lib/Babylonian.sol';\nimport './lib/FixedPoint.sol';\nimport './lib/Safe112.sol';\nimport './owner/Operator.sol';\nimport './utils/ContractGuard.sol';\nimport './interfaces/IBasisAsset.sol';\nimport './interfaces/IOracle.sol';\nimport './interfaces/IBoardroom.sol';\n\n/**\n * @title Basis Cash Treasury contract\n * @notice Monetary policy logic to adjust supplies of basis cash assets\n * @author Summer Smith & Rick Sanchez\n */\ncontract Treasury is ContractGuard, Operator {\n using FixedPoint for *;\n using SafeERC20 for IERC20;\n using Address for address;\n using SafeMath for uint256;\n using Safe112 for uint112;\n\n /* ========= CONSTANT VARIABLES ======== */\n\n uint256 public constant allocationDelay = 1 days;\n\n /* ========== STATE VARIABLES ========== */\n\n address private cash;\n address private bond;\n address private share;\n address private boardroom;\n IOracle private cashOracle;\n\n bool private migrated = false;\n uint256 private seigniorageSaved = 0;\n uint256 public startTime;\n uint256 public cashPriceCeiling;\n uint256 public cashPriceOne;\n uint256 private bondDepletionFloor;\n uint256 private lastAllocated;\n\n /* ========== CONSTRUCTOR ========== */\n\n constructor(\n address _cash,\n address _bond,\n address _share,\n address _cashOracle,\n address _boardroom,\n uint256 _startTime\n ) public {\n cash = _cash;\n bond = _bond;\n share = _share;\n cashOracle = IOracle(_cashOracle);\n boardroom = _boardroom;\n\n startTime = _startTime;\n\n cashPriceOne = 10**18;\n cashPriceCeiling = uint256(105).mul(cashPriceOne).div(10**2);\n\n bondDepletionFloor = uint256(1000).mul(cashPriceOne);\n lastAllocated = now;\n }\n\n /* ========== MODIFIER ========== */\n\n modifier checkMigration {\n require(!migrated, 'Treasury: this contract has been migrated');\n _;\n }\n\n modifier checkOperator {\n require(\n IBasisAsset(cash).operator() == address(this),\n 'Treasury: this contract is not the operator of the basis cash contract'\n );\n require(\n IBasisAsset(bond).operator() == address(this),\n 'Treasury: this contract is not the operator of the basis bond contract'\n );\n require(\n Operator(boardroom).operator() == address(this),\n 'Treasury: this contract is not the operator of the boardroom contract'\n );\n _;\n }\n\n /* ========== VIEW FUNCTIONS ========== */\n\n function getCashPrice() public view returns (uint256 cashPrice) {\n try cashOracle.consult(cash, 1e18) returns (uint256 price) {\n return price;\n } catch {\n revert('Treasury: failed to consult cash price from the oracle');\n }\n }\n\n /* ========== GOVERNANCE ========== */\n\n function migrate(address target) public onlyOperator checkMigration {\n require(block.timestamp >= startTime, 'Treasury: not started yet');\n\n // cash\n Operator(cash).transferOperator(target);\n Operator(cash).transferOwnership(target);\n IERC20(cash).transfer(target, IERC20(cash).balanceOf(address(this)));\n\n // bond\n Operator(bond).transferOperator(target);\n Operator(bond).transferOwnership(target);\n IERC20(bond).transfer(target, IERC20(bond).balanceOf(address(this)));\n\n // share\n Operator(share).transferOperator(target);\n Operator(share).transferOwnership(target);\n IERC20(share).transfer(target, IERC20(share).balanceOf(address(this)));\n\n migrated = true;\n emit Migration(target);\n }\n\n /* ========== MUTABLE FUNCTIONS ========== */\n\n function _getCashPrice() internal returns (uint256 cashPrice) {\n cashPrice = getCashPrice();\n try cashOracle.update() {} catch {\n revert('Treasury: failed to update cash oracle');\n }\n }\n\n function _allocateSeigniorage(uint256 cashPrice)\n internal\n onlyOneBlock\n checkOperator\n checkMigration\n returns (bool, string memory)\n {\n if (now.sub(lastAllocated) < allocationDelay) {\n return (false, 'Treasury: a day has not passed yet');\n }\n if (block.timestamp < startTime) {\n return (false, 'Treasury: not started yet');\n }\n if (cashPrice <= cashPriceCeiling) {\n return (false, 'Treasury: there is no seigniorage to be allocated');\n }\n\n uint256 cashSupply = IERC20(cash).totalSupply();\n uint256 percentage = cashPrice.sub(cashPriceOne);\n uint256 seigniorage = cashSupply.mul(percentage).div(1e18);\n\n if (seigniorageSaved > bondDepletionFloor) {\n IBasisAsset(cash).mint(address(this), seigniorage);\n IERC20(cash).safeApprove(boardroom, seigniorage);\n IBoardroom(boardroom).allocateSeigniorage(seigniorage);\n emit BoardroomFunded(now, seigniorage);\n } else {\n seigniorageSaved = seigniorageSaved.add(seigniorage);\n IBasisAsset(cash).mint(address(this), seigniorage);\n emit TreasuryFunded(now, seigniorage);\n }\n\n lastAllocated = now;\n return (true, 'Treasury: success');\n }\n\n function buyBonds(uint256 amount, uint256 targetPrice) external {\n require(amount > 0, 'Treasury: cannot purchase bonds with zero amount');\n\n uint256 cashPrice = _getCashPrice();\n require(cashPrice == targetPrice, 'Treasury: cash price moved');\n _allocateSeigniorage(cashPrice); // ignore returns\n\n uint256 bondPrice = cashPrice;\n\n IBasisAsset(cash).burnFrom(msg.sender, amount);\n IBasisAsset(bond).mint(msg.sender, amount.mul(1e18).div(bondPrice));\n\n emit BoughtBonds(msg.sender, amount);\n }\n\n function redeemBonds(uint256 amount, uint256 targetPrice) external {\n require(amount > 0, 'Treasury: cannot redeem bonds with zero amount');\n\n uint256 cashPrice = _getCashPrice();\n require(cashPrice == targetPrice, 'Treasury: cash price moved');\n _allocateSeigniorage(cashPrice); // ignore returns\n\n require(\n cashPrice > cashPriceCeiling,\n 'Treasury: bond redemption failed; basis cash remains depegged.'\n );\n\n uint256 treasuryBalance = IERC20(cash).balanceOf(address(this));\n require(\n treasuryBalance >= amount,\n 'Treasury: treasury has no more budget'\n );\n\n if (seigniorageSaved >= amount) {\n seigniorageSaved = seigniorageSaved.sub(amount);\n } else {\n seigniorageSaved = 0;\n }\n\n IBasisAsset(bond).burnFrom(msg.sender, amount);\n IERC20(cash).safeTransfer(msg.sender, amount);\n\n emit RedeemedBonds(msg.sender, amount);\n }\n\n function allocateSeigniorage() external {\n uint256 cashPrice = _getCashPrice();\n (bool result, string memory reason) = _allocateSeigniorage(cashPrice);\n require(result, reason);\n }\n\n event Migration(address indexed target);\n event RedeemedBonds(address indexed from, uint256 amount);\n event BoughtBonds(address indexed from, uint256 amount);\n event TreasuryFunded(uint256 timestamp, uint256 seigniorage);\n event BoardroomFunded(uint256 timestamp, uint256 seigniorage);\n}\n" }, "@openzeppelin/contracts/utils/ReentrancyGuard.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\ncontract ReentrancyGuard {\n // Booleans are more expensive than uint256 or any type that takes up a full\n // word because each write operation emits an extra SLOAD to first read the\n // slot's contents, replace the bits taken up by the boolean, and then write\n // back. This is the compiler's defense against contract upgrades and\n // pointer aliasing, and it cannot be disabled.\n\n // The values being non-zero value makes deployment a bit more expensive,\n // but in exchange the refund on every call to nonReentrant will be lower in\n // amount. Since refunds are capped to a percentage of the total\n // transaction's gas, it is best to keep them low in cases like this one, to\n // increase the likelihood of the full refund coming into effect.\n uint256 private constant _NOT_ENTERED = 1;\n uint256 private constant _ENTERED = 2;\n\n uint256 private _status;\n\n constructor () internal {\n _status = _NOT_ENTERED;\n }\n\n /**\n * @dev Prevents a contract from calling itself, directly or indirectly.\n * Calling a `nonReentrant` function from another `nonReentrant`\n * function is not supported. It is possible to prevent this from happening\n * by making the `nonReentrant` function external, and make it call a\n * `private` function that does the actual work.\n */\n modifier nonReentrant() {\n // On the first call to nonReentrant, _notEntered will be true\n require(_status != _ENTERED, \"ReentrancyGuard: reentrant call\");\n\n // Any calls to nonReentrant after this point will fail\n _status = _ENTERED;\n\n _;\n\n // By storing the original value once again, a refund is triggered (see\n // https://eips.ethereum.org/EIPS/eip-2200)\n _status = _NOT_ENTERED;\n }\n}\n" }, "contracts/lib/Babylonian.sol": { "content": "pragma solidity ^0.6.0;\n\nlibrary Babylonian {\n function sqrt(uint256 y) internal pure returns (uint256 z) {\n if (y > 3) {\n z = y;\n uint256 x = y / 2 + 1;\n while (x < z) {\n z = x;\n x = (y / x + x) / 2;\n }\n } else if (y != 0) {\n z = 1;\n }\n // else z = 0\n }\n}\n" }, "contracts/lib/FixedPoint.sol": { "content": "pragma solidity ^0.6.0;\n\nimport './Babylonian.sol';\n\n// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))\nlibrary FixedPoint {\n // range: [0, 2**112 - 1]\n // resolution: 1 / 2**112\n struct uq112x112 {\n uint224 _x;\n }\n\n // range: [0, 2**144 - 1]\n // resolution: 1 / 2**112\n struct uq144x112 {\n uint256 _x;\n }\n\n uint8 private constant RESOLUTION = 112;\n uint256 private constant Q112 = uint256(1) << RESOLUTION;\n uint256 private constant Q224 = Q112 << RESOLUTION;\n\n // encode a uint112 as a UQ112x112\n function encode(uint112 x) internal pure returns (uq112x112 memory) {\n return uq112x112(uint224(x) << RESOLUTION);\n }\n\n // encodes a uint144 as a UQ144x112\n function encode144(uint144 x) internal pure returns (uq144x112 memory) {\n return uq144x112(uint256(x) << RESOLUTION);\n }\n\n // divide a UQ112x112 by a uint112, returning a UQ112x112\n function div(uq112x112 memory self, uint112 x)\n internal\n pure\n returns (uq112x112 memory)\n {\n require(x != 0, 'FixedPoint: DIV_BY_ZERO');\n return uq112x112(self._x / uint224(x));\n }\n\n // multiply a UQ112x112 by a uint, returning a UQ144x112\n // reverts on overflow\n function mul(uq112x112 memory self, uint256 y)\n internal\n pure\n returns (uq144x112 memory)\n {\n uint256 z;\n require(\n y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x),\n 'FixedPoint: MULTIPLICATION_OVERFLOW'\n );\n return uq144x112(z);\n }\n\n // returns a UQ112x112 which represents the ratio of the numerator to the denominator\n // equivalent to encode(numerator).div(denominator)\n function fraction(uint112 numerator, uint112 denominator)\n internal\n pure\n returns (uq112x112 memory)\n {\n require(denominator > 0, 'FixedPoint: DIV_BY_ZERO');\n return uq112x112((uint224(numerator) << RESOLUTION) / denominator);\n }\n\n // decode a UQ112x112 into a uint112 by truncating after the radix point\n function decode(uq112x112 memory self) internal pure returns (uint112) {\n return uint112(self._x >> RESOLUTION);\n }\n\n // decode a UQ144x112 into a uint144 by truncating after the radix point\n function decode144(uq144x112 memory self) internal pure returns (uint144) {\n return uint144(self._x >> RESOLUTION);\n }\n\n // take the reciprocal of a UQ112x112\n function reciprocal(uq112x112 memory self)\n internal\n pure\n returns (uq112x112 memory)\n {\n require(self._x != 0, 'FixedPoint: ZERO_RECIPROCAL');\n return uq112x112(uint224(Q224 / self._x));\n }\n\n // square root of a UQ112x112\n function sqrt(uq112x112 memory self)\n internal\n pure\n returns (uq112x112 memory)\n {\n return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));\n }\n}\n" }, "contracts/interfaces/IOracle.sol": { "content": "pragma solidity ^0.6.0;\n\ninterface IOracle {\n function update() external;\n\n function consult(address token, uint256 amountIn)\n external\n view\n returns (uint256 amountOut);\n // function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestamp);\n}\n" }, "contracts/interfaces/IBoardroom.sol": { "content": "pragma solidity ^0.6.0;\n\ninterface IBoardroom {\n function allocateSeigniorage(uint256 amount) external;\n}\n" }, "contracts/Oracle.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\n\nimport './lib/Babylonian.sol';\nimport './lib/FixedPoint.sol';\nimport './lib/UniswapV2Library.sol';\nimport './lib/UniswapV2OracleLibrary.sol';\nimport './interfaces/IUniswapV2Pair.sol';\nimport './interfaces/IUniswapV2Factory.sol';\n\n// fixed window oracle that recomputes the average price for the entire period once every period\n// note that the price average is only guaranteed to be over at least 1 period, but may be over a longer period\ncontract Oracle {\n using FixedPoint for *;\n\n uint256 public constant PERIOD = 10 minutes;\n\n IUniswapV2Pair public pair;\n address public token0;\n address public token1;\n\n uint256 public price0CumulativeLast;\n uint256 public price1CumulativeLast;\n uint32 public blockTimestampLast;\n FixedPoint.uq112x112 public price0Average;\n FixedPoint.uq112x112 public price1Average;\n\n constructor(\n address factory,\n address tokenA,\n address tokenB\n ) public {\n IUniswapV2Pair _pair = IUniswapV2Pair(\n UniswapV2Library.pairFor(factory, tokenA, tokenB)\n );\n pair = _pair;\n token0 = _pair.token0();\n token1 = _pair.token1();\n price0CumulativeLast = _pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)\n price1CumulativeLast = _pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)\n uint112 reserve0;\n uint112 reserve1;\n (reserve0, reserve1, blockTimestampLast) = _pair.getReserves();\n require(reserve0 != 0 && reserve1 != 0, 'Oracle: NO_RESERVES'); // ensure that there's liquidity in the pair\n }\n\n /** @dev Updates 1-day EMA price from Uniswap. */\n function update() external {\n (\n uint256 price0Cumulative,\n uint256 price1Cumulative,\n uint32 blockTimestamp\n ) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));\n uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired\n\n if (timeElapsed < PERIOD) {\n // doesn't need to be updated, since a minimum period is not elapsed yet\n return;\n }\n\n // overflow is desired, casting never truncates\n // cumulative price is in (uq112x112 price * seconds) units so we simply wrap it after division by time elapsed\n price0Average = FixedPoint.uq112x112(\n uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)\n );\n price1Average = FixedPoint.uq112x112(\n uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)\n );\n\n price0CumulativeLast = price0Cumulative;\n price1CumulativeLast = price1Cumulative;\n blockTimestampLast = blockTimestamp;\n\n emit Updated(price0Cumulative, price1Cumulative);\n }\n\n // note this will always return 0 before update has been called successfully for the first time.\n function consult(address token, uint256 amountIn)\n external\n view\n returns (uint144 amountOut)\n {\n if (token == token0) {\n amountOut = price0Average.mul(amountIn).decode144();\n } else {\n require(token == token1, 'Oracle: INVALID_TOKEN');\n amountOut = price1Average.mul(amountIn).decode144();\n }\n }\n\n function pairFor(\n address factory,\n address tokenA,\n address tokenB\n ) external pure returns (address lpt) {\n return UniswapV2Library.pairFor(factory, tokenA, tokenB);\n }\n\n event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);\n}\n" }, "contracts/lib/UniswapV2Library.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\nimport '../interfaces/IUniswapV2Pair.sol';\n\nlibrary UniswapV2Library {\n using SafeMath for uint256;\n\n // returns sorted token addresses, used to handle return values from pairs sorted in this order\n function sortTokens(address tokenA, address tokenB)\n internal\n pure\n returns (address token0, address token1)\n {\n require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');\n (token0, token1) = tokenA < tokenB\n ? (tokenA, tokenB)\n : (tokenB, tokenA);\n require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');\n }\n\n // calculates the CREATE2 address for a pair without making any external calls\n function pairFor(\n address factory,\n address tokenA,\n address tokenB\n ) internal pure returns (address pair) {\n (address token0, address token1) = sortTokens(tokenA, tokenB);\n pair = address(\n uint256(\n keccak256(\n abi.encodePacked(\n hex'ff',\n factory,\n keccak256(abi.encodePacked(token0, token1)),\n hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash\n )\n )\n )\n );\n }\n\n // fetches and sorts the reserves for a pair\n function getReserves(\n address factory,\n address tokenA,\n address tokenB\n ) internal view returns (uint256 reserveA, uint256 reserveB) {\n (address token0, ) = sortTokens(tokenA, tokenB);\n (uint256 reserve0, uint256 reserve1, ) = IUniswapV2Pair(\n pairFor(factory, tokenA, tokenB)\n )\n .getReserves();\n (reserveA, reserveB) = tokenA == token0\n ? (reserve0, reserve1)\n : (reserve1, reserve0);\n }\n\n // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset\n function quote(\n uint256 amountA,\n uint256 reserveA,\n uint256 reserveB\n ) internal pure returns (uint256 amountB) {\n require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');\n require(\n reserveA > 0 && reserveB > 0,\n 'UniswapV2Library: INSUFFICIENT_LIQUIDITY'\n );\n amountB = amountA.mul(reserveB) / reserveA;\n }\n\n // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset\n function getAmountOut(\n uint256 amountIn,\n uint256 reserveIn,\n uint256 reserveOut\n ) internal pure returns (uint256 amountOut) {\n require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');\n require(\n reserveIn > 0 && reserveOut > 0,\n 'UniswapV2Library: INSUFFICIENT_LIQUIDITY'\n );\n uint256 amountInWithFee = amountIn.mul(997);\n uint256 numerator = amountInWithFee.mul(reserveOut);\n uint256 denominator = reserveIn.mul(1000).add(amountInWithFee);\n amountOut = numerator / denominator;\n }\n\n // given an output amount of an asset and pair reserves, returns a required input amount of the other asset\n function getAmountIn(\n uint256 amountOut,\n uint256 reserveIn,\n uint256 reserveOut\n ) internal pure returns (uint256 amountIn) {\n require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');\n require(\n reserveIn > 0 && reserveOut > 0,\n 'UniswapV2Library: INSUFFICIENT_LIQUIDITY'\n );\n uint256 numerator = reserveIn.mul(amountOut).mul(1000);\n uint256 denominator = reserveOut.sub(amountOut).mul(997);\n amountIn = (numerator / denominator).add(1);\n }\n\n // performs chained getAmountOut calculations on any number of pairs\n function getAmountsOut(\n address factory,\n uint256 amountIn,\n address[] memory path\n ) internal view returns (uint256[] memory amounts) {\n require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');\n amounts = new uint256[](path.length);\n amounts[0] = amountIn;\n for (uint256 i; i < path.length - 1; i++) {\n (uint256 reserveIn, uint256 reserveOut) = getReserves(\n factory,\n path[i],\n path[i + 1]\n );\n amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);\n }\n }\n\n // performs chained getAmountIn calculations on any number of pairs\n function getAmountsIn(\n address factory,\n uint256 amountOut,\n address[] memory path\n ) internal view returns (uint256[] memory amounts) {\n require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');\n amounts = new uint256[](path.length);\n amounts[amounts.length - 1] = amountOut;\n for (uint256 i = path.length - 1; i > 0; i--) {\n (uint256 reserveIn, uint256 reserveOut) = getReserves(\n factory,\n path[i - 1],\n path[i]\n );\n amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);\n }\n }\n}\n" }, "contracts/lib/UniswapV2OracleLibrary.sol": { "content": "pragma solidity ^0.6.0;\n\nimport './FixedPoint.sol';\nimport '../interfaces/IUniswapV2Pair.sol';\n\n// library with helper methods for oracles that are concerned with computing average prices\nlibrary UniswapV2OracleLibrary {\n using FixedPoint for *;\n\n // helper function that returns the current block timestamp within the range of uint32, i.e. [0, 2**32 - 1]\n function currentBlockTimestamp() internal view returns (uint32) {\n return uint32(block.timestamp % 2**32);\n }\n\n // produces the cumulative price using counterfactuals to save gas and avoid a call to sync.\n function currentCumulativePrices(address pair)\n internal\n view\n returns (\n uint256 price0Cumulative,\n uint256 price1Cumulative,\n uint32 blockTimestamp\n )\n {\n blockTimestamp = currentBlockTimestamp();\n price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();\n price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();\n\n // if time has elapsed since the last update on the pair, mock the accumulated price values\n (\n uint112 reserve0,\n uint112 reserve1,\n uint32 blockTimestampLast\n ) = IUniswapV2Pair(pair).getReserves();\n if (blockTimestampLast != blockTimestamp) {\n // subtraction overflow is desired\n uint32 timeElapsed = blockTimestamp - blockTimestampLast;\n // addition overflow is desired\n // counterfactual\n price0Cumulative +=\n uint256(FixedPoint.fraction(reserve1, reserve0)._x) *\n timeElapsed;\n // counterfactual\n price1Cumulative +=\n uint256(FixedPoint.fraction(reserve0, reserve1)._x) *\n timeElapsed;\n }\n }\n}\n" }, "contracts/interfaces/IUniswapV2Pair.sol": { "content": "pragma solidity ^0.6.0;\n\ninterface IUniswapV2Pair {\n event Approval(\n address indexed owner,\n address indexed spender,\n uint256 value\n );\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n function name() external pure returns (string memory);\n\n function symbol() external pure returns (string memory);\n\n function decimals() external pure returns (uint8);\n\n function totalSupply() external view returns (uint256);\n\n function balanceOf(address owner) external view returns (uint256);\n\n function allowance(address owner, address spender)\n external\n view\n returns (uint256);\n\n function approve(address spender, uint256 value) external returns (bool);\n\n function transfer(address to, uint256 value) external returns (bool);\n\n function transferFrom(\n address from,\n address to,\n uint256 value\n ) external returns (bool);\n\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n\n function PERMIT_TYPEHASH() external pure returns (bytes32);\n\n function nonces(address owner) external view returns (uint256);\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 event Mint(address indexed sender, uint256 amount0, uint256 amount1);\n event Burn(\n address indexed sender,\n uint256 amount0,\n uint256 amount1,\n address indexed to\n );\n event Swap(\n address indexed sender,\n uint256 amount0In,\n uint256 amount1In,\n uint256 amount0Out,\n uint256 amount1Out,\n address indexed to\n );\n event Sync(uint112 reserve0, uint112 reserve1);\n\n function MINIMUM_LIQUIDITY() external pure returns (uint256);\n\n function factory() external view returns (address);\n\n function token0() external view returns (address);\n\n function token1() external view returns (address);\n\n function getReserves()\n external\n view\n returns (\n uint112 reserve0,\n uint112 reserve1,\n uint32 blockTimestampLast\n );\n\n function price0CumulativeLast() external view returns (uint256);\n\n function price1CumulativeLast() external view returns (uint256);\n\n function kLast() external view returns (uint256);\n\n function mint(address to) external returns (uint256 liquidity);\n\n function burn(address to)\n external\n returns (uint256 amount0, uint256 amount1);\n\n function swap(\n uint256 amount0Out,\n uint256 amount1Out,\n address to,\n bytes calldata data\n ) external;\n\n function skim(address to) external;\n\n function sync() external;\n\n function initialize(address, address) external;\n}\n" }, "contracts/interfaces/IUniswapV2Factory.sol": { "content": "pragma solidity ^0.6.0;\n\ninterface IUniswapV2Factory {\n event PairCreated(\n address indexed token0,\n address indexed token1,\n address pair,\n uint256\n );\n\n function getPair(address tokenA, address tokenB)\n external\n view\n returns (address pair);\n\n function allPairs(uint256) external view returns (address pair);\n\n function allPairsLength() external view returns (uint256);\n\n function feeTo() external view returns (address);\n\n function feeToSetter() external view returns (address);\n\n function createPair(address tokenA, address tokenB)\n external\n returns (address pair);\n}\n" }, "contracts/Timelock.sol": { "content": "pragma solidity ^0.6.0;\n\n/*\n * Copyright 2020 Compound Labs, Inc.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n *\n * 3. Neither the name of the copyright holder nor the names of its contributors\n * may be used to endorse or promote products derived from this software without\n * specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,\n * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\n * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\n * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\n * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\n * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\nimport '@openzeppelin/contracts/math/SafeMath.sol';\n\ncontract Timelock {\n using SafeMath for uint256;\n\n event NewAdmin(address indexed newAdmin);\n event NewPendingAdmin(address indexed newPendingAdmin);\n event NewDelay(uint256 indexed newDelay);\n event CancelTransaction(\n bytes32 indexed txHash,\n address indexed target,\n uint256 value,\n string signature,\n bytes data,\n uint256 eta\n );\n event ExecuteTransaction(\n bytes32 indexed txHash,\n address indexed target,\n uint256 value,\n string signature,\n bytes data,\n uint256 eta\n );\n event QueueTransaction(\n bytes32 indexed txHash,\n address indexed target,\n uint256 value,\n string signature,\n bytes data,\n uint256 eta\n );\n\n uint256 public constant GRACE_PERIOD = 14 days;\n uint256 public constant MINIMUM_DELAY = 2 days;\n uint256 public constant MAXIMUM_DELAY = 30 days;\n\n address public admin;\n address public pendingAdmin;\n uint256 public delay;\n\n mapping(bytes32 => bool) public queuedTransactions;\n\n constructor(address admin_, uint256 delay_) public {\n require(\n delay_ >= MINIMUM_DELAY,\n 'Timelock::constructor: Delay must exceed minimum delay.'\n );\n require(\n delay_ <= MAXIMUM_DELAY,\n 'Timelock::setDelay: Delay must not exceed maximum delay.'\n );\n\n admin = admin_;\n delay = delay_;\n }\n\n receive() external payable {}\n\n function setDelay(uint256 delay_) public {\n require(\n msg.sender == address(this),\n 'Timelock::setDelay: Call must come from Timelock.'\n );\n require(\n delay_ >= MINIMUM_DELAY,\n 'Timelock::setDelay: Delay must exceed minimum delay.'\n );\n require(\n delay_ <= MAXIMUM_DELAY,\n 'Timelock::setDelay: Delay must not exceed maximum delay.'\n );\n delay = delay_;\n\n emit NewDelay(delay);\n }\n\n function acceptAdmin() public {\n require(\n msg.sender == pendingAdmin,\n 'Timelock::acceptAdmin: Call must come from pendingAdmin.'\n );\n admin = msg.sender;\n pendingAdmin = address(0);\n\n emit NewAdmin(admin);\n }\n\n function setPendingAdmin(address pendingAdmin_) public {\n require(\n msg.sender == address(this),\n 'Timelock::setPendingAdmin: Call must come from Timelock.'\n );\n pendingAdmin = pendingAdmin_;\n\n emit NewPendingAdmin(pendingAdmin);\n }\n\n function queueTransaction(\n address target,\n uint256 value,\n string memory signature,\n bytes memory data,\n uint256 eta\n ) public returns (bytes32) {\n require(\n msg.sender == admin,\n 'Timelock::queueTransaction: Call must come from admin.'\n );\n require(\n eta >= getBlockTimestamp().add(delay),\n 'Timelock::queueTransaction: Estimated execution block must satisfy delay.'\n );\n\n bytes32 txHash = keccak256(\n abi.encode(target, value, signature, data, eta)\n );\n queuedTransactions[txHash] = true;\n\n emit QueueTransaction(txHash, target, value, signature, data, eta);\n return txHash;\n }\n\n function cancelTransaction(\n address target,\n uint256 value,\n string memory signature,\n bytes memory data,\n uint256 eta\n ) public {\n require(\n msg.sender == admin,\n 'Timelock::cancelTransaction: Call must come from admin.'\n );\n\n bytes32 txHash = keccak256(\n abi.encode(target, value, signature, data, eta)\n );\n queuedTransactions[txHash] = false;\n\n emit CancelTransaction(txHash, target, value, signature, data, eta);\n }\n\n function executeTransaction(\n address target,\n uint256 value,\n string memory signature,\n bytes memory data,\n uint256 eta\n ) public payable returns (bytes memory) {\n require(\n msg.sender == admin,\n 'Timelock::executeTransaction: Call must come from admin.'\n );\n\n bytes32 txHash = keccak256(\n abi.encode(target, value, signature, data, eta)\n );\n require(\n queuedTransactions[txHash],\n \"Timelock::executeTransaction: Transaction hasn't been queued.\"\n );\n require(\n getBlockTimestamp() >= eta,\n \"Timelock::executeTransaction: Transaction hasn't surpassed time lock.\"\n );\n require(\n getBlockTimestamp() <= eta.add(GRACE_PERIOD),\n 'Timelock::executeTransaction: Transaction is stale.'\n );\n\n queuedTransactions[txHash] = false;\n\n bytes memory callData;\n\n if (bytes(signature).length == 0) {\n callData = data;\n } else {\n callData = abi.encodePacked(\n bytes4(keccak256(bytes(signature))),\n data\n );\n }\n\n // solium-disable-next-line security/no-call-value\n (bool success, bytes memory returnData) = target.call{value: value}(\n callData\n );\n require(\n success,\n 'Timelock::executeTransaction: Transaction execution reverted.'\n );\n\n emit ExecuteTransaction(txHash, target, value, signature, data, eta);\n\n return returnData;\n }\n\n function getBlockTimestamp() internal view returns (uint256) {\n // solium-disable-next-line security/no-block-members\n return block.timestamp;\n }\n}\n" }, "contracts/distributor/InitialShareDistributor.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\nimport '../interfaces/IDistributor.sol';\nimport '../interfaces/IRewardDistributionRecipient.sol';\n\ncontract InitialShareDistributor is IDistributor {\n using SafeMath for uint256;\n\n event Distributed(address pool, uint256 cashAmount);\n\n bool public once = true;\n\n IERC20 public share;\n IRewardDistributionRecipient public daibacLPPool;\n uint256 public daibacInitialBalance;\n IRewardDistributionRecipient public daibasLPPool;\n uint256 public daibasInitialBalance;\n\n constructor(\n IERC20 _share,\n IRewardDistributionRecipient _daibacLPPool,\n uint256 _daibacInitialBalance,\n IRewardDistributionRecipient _daibasLPPool,\n uint256 _daibasInitialBalance\n ) public {\n share = _share;\n daibacLPPool = _daibacLPPool;\n daibacInitialBalance = _daibacInitialBalance;\n daibasLPPool = _daibasLPPool;\n daibasInitialBalance = _daibasInitialBalance;\n }\n\n function distribute() public override {\n require(\n once,\n 'InitialShareDistributor: you cannot run this function twice'\n );\n\n share.transfer(address(daibacLPPool), daibacInitialBalance);\n daibacLPPool.notifyRewardAmount(daibacInitialBalance);\n emit Distributed(address(daibacLPPool), daibacInitialBalance);\n\n share.transfer(address(daibasLPPool), daibasInitialBalance);\n daibasLPPool.notifyRewardAmount(daibasInitialBalance);\n emit Distributed(address(daibasLPPool), daibasInitialBalance);\n\n once = false;\n }\n}\n" }, "contracts/interfaces/IDistributor.sol": { "content": "pragma solidity ^0.6.0;\n\ninterface IDistributor {\n function distribute() external;\n}\n" }, "contracts/interfaces/IRewardDistributionRecipient.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '@openzeppelin/contracts/access/Ownable.sol';\n\nabstract contract IRewardDistributionRecipient is Ownable {\n address public rewardDistribution;\n\n function notifyRewardAmount(uint256 reward) external virtual;\n\n modifier onlyRewardDistribution() {\n require(\n _msgSender() == rewardDistribution,\n 'Caller is not reward distribution'\n );\n _;\n }\n\n function setRewardDistribution(address _rewardDistribution)\n external\n virtual\n onlyOwner\n {\n rewardDistribution = _rewardDistribution;\n }\n}\n" }, "contracts/distribution/DAIBASLPTokenSharePool.sol": { "content": "pragma solidity ^0.6.0;\n/**\n *Submitted for verification at Etherscan.io on 2020-07-17\n */\n\n/*\n ____ __ __ __ _\n / __/__ __ ___ / /_ / / ___ / /_ (_)__ __\n _\\ \\ / // // _ \\/ __// _ \\/ -_)/ __// / \\ \\ /\n/___/ \\_, //_//_/\\__//_//_/\\__/ \\__//_/ /_\\_\\\n /___/\n\n* Synthetix: BASISCASHRewards.sol\n*\n* Docs: https://docs.synthetix.io/\n*\n*\n* MIT License\n* ===========\n*\n* Copyright (c) 2020 Synthetix\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is\n* furnished to do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n*/\n\n// File: @openzeppelin/contracts/math/Math.sol\n\nimport '@openzeppelin/contracts/math/Math.sol';\n\n// File: @openzeppelin/contracts/math/SafeMath.sol\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/IERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\n// File: @openzeppelin/contracts/utils/Address.sol\n\nimport '@openzeppelin/contracts/utils/Address.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';\n\n// File: contracts/IRewardDistributionRecipient.sol\n\nimport '../interfaces/IRewardDistributionRecipient.sol';\n\nimport '../token/LPTokenWrapper.sol';\n\ncontract DAIBASLPTokenSharePool is\n LPTokenWrapper,\n IRewardDistributionRecipient\n{\n IERC20 public basisShare;\n uint256 public DURATION = 365 days;\n\n uint256 public starttime;\n uint256 public periodFinish = 0;\n uint256 public rewardRate = 0;\n uint256 public lastUpdateTime;\n uint256 public rewardPerTokenStored;\n mapping(address => uint256) public userRewardPerTokenPaid;\n mapping(address => uint256) public rewards;\n\n event RewardAdded(uint256 reward);\n event Staked(address indexed user, uint256 amount);\n event Withdrawn(address indexed user, uint256 amount);\n event RewardPaid(address indexed user, uint256 reward);\n\n constructor(\n address basisShare_,\n address lptoken_,\n uint256 starttime_\n ) public {\n basisShare = IERC20(basisShare_);\n lpt = IERC20(lptoken_);\n starttime = starttime_;\n }\n\n modifier checkStart() {\n require(\n block.timestamp >= starttime,\n 'DAIBASLPTokenSharePool: not start'\n );\n _;\n }\n\n modifier updateReward(address account) {\n rewardPerTokenStored = rewardPerToken();\n lastUpdateTime = lastTimeRewardApplicable();\n if (account != address(0)) {\n rewards[account] = earned(account);\n userRewardPerTokenPaid[account] = rewardPerTokenStored;\n }\n _;\n }\n\n function lastTimeRewardApplicable() public view returns (uint256) {\n return Math.min(block.timestamp, periodFinish);\n }\n\n function rewardPerToken() public view returns (uint256) {\n if (totalSupply() == 0) {\n return rewardPerTokenStored;\n }\n return\n rewardPerTokenStored.add(\n lastTimeRewardApplicable()\n .sub(lastUpdateTime)\n .mul(rewardRate)\n .mul(1e18)\n .div(totalSupply())\n );\n }\n\n function earned(address account) public view returns (uint256) {\n return\n balanceOf(account)\n .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))\n .div(1e18)\n .add(rewards[account]);\n }\n\n // stake visibility is public as overriding LPTokenWrapper's stake() function\n function stake(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'DAIBASLPTokenSharePool: Cannot stake 0');\n super.stake(amount);\n emit Staked(msg.sender, amount);\n }\n\n function withdraw(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'DAIBASLPTokenSharePool: Cannot withdraw 0');\n super.withdraw(amount);\n emit Withdrawn(msg.sender, amount);\n }\n\n function exit() external {\n withdraw(balanceOf(msg.sender));\n getReward();\n }\n\n function getReward() public updateReward(msg.sender) checkStart {\n uint256 reward = earned(msg.sender);\n if (reward > 0) {\n rewards[msg.sender] = 0;\n basisShare.safeTransfer(msg.sender, reward);\n emit RewardPaid(msg.sender, reward);\n }\n }\n\n function notifyRewardAmount(uint256 reward)\n external\n override\n onlyRewardDistribution\n updateReward(address(0))\n {\n if (block.timestamp > starttime) {\n if (block.timestamp >= periodFinish) {\n rewardRate = reward.div(DURATION);\n } else {\n uint256 remaining = periodFinish.sub(block.timestamp);\n uint256 leftover = remaining.mul(rewardRate);\n rewardRate = reward.add(leftover).div(DURATION);\n }\n lastUpdateTime = block.timestamp;\n periodFinish = block.timestamp.add(DURATION);\n emit RewardAdded(reward);\n } else {\n rewardRate = reward.div(DURATION);\n lastUpdateTime = starttime;\n periodFinish = starttime.add(DURATION);\n emit RewardAdded(reward);\n }\n }\n}\n" }, "@openzeppelin/contracts/math/Math.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n /**\n * @dev Returns the largest of two numbers.\n */\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\n return a >= b ? a : b;\n }\n\n /**\n * @dev Returns the smallest of two numbers.\n */\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\n return a < b ? a : b;\n }\n\n /**\n * @dev Returns the average of two numbers. The result is rounded towards\n * zero.\n */\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b) / 2 can overflow, so we distribute\n return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);\n }\n}\n" }, "contracts/token/LPTokenWrapper.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\nimport '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\ncontract LPTokenWrapper {\n using SafeMath for uint256;\n using SafeERC20 for IERC20;\n\n IERC20 public lpt;\n\n uint256 private _totalSupply;\n mapping(address => uint256) private _balances;\n\n function totalSupply() public view returns (uint256) {\n return _totalSupply;\n }\n\n function balanceOf(address account) public view returns (uint256) {\n return _balances[account];\n }\n\n function stake(uint256 amount) public virtual {\n _totalSupply = _totalSupply.add(amount);\n _balances[msg.sender] = _balances[msg.sender].add(amount);\n lpt.safeTransferFrom(msg.sender, address(this), amount);\n }\n\n function withdraw(uint256 amount) public virtual {\n _totalSupply = _totalSupply.sub(amount);\n _balances[msg.sender] = _balances[msg.sender].sub(amount);\n lpt.safeTransfer(msg.sender, amount);\n }\n}\n" }, "contracts/distribution/DAIBACLPTokenSharePool.sol": { "content": "pragma solidity ^0.6.0;\n/**\n *Submitted for verification at Etherscan.io on 2020-07-17\n */\n\n/*\n ____ __ __ __ _\n / __/__ __ ___ / /_ / / ___ / /_ (_)__ __\n _\\ \\ / // // _ \\/ __// _ \\/ -_)/ __// / \\ \\ /\n/___/ \\_, //_//_/\\__//_//_/\\__/ \\__//_/ /_\\_\\\n /___/\n\n* Synthetix: BASISCASHRewards.sol\n*\n* Docs: https://docs.synthetix.io/\n*\n*\n* MIT License\n* ===========\n*\n* Copyright (c) 2020 Synthetix\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is\n* furnished to do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n*/\n\n// File: @openzeppelin/contracts/math/Math.sol\n\nimport '@openzeppelin/contracts/math/Math.sol';\n\n// File: @openzeppelin/contracts/math/SafeMath.sol\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/IERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\n// File: @openzeppelin/contracts/utils/Address.sol\n\nimport '@openzeppelin/contracts/utils/Address.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';\n\n// File: contracts/IRewardDistributionRecipient.sol\n\nimport '../interfaces/IRewardDistributionRecipient.sol';\n\nimport '../token/LPTokenWrapper.sol';\n\ncontract DAIBACLPTokenSharePool is\n LPTokenWrapper,\n IRewardDistributionRecipient\n{\n IERC20 public basisShare;\n uint256 public constant DURATION = 30 days;\n\n uint256 public initreward = 18479995 * 10**16; // 184,799.95 Shares\n uint256 public starttime; // starttime TBD\n uint256 public periodFinish = 0;\n uint256 public rewardRate = 0;\n uint256 public lastUpdateTime;\n uint256 public rewardPerTokenStored;\n mapping(address => uint256) public userRewardPerTokenPaid;\n mapping(address => uint256) public rewards;\n\n event RewardAdded(uint256 reward);\n event Staked(address indexed user, uint256 amount);\n event Withdrawn(address indexed user, uint256 amount);\n event RewardPaid(address indexed user, uint256 reward);\n\n constructor(\n address basisShare_,\n address lptoken_,\n uint256 starttime_\n ) public {\n basisShare = IERC20(basisShare_);\n lpt = IERC20(lptoken_);\n starttime = starttime_;\n }\n\n modifier updateReward(address account) {\n rewardPerTokenStored = rewardPerToken();\n lastUpdateTime = lastTimeRewardApplicable();\n if (account != address(0)) {\n rewards[account] = earned(account);\n userRewardPerTokenPaid[account] = rewardPerTokenStored;\n }\n _;\n }\n\n function lastTimeRewardApplicable() public view returns (uint256) {\n return Math.min(block.timestamp, periodFinish);\n }\n\n function rewardPerToken() public view returns (uint256) {\n if (totalSupply() == 0) {\n return rewardPerTokenStored;\n }\n return\n rewardPerTokenStored.add(\n lastTimeRewardApplicable()\n .sub(lastUpdateTime)\n .mul(rewardRate)\n .mul(1e18)\n .div(totalSupply())\n );\n }\n\n function earned(address account) public view returns (uint256) {\n return\n balanceOf(account)\n .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))\n .div(1e18)\n .add(rewards[account]);\n }\n\n // stake visibility is public as overriding LPTokenWrapper's stake() function\n function stake(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkhalve\n checkStart\n {\n require(amount > 0, 'Cannot stake 0');\n super.stake(amount);\n emit Staked(msg.sender, amount);\n }\n\n function withdraw(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkhalve\n checkStart\n {\n require(amount > 0, 'Cannot withdraw 0');\n super.withdraw(amount);\n emit Withdrawn(msg.sender, amount);\n }\n\n function exit() external {\n withdraw(balanceOf(msg.sender));\n getReward();\n }\n\n function getReward() public updateReward(msg.sender) checkhalve checkStart {\n uint256 reward = earned(msg.sender);\n if (reward > 0) {\n rewards[msg.sender] = 0;\n basisShare.safeTransfer(msg.sender, reward);\n emit RewardPaid(msg.sender, reward);\n }\n }\n\n modifier checkhalve() {\n if (block.timestamp >= periodFinish) {\n initreward = initreward.mul(75).div(100);\n\n rewardRate = initreward.div(DURATION);\n periodFinish = block.timestamp.add(DURATION);\n emit RewardAdded(initreward);\n }\n _;\n }\n\n modifier checkStart() {\n require(block.timestamp >= starttime, 'not start');\n _;\n }\n\n function notifyRewardAmount(uint256 reward)\n external\n override\n onlyRewardDistribution\n updateReward(address(0))\n {\n if (block.timestamp > starttime) {\n if (block.timestamp >= periodFinish) {\n rewardRate = reward.div(DURATION);\n } else {\n uint256 remaining = periodFinish.sub(block.timestamp);\n uint256 leftover = remaining.mul(rewardRate);\n rewardRate = reward.add(leftover).div(DURATION);\n }\n lastUpdateTime = block.timestamp;\n periodFinish = block.timestamp.add(DURATION);\n emit RewardAdded(reward);\n } else {\n rewardRate = initreward.div(DURATION);\n lastUpdateTime = starttime;\n periodFinish = starttime.add(DURATION);\n emit RewardAdded(reward);\n }\n }\n}\n" }, "contracts/distribution/BACyCRVPool.sol": { "content": "pragma solidity ^0.6.0;\n/**\n *Submitted for verification at Etherscan.io on 2020-07-17\n */\n\n/*\n ____ __ __ __ _\n / __/__ __ ___ / /_ / / ___ / /_ (_)__ __\n _\\ \\ / // // _ \\/ __// _ \\/ -_)/ __// / \\ \\ /\n/___/ \\_, //_//_/\\__//_//_/\\__/ \\__//_/ /_\\_\\\n /___/\n\n* Synthetix: BASISCASHRewards.sol\n*\n* Docs: https://docs.synthetix.io/\n*\n*\n* MIT License\n* ===========\n*\n* Copyright (c) 2020 Synthetix\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is\n* furnished to do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n*/\n\n// File: @openzeppelin/contracts/math/Math.sol\n\nimport '@openzeppelin/contracts/math/Math.sol';\n\n// File: @openzeppelin/contracts/math/SafeMath.sol\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/IERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\n// File: @openzeppelin/contracts/utils/Address.sol\n\nimport '@openzeppelin/contracts/utils/Address.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';\n\n// File: contracts/IRewardDistributionRecipient.sol\n\nimport '../interfaces/IRewardDistributionRecipient.sol';\n\ncontract yCRVWrapper {\n using SafeMath for uint256;\n using SafeERC20 for IERC20;\n\n IERC20 public ycrv;\n\n uint256 private _totalSupply;\n mapping(address => uint256) private _balances;\n\n function totalSupply() public virtual view returns (uint256) {\n return _totalSupply;\n }\n\n function balanceOf(address account) public virtual view returns (uint256) {\n return _balances[account];\n }\n\n function stake(uint256 amount) public virtual {\n _totalSupply = _totalSupply.add(amount);\n _balances[msg.sender] = _balances[msg.sender].add(amount);\n ycrv.safeTransferFrom(msg.sender, address(this), amount);\n }\n\n function withdraw(uint256 amount) public virtual {\n _totalSupply = _totalSupply.sub(amount);\n _balances[msg.sender] = _balances[msg.sender].sub(amount);\n ycrv.safeTransfer(msg.sender, amount);\n }\n}\n\ncontract BACyCRVPool is yCRVWrapper, IRewardDistributionRecipient {\n IERC20 public basisCash;\n uint256 public DURATION = 5 days;\n\n uint256 public starttime;\n uint256 public periodFinish = 0;\n uint256 public rewardRate = 0;\n uint256 public lastUpdateTime;\n uint256 public rewardPerTokenStored;\n mapping(address => uint256) public userRewardPerTokenPaid;\n mapping(address => uint256) public rewards;\n mapping(address => uint256) public deposits;\n\n event RewardAdded(uint256 reward);\n event Staked(address indexed user, uint256 amount);\n event Withdrawn(address indexed user, uint256 amount);\n event RewardPaid(address indexed user, uint256 reward);\n\n constructor(\n address basisCash_,\n address ycrv_,\n uint256 starttime_\n ) public {\n basisCash = IERC20(basisCash_);\n ycrv = IERC20(ycrv_);\n starttime = starttime_;\n }\n\n modifier checkStart() {\n require(block.timestamp >= starttime, 'BACyCRVPool: not start');\n _;\n }\n\n modifier updateReward(address account) {\n rewardPerTokenStored = rewardPerToken();\n lastUpdateTime = lastTimeRewardApplicable();\n if (account != address(0)) {\n rewards[account] = earned(account);\n userRewardPerTokenPaid[account] = rewardPerTokenStored;\n }\n _;\n }\n\n function lastTimeRewardApplicable() public view returns (uint256) {\n return Math.min(block.timestamp, periodFinish);\n }\n\n function rewardPerToken() public view returns (uint256) {\n if (totalSupply() == 0) {\n return rewardPerTokenStored;\n }\n return\n rewardPerTokenStored.add(\n lastTimeRewardApplicable()\n .sub(lastUpdateTime)\n .mul(rewardRate)\n .mul(1e18)\n .div(totalSupply())\n );\n }\n\n function earned(address account) public view returns (uint256) {\n return\n balanceOf(account)\n .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))\n .div(1e18)\n .add(rewards[account]);\n }\n\n // stake visibility is public as overriding LPTokenWrapper's stake() function\n function stake(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'BACyCRVPool: Cannot stake 0');\n uint256 newDeposit = deposits[msg.sender].add(amount);\n require(\n newDeposit <= 20000e18,\n 'BACyCRVPool: deposit amount exceeds maximum 20000'\n );\n deposits[msg.sender] = newDeposit;\n super.stake(amount);\n emit Staked(msg.sender, amount);\n }\n\n function withdraw(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'BACyCRVPool: Cannot withdraw 0');\n deposits[msg.sender] = deposits[msg.sender].sub(amount);\n super.withdraw(amount);\n emit Withdrawn(msg.sender, amount);\n }\n\n function exit() external {\n withdraw(balanceOf(msg.sender));\n getReward();\n }\n\n function getReward() public updateReward(msg.sender) checkStart {\n uint256 reward = earned(msg.sender);\n if (reward > 0) {\n rewards[msg.sender] = 0;\n basisCash.safeTransfer(msg.sender, reward);\n emit RewardPaid(msg.sender, reward);\n }\n }\n\n function notifyRewardAmount(uint256 reward)\n external\n override\n onlyRewardDistribution\n updateReward(address(0))\n {\n if (block.timestamp > starttime) {\n if (block.timestamp >= periodFinish) {\n rewardRate = reward.div(DURATION);\n } else {\n uint256 remaining = periodFinish.sub(block.timestamp);\n uint256 leftover = remaining.mul(rewardRate);\n rewardRate = reward.add(leftover).div(DURATION);\n }\n lastUpdateTime = block.timestamp;\n periodFinish = block.timestamp.add(DURATION);\n emit RewardAdded(reward);\n } else {\n rewardRate = reward.div(DURATION);\n lastUpdateTime = starttime;\n periodFinish = starttime.add(DURATION);\n emit RewardAdded(reward);\n }\n }\n}\n" }, "contracts/distributor/InitialCashDistributor.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '../distribution/BACDAIPool.sol';\nimport '../distribution/BACSUSDPool.sol';\nimport '../distribution/BACUSDCPool.sol';\nimport '../distribution/BACUSDTPool.sol';\nimport '../distribution/BACyCRVPool.sol';\nimport '../interfaces/IDistributor.sol';\n\ncontract InitialCashDistributor is IDistributor {\n using SafeMath for uint256;\n\n event Distributed(address pool, uint256 cashAmount);\n\n bool public once = true;\n\n IERC20 public cash;\n IRewardDistributionRecipient[] public pools;\n uint256 public totalInitialBalance;\n\n constructor(\n IERC20 _cash,\n IRewardDistributionRecipient[] memory _pools,\n uint256 _totalInitialBalance\n ) public {\n require(_pools.length != 0, 'a list of BAC pools are required');\n\n cash = _cash;\n pools = _pools;\n totalInitialBalance = _totalInitialBalance;\n }\n\n function distribute() public override {\n require(\n once,\n 'InitialCashDistributor: you cannot run this function twice'\n );\n\n for (uint256 i = 0; i < pools.length; i++) {\n uint256 amount = totalInitialBalance.div(pools.length);\n\n cash.transfer(address(pools[i]), amount);\n pools[i].notifyRewardAmount(amount);\n\n emit Distributed(address(pools[i]), amount);\n }\n\n once = false;\n }\n}\n" }, "contracts/distribution/BACDAIPool.sol": { "content": "pragma solidity ^0.6.0;\n/**\n *Submitted for verification at Etherscan.io on 2020-07-17\n */\n\n/*\n ____ __ __ __ _\n / __/__ __ ___ / /_ / / ___ / /_ (_)__ __\n _\\ \\ / // // _ \\/ __// _ \\/ -_)/ __// / \\ \\ /\n/___/ \\_, //_//_/\\__//_//_/\\__/ \\__//_/ /_\\_\\\n /___/\n\n* Synthetix: BASISCASHRewards.sol\n*\n* Docs: https://docs.synthetix.io/\n*\n*\n* MIT License\n* ===========\n*\n* Copyright (c) 2020 Synthetix\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is\n* furnished to do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n*/\n\n// File: @openzeppelin/contracts/math/Math.sol\n\nimport '@openzeppelin/contracts/math/Math.sol';\n\n// File: @openzeppelin/contracts/math/SafeMath.sol\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/IERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\n// File: @openzeppelin/contracts/utils/Address.sol\n\nimport '@openzeppelin/contracts/utils/Address.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';\n\n// File: contracts/IRewardDistributionRecipient.sol\n\nimport '../interfaces/IRewardDistributionRecipient.sol';\n\ncontract DAIWrapper {\n using SafeMath for uint256;\n using SafeERC20 for IERC20;\n\n IERC20 public dai;\n\n uint256 private _totalSupply;\n mapping(address => uint256) private _balances;\n\n function totalSupply() public view returns (uint256) {\n return _totalSupply;\n }\n\n function balanceOf(address account) public view returns (uint256) {\n return _balances[account];\n }\n\n function stake(uint256 amount) public virtual {\n _totalSupply = _totalSupply.add(amount);\n _balances[msg.sender] = _balances[msg.sender].add(amount);\n dai.safeTransferFrom(msg.sender, address(this), amount);\n }\n\n function withdraw(uint256 amount) public virtual {\n _totalSupply = _totalSupply.sub(amount);\n _balances[msg.sender] = _balances[msg.sender].sub(amount);\n dai.safeTransfer(msg.sender, amount);\n }\n}\n\ncontract BACDAIPool is DAIWrapper, IRewardDistributionRecipient {\n IERC20 public basisCash;\n uint256 public DURATION = 5 days;\n\n uint256 public starttime;\n uint256 public periodFinish = 0;\n uint256 public rewardRate = 0;\n uint256 public lastUpdateTime;\n uint256 public rewardPerTokenStored;\n mapping(address => uint256) public userRewardPerTokenPaid;\n mapping(address => uint256) public rewards;\n mapping(address => uint256) public deposits;\n\n event RewardAdded(uint256 reward);\n event Staked(address indexed user, uint256 amount);\n event Withdrawn(address indexed user, uint256 amount);\n event RewardPaid(address indexed user, uint256 reward);\n\n constructor(\n address basisCash_,\n address dai_,\n uint256 starttime_\n ) public {\n basisCash = IERC20(basisCash_);\n dai = IERC20(dai_);\n starttime = starttime_;\n }\n\n modifier checkStart() {\n require(block.timestamp >= starttime, 'BACDAIPool: not start');\n _;\n }\n\n modifier updateReward(address account) {\n rewardPerTokenStored = rewardPerToken();\n lastUpdateTime = lastTimeRewardApplicable();\n if (account != address(0)) {\n rewards[account] = earned(account);\n userRewardPerTokenPaid[account] = rewardPerTokenStored;\n }\n _;\n }\n\n function lastTimeRewardApplicable() public view returns (uint256) {\n return Math.min(block.timestamp, periodFinish);\n }\n\n function rewardPerToken() public view returns (uint256) {\n if (totalSupply() == 0) {\n return rewardPerTokenStored;\n }\n return\n rewardPerTokenStored.add(\n lastTimeRewardApplicable()\n .sub(lastUpdateTime)\n .mul(rewardRate)\n .mul(1e18)\n .div(totalSupply())\n );\n }\n\n function earned(address account) public view returns (uint256) {\n return\n balanceOf(account)\n .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))\n .div(1e18)\n .add(rewards[account]);\n }\n\n // stake visibility is public as overriding LPTokenWrapper's stake() function\n function stake(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'BACDAIPool: Cannot stake 0');\n uint256 newDeposit = deposits[msg.sender].add(amount);\n require(\n newDeposit <= 20000e18,\n 'BACDAIPool: deposit amount exceeds maximum 20000'\n );\n deposits[msg.sender] = newDeposit;\n super.stake(amount);\n emit Staked(msg.sender, amount);\n }\n\n function withdraw(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'BACDAIPool: Cannot withdraw 0');\n deposits[msg.sender] = deposits[msg.sender].sub(amount);\n super.withdraw(amount);\n emit Withdrawn(msg.sender, amount);\n }\n\n function exit() external {\n withdraw(balanceOf(msg.sender));\n getReward();\n }\n\n function getReward() public updateReward(msg.sender) checkStart {\n uint256 reward = earned(msg.sender);\n if (reward > 0) {\n rewards[msg.sender] = 0;\n basisCash.safeTransfer(msg.sender, reward);\n emit RewardPaid(msg.sender, reward);\n }\n }\n\n function notifyRewardAmount(uint256 reward)\n external\n override\n onlyRewardDistribution\n updateReward(address(0))\n {\n if (block.timestamp > starttime) {\n if (block.timestamp >= periodFinish) {\n rewardRate = reward.div(DURATION);\n } else {\n uint256 remaining = periodFinish.sub(block.timestamp);\n uint256 leftover = remaining.mul(rewardRate);\n rewardRate = reward.add(leftover).div(DURATION);\n }\n lastUpdateTime = block.timestamp;\n periodFinish = block.timestamp.add(DURATION);\n emit RewardAdded(reward);\n } else {\n rewardRate = reward.div(DURATION);\n lastUpdateTime = starttime;\n periodFinish = starttime.add(DURATION);\n emit RewardAdded(reward);\n }\n }\n}\n" }, "contracts/distribution/BACSUSDPool.sol": { "content": "pragma solidity ^0.6.0;\n/**\n *Submitted for verification at Etherscan.io on 2020-07-17\n */\n\n/*\n ____ __ __ __ _\n / __/__ __ ___ / /_ / / ___ / /_ (_)__ __\n _\\ \\ / // // _ \\/ __// _ \\/ -_)/ __// / \\ \\ /\n/___/ \\_, //_//_/\\__//_//_/\\__/ \\__//_/ /_\\_\\\n /___/\n\n* Synthetix: BASISCASHRewards.sol\n*\n* Docs: https://docs.synthetix.io/\n*\n*\n* MIT License\n* ===========\n*\n* Copyright (c) 2020 Synthetix\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is\n* furnished to do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n*/\n\n// File: @openzeppelin/contracts/math/Math.sol\n\nimport '@openzeppelin/contracts/math/Math.sol';\n\n// File: @openzeppelin/contracts/math/SafeMath.sol\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/IERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\n// File: @openzeppelin/contracts/utils/Address.sol\n\nimport '@openzeppelin/contracts/utils/Address.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';\n\n// File: contracts/IRewardDistributionRecipient.sol\n\nimport '../interfaces/IRewardDistributionRecipient.sol';\n\ncontract SUSDWrapper {\n using SafeMath for uint256;\n using SafeERC20 for IERC20;\n\n IERC20 public SUSD;\n\n uint256 private _totalSupply;\n mapping(address => uint256) private _balances;\n\n function totalSupply() public view returns (uint256) {\n return _totalSupply;\n }\n\n function balanceOf(address account) public view returns (uint256) {\n return _balances[account];\n }\n\n function stake(uint256 amount) public virtual {\n _totalSupply = _totalSupply.add(amount);\n _balances[msg.sender] = _balances[msg.sender].add(amount);\n SUSD.safeTransferFrom(msg.sender, address(this), amount);\n }\n\n function withdraw(uint256 amount) public virtual {\n _totalSupply = _totalSupply.sub(amount);\n _balances[msg.sender] = _balances[msg.sender].sub(amount);\n SUSD.safeTransfer(msg.sender, amount);\n }\n}\n\ncontract BACSUSDPool is SUSDWrapper, IRewardDistributionRecipient {\n IERC20 public basisCash;\n uint256 public DURATION = 5 days;\n\n uint256 public starttime;\n uint256 public periodFinish = 0;\n uint256 public rewardRate = 0;\n uint256 public lastUpdateTime;\n uint256 public rewardPerTokenStored;\n mapping(address => uint256) public userRewardPerTokenPaid;\n mapping(address => uint256) public rewards;\n mapping(address => uint256) public deposits;\n\n event RewardAdded(uint256 reward);\n event Staked(address indexed user, uint256 amount);\n event Withdrawn(address indexed user, uint256 amount);\n event RewardPaid(address indexed user, uint256 reward);\n\n constructor(\n address basisCash_,\n address susd_,\n uint256 starttime_\n ) public {\n basisCash = IERC20(basisCash_);\n SUSD = IERC20(susd_);\n starttime = starttime_;\n }\n\n modifier checkStart() {\n require(block.timestamp >= starttime, 'BACSUSDPool: not start');\n _;\n }\n\n modifier updateReward(address account) {\n rewardPerTokenStored = rewardPerToken();\n lastUpdateTime = lastTimeRewardApplicable();\n if (account != address(0)) {\n rewards[account] = earned(account);\n userRewardPerTokenPaid[account] = rewardPerTokenStored;\n }\n _;\n }\n\n function lastTimeRewardApplicable() public view returns (uint256) {\n return Math.min(block.timestamp, periodFinish);\n }\n\n function rewardPerToken() public view returns (uint256) {\n if (totalSupply() == 0) {\n return rewardPerTokenStored;\n }\n return\n rewardPerTokenStored.add(\n lastTimeRewardApplicable()\n .sub(lastUpdateTime)\n .mul(rewardRate)\n .mul(1e18)\n .div(totalSupply())\n );\n }\n\n function earned(address account) public view returns (uint256) {\n return\n balanceOf(account)\n .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))\n .div(1e18)\n .add(rewards[account]);\n }\n\n // stake visibility is public as overriding LPTokenWrapper's stake() function\n function stake(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'BACSUSDPool: Cannot stake 0');\n uint256 newDeposit = deposits[msg.sender].add(amount);\n require(\n newDeposit <= 20000e18,\n 'BACSUSDPool: deposit amount exceeds maximum 20000'\n );\n deposits[msg.sender] = newDeposit;\n super.stake(amount);\n emit Staked(msg.sender, amount);\n }\n\n function withdraw(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'BACSUSDPool: Cannot withdraw 0');\n deposits[msg.sender] = deposits[msg.sender].sub(amount);\n super.withdraw(amount);\n emit Withdrawn(msg.sender, amount);\n }\n\n function exit() external {\n withdraw(balanceOf(msg.sender));\n getReward();\n }\n\n function getReward() public updateReward(msg.sender) checkStart {\n uint256 reward = earned(msg.sender);\n if (reward > 0) {\n rewards[msg.sender] = 0;\n basisCash.safeTransfer(msg.sender, reward);\n emit RewardPaid(msg.sender, reward);\n }\n }\n\n function notifyRewardAmount(uint256 reward)\n external\n override\n onlyRewardDistribution\n updateReward(address(0))\n {\n if (block.timestamp > starttime) {\n if (block.timestamp >= periodFinish) {\n rewardRate = reward.div(DURATION);\n } else {\n uint256 remaining = periodFinish.sub(block.timestamp);\n uint256 leftover = remaining.mul(rewardRate);\n rewardRate = reward.add(leftover).div(DURATION);\n }\n lastUpdateTime = block.timestamp;\n periodFinish = block.timestamp.add(DURATION);\n emit RewardAdded(reward);\n } else {\n rewardRate = reward.div(DURATION);\n lastUpdateTime = starttime;\n periodFinish = starttime.add(DURATION);\n emit RewardAdded(reward);\n }\n }\n}\n" }, "contracts/distribution/BACUSDCPool.sol": { "content": "pragma solidity ^0.6.0;\n/**\n *Submitted for verification at Etherscan.io on 2020-07-17\n */\n\n/*\n ____ __ __ __ _\n / __/__ __ ___ / /_ / / ___ / /_ (_)__ __\n _\\ \\ / // // _ \\/ __// _ \\/ -_)/ __// / \\ \\ /\n/___/ \\_, //_//_/\\__//_//_/\\__/ \\__//_/ /_\\_\\\n /___/\n\n* Synthetix: BASISCASHRewards.sol\n*\n* Docs: https://docs.synthetix.io/\n*\n*\n* MIT License\n* ===========\n*\n* Copyright (c) 2020 Synthetix\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is\n* furnished to do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n*/\n\n// File: @openzeppelin/contracts/math/Math.sol\n\nimport '@openzeppelin/contracts/math/Math.sol';\n\n// File: @openzeppelin/contracts/math/SafeMath.sol\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/IERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\n// File: @openzeppelin/contracts/utils/Address.sol\n\nimport '@openzeppelin/contracts/utils/Address.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';\n\n// File: contracts/IRewardDistributionRecipient.sol\n\nimport '../interfaces/IRewardDistributionRecipient.sol';\n\ncontract USDCWrapper {\n using SafeMath for uint256;\n using SafeERC20 for IERC20;\n\n IERC20 public usdc;\n\n uint256 private _totalSupply;\n mapping(address => uint256) private _balances;\n\n function totalSupply() public view returns (uint256) {\n return _totalSupply;\n }\n\n function balanceOf(address account) public view returns (uint256) {\n return _balances[account];\n }\n\n function stake(uint256 amount) public virtual {\n _totalSupply = _totalSupply.add(amount);\n _balances[msg.sender] = _balances[msg.sender].add(amount);\n usdc.safeTransferFrom(msg.sender, address(this), amount);\n }\n\n function withdraw(uint256 amount) public virtual {\n _totalSupply = _totalSupply.sub(amount);\n _balances[msg.sender] = _balances[msg.sender].sub(amount);\n usdc.safeTransfer(msg.sender, amount);\n }\n}\n\ncontract BACUSDCPool is USDCWrapper, IRewardDistributionRecipient {\n IERC20 public basisCash;\n uint256 public DURATION = 5 days;\n\n uint256 public starttime;\n uint256 public periodFinish = 0;\n uint256 public rewardRate = 0;\n uint256 public lastUpdateTime;\n uint256 public rewardPerTokenStored;\n mapping(address => uint256) public userRewardPerTokenPaid;\n mapping(address => uint256) public rewards;\n mapping(address => uint256) public deposits;\n\n event RewardAdded(uint256 reward);\n event Staked(address indexed user, uint256 amount);\n event Withdrawn(address indexed user, uint256 amount);\n event RewardPaid(address indexed user, uint256 reward);\n\n constructor(\n address basisCash_,\n address usdc_,\n uint256 starttime_\n ) public {\n basisCash = IERC20(basisCash_);\n usdc = IERC20(usdc_);\n starttime = starttime_;\n }\n\n modifier checkStart() {\n require(block.timestamp >= starttime, 'BACUSDCPool: not start');\n _;\n }\n\n modifier updateReward(address account) {\n rewardPerTokenStored = rewardPerToken();\n lastUpdateTime = lastTimeRewardApplicable();\n if (account != address(0)) {\n rewards[account] = earned(account);\n userRewardPerTokenPaid[account] = rewardPerTokenStored;\n }\n _;\n }\n\n function lastTimeRewardApplicable() public view returns (uint256) {\n return Math.min(block.timestamp, periodFinish);\n }\n\n function rewardPerToken() public view returns (uint256) {\n if (totalSupply() == 0) {\n return rewardPerTokenStored;\n }\n return\n rewardPerTokenStored.add(\n lastTimeRewardApplicable()\n .sub(lastUpdateTime)\n .mul(rewardRate)\n .mul(1e18)\n .div(totalSupply())\n );\n }\n\n function earned(address account) public view returns (uint256) {\n return\n balanceOf(account)\n .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))\n .div(1e18)\n .add(rewards[account]);\n }\n\n // stake visibility is public as overriding LPTokenWrapper's stake() function\n function stake(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'BACUSDCPool: Cannot stake 0');\n uint256 newDeposit = deposits[msg.sender].add(amount);\n require(\n newDeposit <= 20000e6,\n 'BACUSDCPool: deposit amount exceeds maximum 20000'\n );\n deposits[msg.sender] = newDeposit;\n super.stake(amount);\n emit Staked(msg.sender, amount);\n }\n\n function withdraw(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'BACUSDCPool: Cannot withdraw 0');\n deposits[msg.sender] = deposits[msg.sender].sub(amount);\n super.withdraw(amount);\n emit Withdrawn(msg.sender, amount);\n }\n\n function exit() external {\n withdraw(balanceOf(msg.sender));\n getReward();\n }\n\n function getReward() public updateReward(msg.sender) checkStart {\n uint256 reward = earned(msg.sender);\n if (reward > 0) {\n rewards[msg.sender] = 0;\n basisCash.safeTransfer(msg.sender, reward);\n emit RewardPaid(msg.sender, reward);\n }\n }\n\n function notifyRewardAmount(uint256 reward)\n external\n override\n onlyRewardDistribution\n updateReward(address(0))\n {\n if (block.timestamp > starttime) {\n if (block.timestamp >= periodFinish) {\n rewardRate = reward.div(DURATION);\n } else {\n uint256 remaining = periodFinish.sub(block.timestamp);\n uint256 leftover = remaining.mul(rewardRate);\n rewardRate = reward.add(leftover).div(DURATION);\n }\n lastUpdateTime = block.timestamp;\n periodFinish = block.timestamp.add(DURATION);\n emit RewardAdded(reward);\n } else {\n rewardRate = reward.div(DURATION);\n lastUpdateTime = starttime;\n periodFinish = starttime.add(DURATION);\n emit RewardAdded(reward);\n }\n }\n}\n" }, "contracts/distribution/BACUSDTPool.sol": { "content": "pragma solidity ^0.6.0;\n/**\n *Submitted for verification at Etherscan.io on 2020-07-17\n */\n\n/*\n ____ __ __ __ _\n / __/__ __ ___ / /_ / / ___ / /_ (_)__ __\n _\\ \\ / // // _ \\/ __// _ \\/ -_)/ __// / \\ \\ /\n/___/ \\_, //_//_/\\__//_//_/\\__/ \\__//_/ /_\\_\\\n /___/\n\n* Synthetix: BASISCASHRewards.sol\n*\n* Docs: https://docs.synthetix.io/\n*\n*\n* MIT License\n* ===========\n*\n* Copyright (c) 2020 Synthetix\n*\n* Permission is hereby granted, free of charge, to any person obtaining a copy\n* of this software and associated documentation files (the \"Software\"), to deal\n* in the Software without restriction, including without limitation the rights\n* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the Software is\n* furnished to do so, subject to the following conditions:\n*\n* The above copyright notice and this permission notice shall be included in all\n* copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n*/\n\n// File: @openzeppelin/contracts/math/Math.sol\n\nimport '@openzeppelin/contracts/math/Math.sol';\n\n// File: @openzeppelin/contracts/math/SafeMath.sol\n\nimport '@openzeppelin/contracts/math/SafeMath.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/IERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\n// File: @openzeppelin/contracts/utils/Address.sol\n\nimport '@openzeppelin/contracts/utils/Address.sol';\n\n// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol\n\nimport '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';\n\n// File: contracts/IRewardDistributionRecipient.sol\n\nimport '../interfaces/IRewardDistributionRecipient.sol';\n\ncontract USDTWrapper {\n using SafeMath for uint256;\n using SafeERC20 for IERC20;\n\n IERC20 public usdt;\n\n uint256 private _totalSupply;\n mapping(address => uint256) private _balances;\n\n function totalSupply() public view returns (uint256) {\n return _totalSupply;\n }\n\n function balanceOf(address account) public view returns (uint256) {\n return _balances[account];\n }\n\n function stake(uint256 amount) public virtual {\n _totalSupply = _totalSupply.add(amount);\n _balances[msg.sender] = _balances[msg.sender].add(amount);\n usdt.safeTransferFrom(msg.sender, address(this), amount);\n }\n\n function withdraw(uint256 amount) public virtual {\n _totalSupply = _totalSupply.sub(amount);\n _balances[msg.sender] = _balances[msg.sender].sub(amount);\n usdt.safeTransfer(msg.sender, amount);\n }\n}\n\ncontract BACUSDTPool is USDTWrapper, IRewardDistributionRecipient {\n IERC20 public basisCash;\n uint256 public DURATION = 5 days;\n\n uint256 public starttime;\n uint256 public periodFinish = 0;\n uint256 public rewardRate = 0;\n uint256 public lastUpdateTime;\n uint256 public rewardPerTokenStored;\n mapping(address => uint256) public userRewardPerTokenPaid;\n mapping(address => uint256) public rewards;\n mapping(address => uint256) public deposits;\n\n event RewardAdded(uint256 reward);\n event Staked(address indexed user, uint256 amount);\n event Withdrawn(address indexed user, uint256 amount);\n event RewardPaid(address indexed user, uint256 reward);\n\n constructor(\n address basisCash_,\n address usdt_,\n uint256 starttime_\n ) public {\n basisCash = IERC20(basisCash_);\n usdt = IERC20(usdt_);\n starttime = starttime_;\n }\n\n modifier checkStart() {\n require(block.timestamp >= starttime, 'BACUSDTPool: not start');\n _;\n }\n\n modifier updateReward(address account) {\n rewardPerTokenStored = rewardPerToken();\n lastUpdateTime = lastTimeRewardApplicable();\n if (account != address(0)) {\n rewards[account] = earned(account);\n userRewardPerTokenPaid[account] = rewardPerTokenStored;\n }\n _;\n }\n\n function lastTimeRewardApplicable() public view returns (uint256) {\n return Math.min(block.timestamp, periodFinish);\n }\n\n function rewardPerToken() public view returns (uint256) {\n if (totalSupply() == 0) {\n return rewardPerTokenStored;\n }\n return\n rewardPerTokenStored.add(\n lastTimeRewardApplicable()\n .sub(lastUpdateTime)\n .mul(rewardRate)\n .mul(1e18)\n .div(totalSupply())\n );\n }\n\n function earned(address account) public view returns (uint256) {\n return\n balanceOf(account)\n .mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))\n .div(1e18)\n .add(rewards[account]);\n }\n\n // stake visibility is public as overriding LPTokenWrapper's stake() function\n function stake(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'BACUSDTPool: Cannot stake 0');\n uint256 newDeposit = deposits[msg.sender].add(amount);\n require(\n newDeposit <= 20000e6,\n 'BACUSDTPool: deposit amount exceeds maximum 20000'\n );\n deposits[msg.sender] = newDeposit;\n super.stake(amount);\n emit Staked(msg.sender, amount);\n }\n\n function withdraw(uint256 amount)\n public\n override\n updateReward(msg.sender)\n checkStart\n {\n require(amount > 0, 'BACUSDTPool: Cannot withdraw 0');\n deposits[msg.sender] = deposits[msg.sender].sub(amount);\n super.withdraw(amount);\n emit Withdrawn(msg.sender, amount);\n }\n\n function exit() external {\n withdraw(balanceOf(msg.sender));\n getReward();\n }\n\n function getReward() public updateReward(msg.sender) checkStart {\n uint256 reward = earned(msg.sender);\n if (reward > 0) {\n rewards[msg.sender] = 0;\n basisCash.safeTransfer(msg.sender, reward);\n emit RewardPaid(msg.sender, reward);\n }\n }\n\n function notifyRewardAmount(uint256 reward)\n external\n override\n onlyRewardDistribution\n updateReward(address(0))\n {\n if (block.timestamp > starttime) {\n if (block.timestamp >= periodFinish) {\n rewardRate = reward.div(DURATION);\n } else {\n uint256 remaining = periodFinish.sub(block.timestamp);\n uint256 leftover = remaining.mul(rewardRate);\n rewardRate = reward.add(leftover).div(DURATION);\n }\n lastUpdateTime = block.timestamp;\n periodFinish = block.timestamp.add(DURATION);\n emit RewardAdded(reward);\n } else {\n rewardRate = reward.div(DURATION);\n lastUpdateTime = starttime;\n periodFinish = starttime.add(DURATION);\n emit RewardAdded(reward);\n }\n }\n}\n" }, "contracts/Distributor.sol": { "content": "pragma solidity ^0.6.0;\n\nimport './interfaces/IDistributor.sol';\n\ncontract Distributor {\n IDistributor[] public distributors;\n\n constructor(IDistributor[] memory _distributors) public {\n distributors = _distributors;\n }\n\n function distribute() public {\n for (uint256 i = 0; i < distributors.length; i++) {\n distributors[i].distribute();\n }\n }\n}\n" }, "@openzeppelin/contracts/token/ERC20/ERC20.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\nimport \"../../GSN/Context.sol\";\nimport \"./IERC20.sol\";\nimport \"../../math/SafeMath.sol\";\nimport \"../../utils/Address.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20 {\n using SafeMath for uint256;\n using Address for address;\n\n mapping (address => uint256) private _balances;\n\n mapping (address => mapping (address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n uint8 private _decimals;\n\n /**\n * @dev Sets the values for {name} and {symbol}, initializes {decimals} with\n * a default value of 18.\n *\n * To select a different value for {decimals}, use {_setupDecimals}.\n *\n * All three of these values are immutable: they can only be set once during\n * construction.\n */\n constructor (string memory name, string memory symbol) public {\n _name = name;\n _symbol = symbol;\n _decimals = 18;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is\n * called.\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view returns (uint8) {\n return _decimals;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20};\n *\n * Requirements:\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for ``sender``'s tokens of at least\n * `amount`.\n */\n function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \"ERC20: transfer amount exceeds allowance\"));\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \"ERC20: decreased allowance below zero\"));\n return true;\n }\n\n /**\n * @dev Moves tokens `amount` from `sender` to `recipient`.\n *\n * This is internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n _balances[sender] = _balances[sender].sub(amount, \"ERC20: transfer amount exceeds balance\");\n _balances[recipient] = _balances[recipient].add(amount);\n emit Transfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements\n *\n * - `to` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply = _totalSupply.add(amount);\n _balances[account] = _balances[account].add(amount);\n emit Transfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n _balances[account] = _balances[account].sub(amount, \"ERC20: burn amount exceeds balance\");\n _totalSupply = _totalSupply.sub(amount);\n emit Transfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Sets {decimals} to a value other than the default one of 18.\n *\n * WARNING: This function should only be called from the constructor. Most\n * applications that interact with token contracts will not expect\n * {decimals} to ever change, and may work incorrectly if it does.\n */\n function _setupDecimals(uint8 decimals_) internal {\n _decimals = decimals_;\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be to transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n}\n" }, "@openzeppelin/contracts/token/ERC20/ERC20Burnable.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\nimport \"../../GSN/Context.sol\";\nimport \"./ERC20.sol\";\n\n/**\n * @dev Extension of {ERC20} that allows token holders to destroy both their own\n * tokens and those that they have an allowance for, in a way that can be\n * recognized off-chain (via event analysis).\n */\nabstract contract ERC20Burnable is Context, ERC20 {\n /**\n * @dev Destroys `amount` tokens from the caller.\n *\n * See {ERC20-_burn}.\n */\n function burn(uint256 amount) public virtual {\n _burn(_msgSender(), amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, deducting from the caller's\n * allowance.\n *\n * See {ERC20-_burn} and {ERC20-allowance}.\n *\n * Requirements:\n *\n * - the caller must have allowance for ``accounts``'s tokens of at least\n * `amount`.\n */\n function burnFrom(address account, uint256 amount) public virtual {\n uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, \"ERC20: burn amount exceeds allowance\");\n\n _approve(account, _msgSender(), decreasedAllowance);\n _burn(account, amount);\n }\n}\n" }, "contracts/test/MockDai.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '@openzeppelin/contracts/token/ERC20/ERC20Burnable.sol';\nimport '../owner/Operator.sol';\n\ncontract MockDai is ERC20Burnable, Operator {\n /**\n * @notice Constructs the Basis Cash ERC-20 contract.\n */\n constructor() public ERC20('DAI', 'DAI') {\n _mint(msg.sender, 10000 * 10**18);\n }\n\n /**\n * @notice Operator mints dino cash to a recipient\n * @param recipient_ The address of recipient\n * @param amount_ The amount of dino cash to mint to\n * @return whether the process has been done\n */\n function mint(address recipient_, uint256 amount_)\n public\n onlyOperator\n returns (bool)\n {\n uint256 balanceBefore = balanceOf(recipient_);\n _mint(recipient_, amount_);\n uint256 balanceAfter = balanceOf(recipient_);\n\n return balanceAfter > balanceBefore;\n }\n}\n" }, "contracts/Share.sol": { "content": "pragma solidity ^0.6.0;\n\nimport './owner/Operator.sol';\nimport '@openzeppelin/contracts/token/ERC20/ERC20Burnable.sol';\n\ncontract Share is ERC20Burnable, Operator {\n constructor() public ERC20('BAS', 'BAS') {\n // Mints 1 Basis Share to contract creator for initial Uniswap oracle deployment.\n // Will be burned after oracle deployment\n _mint(msg.sender, 1 * 10**18);\n }\n\n /**\n * @notice Operator mints basis cash to a recipient\n * @param recipient_ The address of recipient\n * @param amount_ The amount of basis cash to mint to\n */\n function mint(address recipient_, uint256 amount_)\n public\n onlyOperator\n returns (bool)\n {\n uint256 balanceBefore = balanceOf(recipient_);\n _mint(recipient_, amount_);\n uint256 balanceAfter = balanceOf(recipient_);\n return balanceAfter >= balanceBefore;\n }\n\n function burn(uint256 amount) public override onlyOperator {\n super.burn(amount);\n }\n\n function burnFrom(address account, uint256 amount)\n public\n override\n onlyOperator\n {\n super.burnFrom(account, amount);\n }\n}\n" }, "contracts/Cash.sol": { "content": "pragma solidity ^0.6.0;\n\nimport '@openzeppelin/contracts/token/ERC20/ERC20Burnable.sol';\nimport './owner/Operator.sol';\n\ncontract Cash is ERC20Burnable, Operator {\n /**\n * @notice Constructs the Basis Cash ERC-20 contract.\n */\n constructor() public ERC20('BAC', 'BAC') {\n // Mints 1 Basis Cash to contract creator for initial Uniswap oracle deployment.\n // Will be burned after oracle deployment\n _mint(msg.sender, 1 * 10**18);\n }\n\n // function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {\n // super._beforeTokenTransfer(from, to, amount);\n // require(\n // to != operator(),\n // \"basis.cash: operator as a recipient is not allowed\"\n // );\n // }\n\n /**\n * @notice Operator mints basis cash to a recipient\n * @param recipient_ The address of recipient\n * @param amount_ The amount of basis cash to mint to\n * @return whether the process has been done\n */\n function mint(address recipient_, uint256 amount_)\n public\n onlyOperator\n returns (bool)\n {\n uint256 balanceBefore = balanceOf(recipient_);\n _mint(recipient_, amount_);\n uint256 balanceAfter = balanceOf(recipient_);\n\n return balanceAfter > balanceBefore;\n }\n\n function burn(uint256 amount) public override onlyOperator {\n super.burn(amount);\n }\n\n function burnFrom(address account, uint256 amount)\n public\n override\n onlyOperator\n {\n super.burnFrom(account, amount);\n }\n}\n" }, "contracts/Bond.sol": { "content": "pragma solidity ^0.6.0;\n\nimport './owner/Operator.sol';\nimport '@openzeppelin/contracts/token/ERC20/ERC20Burnable.sol';\n\ncontract Bond is ERC20Burnable, Ownable, Operator {\n /**\n * @notice Constructs the Basis Bond ERC-20 contract.\n */\n constructor() public ERC20('BAB', 'BAB') {}\n\n /**\n * @notice Operator mints basis bonds to a recipient\n * @param recipient_ The address of recipient\n * @param amount_ The amount of basis bonds to mint to\n * @return whether the process has been done\n */\n function mint(address recipient_, uint256 amount_)\n public\n onlyOperator\n returns (bool)\n {\n uint256 balanceBefore = balanceOf(recipient_);\n _mint(recipient_, amount_);\n uint256 balanceAfter = balanceOf(recipient_);\n\n return balanceAfter > balanceBefore;\n }\n\n function burn(uint256 amount) public override onlyOperator {\n super.burn(amount);\n }\n\n function burnFrom(address account, uint256 amount)\n public\n override\n onlyOperator\n {\n super.burnFrom(account, amount);\n }\n}\n" }, "contracts/interfaces/IUniswapV2Callee.sol": { "content": "pragma solidity ^0.6.0;\n\ninterface IUniswapV2Callee {\n function uniswapV2Call(\n address sender,\n uint256 amount0,\n uint256 amount1,\n bytes calldata data\n ) external;\n}\n" }, "contracts/interfaces/IUniswapV2ERC20.sol": { "content": "pragma solidity ^0.6.0;\n\ninterface IUniswapV2ERC20 {\n event Approval(\n address indexed owner,\n address indexed spender,\n uint256 value\n );\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n function name() external pure returns (string memory);\n\n function symbol() external pure returns (string memory);\n\n function decimals() external pure returns (uint8);\n\n function totalSupply() external view returns (uint256);\n\n function balanceOf(address owner) external view returns (uint256);\n\n function allowance(address owner, address spender)\n external\n view\n returns (uint256);\n\n function approve(address spender, uint256 value) external returns (bool);\n\n function transfer(address to, uint256 value) external returns (bool);\n\n function transferFrom(\n address from,\n address to,\n uint256 value\n ) external returns (bool);\n\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n\n function PERMIT_TYPEHASH() external pure returns (bytes32);\n\n function nonces(address owner) external view returns (uint256);\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" }, "contracts/Migrations.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.8.0;\n\ncontract Migrations {\n address public owner;\n uint256 public last_completed_migration;\n\n constructor() public {\n owner = msg.sender;\n }\n\n modifier restricted() {\n if (msg.sender == owner) _;\n }\n\n function setCompleted(uint256 completed) public restricted {\n last_completed_migration = completed;\n }\n}\n" } }, "settings": { "optimizer": { "enabled": false, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "libraries": {} } }}

Basis Cash

Start building on QuickNode

Source code: