🌳 Add TrueUSDWithPoR contract to contracts-por (#1195)

Author: Michał Sieczkowski

packages/contracts-por/.compiler.json

@@ -1,5 +1,5 @@
 {
-    "version": "0.8.16",
+    "version": "0.6.10",
     "settings": {
         "optimizer": {
             "enabled": true,

packages/contracts-por/contracts/DummyContract.sol

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.6.10;
+
+import {BurnableTokenWithBounds} from "./common/BurnableTokenWithBounds.sol";
+
+/**
+ * @title TrueCurrency
+ * @dev TrueCurrency is an ERC20 with blacklist & redemption addresses
+ *
+ * TrueCurrency is a compliant stablecoin with blacklist and redemption
+ * addresses. Only the owner can blacklist accounts. Redemption addresses
+ * are assigned automatically to the first 0x100000 addresses. Sending
+ * tokens to the redemption address will trigger a burn operation. Only
+ * the owner can mint or blacklist accounts.
+ *
+ * This contract is owned by the TokenController, which manages token
+ * minting & admin functionality. See TokenController.sol
+ *
+ * See also: BurnableTokenWithBounds.sol
+ *
+ * ~~~~ Features ~~~~
+ *
+ * Redemption Addresses
+ * - The first 0x100000 addresses are redemption addresses
+ * - Tokens sent to redemption addresses are burned
+ * - Redemptions are tracked off-chain
+ * - Cannot mint tokens to redemption addresses
+ *
+ * Blacklist
+ * - Owner can blacklist accounts in accordance with local regulatory bodies
+ * - Only a court order will merit a blacklist; blacklisting is extremely rare
+ *
+ * Burn Bounds & CanBurn
+ * - Owner can set min & max burn amounts
+ * - Only accounts flagged in canBurn are allowed to burn tokens
+ * - canBurn prevents tokens from being sent to the incorrect address
+ *
+ * Reclaimer Token
+ * - ERC20 Tokens and Ether sent to this contract can be reclaimed by the owner
+ */
+abstract contract TrueCurrency is BurnableTokenWithBounds {
+    uint256 constant CENT = 10**16;
+    uint256 constant REDEMPTION_ADDRESS_COUNT = 0x100000;
+
+    /**
+     * @dev Emitted when account blacklist status changes
+     */
+    event Blacklisted(address indexed account, bool isBlacklisted);
+
+    /**
+     * @dev Emitted when `value` tokens are minted for `to`
+     * @param to address to mint tokens for
+     * @param value amount of tokens to be minted
+     */
+    event Mint(address indexed to, uint256 value);
+
+    /**
+     * @dev Creates `amount` tokens and assigns them to `account`, increasing
+     * the total supply.
+     * @param account address to mint tokens for
+     * @param amount amount of tokens to be minted
+     *
+     * Emits a {Mint} event
+     *
+     * Requirements
+     *
+     * - `account` cannot be the zero address.
+     * - `account` cannot be blacklisted.
+     * - `account` cannot be a redemption address.
+     */
+    function mint(address account, uint256 amount) external onlyOwner {
+        require(!isBlacklisted[account], "TrueCurrency: account is blacklisted");
+        require(!isRedemptionAddress(account), "TrueCurrency: account is a redemption address");
+        _mint(account, amount);
+        emit Mint(account, amount);
+    }
+
+    /**
+     * @dev Set blacklisted status for the account.
+     * @param account address to set blacklist flag for
+     * @param _isBlacklisted blacklist flag value
+     *
+     * Requirements:
+     *
+     * - `msg.sender` should be owner.
+     */
+    function setBlacklisted(address account, bool _isBlacklisted) external onlyOwner {
+        require(uint256(account) >= REDEMPTION_ADDRESS_COUNT, "TrueCurrency: blacklisting of redemption address is not allowed");
+        isBlacklisted[account] = _isBlacklisted;
+        emit Blacklisted(account, _isBlacklisted);
+    }
+
+    /**
+     * @dev Set canBurn status for the account.
+     * @param account address to set canBurn flag for
+     * @param _canBurn canBurn flag value
+     *
+     * Requirements:
+     *
+     * - `msg.sender` should be owner.
+     */
+    function setCanBurn(address account, bool _canBurn) external onlyOwner {
+        canBurn[account] = _canBurn;
+    }
+
+    /**
+     * @dev Check if neither account is blacklisted before performing transfer
+     * If transfer recipient is a redemption address, burns tokens
+     * @notice Transfer to redemption address will burn tokens with a 1 cent precision
+     * @param sender address of sender
+     * @param recipient address of recipient
+     * @param amount amount of tokens to transfer
+     */
+    function _transfer(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) internal virtual override {
+        require(!isBlacklisted[sender], "TrueCurrency: sender is blacklisted");
+        require(!isBlacklisted[recipient], "TrueCurrency: recipient is blacklisted");
+
+        if (isRedemptionAddress(recipient)) {
+            super._transfer(sender, recipient, amount.sub(amount.mod(CENT)));
+            _burn(recipient, amount.sub(amount.mod(CENT)));
+        } else {
+            super._transfer(sender, recipient, amount);
+        }
+    }
+
+    /**
+     * @dev Requere neither accounts to be blacklisted before approval
+     * @param owner address of owner giving approval
+     * @param spender address of spender to approve for
+     * @param amount amount of tokens to approve
+     */
+    function _approve(
+        address owner,
+        address spender,
+        uint256 amount
+    ) internal override {
+        require(!isBlacklisted[owner], "TrueCurrency: tokens owner is blacklisted");
+        require(!isBlacklisted[spender] || amount == 0, "TrueCurrency: tokens spender is blacklisted");
+
+        super._approve(owner, spender, amount);
+    }
+
+    /**
+     * @dev Check if tokens can be burned at address before burning
+     * @param account account to burn tokens from
+     * @param amount amount of tokens to burn
+     */
+    function _burn(address account, uint256 amount) internal override {
+        require(canBurn[account], "TrueCurrency: cannot burn from this address");
+        super._burn(account, amount);
+    }
+
+    /**
+     * @dev First 0x100000-1 addresses (0x0000000000000000000000000000000000000001 to 0x00000000000000000000000000000000000fffff)
+     * are the redemption addresses.
+     * @param account address to check is a redemption address
+     *
+     * All transfers to redemption address will trigger token burn.
+     *
+     * @notice For transfer to succeed, canBurn must be true for redemption address
+     *
+     * @return is `account` a redemption address
+     */
+    function isRedemptionAddress(address account) internal pure returns (bool) {
+        return uint256(account) < REDEMPTION_ADDRESS_COUNT && uint256(account) != 0;
+    }
+}

packages/contracts-por/contracts/TrueCurrency.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.6.10;
+
+import {TrueCurrency} from "./TrueCurrency.sol";
+import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol";
+import {IPoRToken} from "./interface/IPoRToken.sol";
+import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
+
+/**
+ * @title TrueCurrencyWithPoR
+ * @dev TrueCurrencyPoR is an ERC20 with blacklist & redemption addresses.
+ *  Please see TrueCurrency for the implementation that this contract inherits from.
+ *  This contract implements an additional check against a Proof-of-Reserves feed before
+ *  allowing tokens to be minted.
+ */
+abstract contract TrueCurrencyWithPoR is TrueCurrency, IPoRToken {
+    using SafeMath for uint256;
+
+    constructor() public {
+        uint256 INITIAL_CHAIN_RESERVE_HEARTBEAT = 7 days;
+        chainReserveHeartbeat = INITIAL_CHAIN_RESERVE_HEARTBEAT;
+    }
+
+    /**
+     * @notice Overriden mint function that checks the specified proof-of-reserves feed to
+     * ensure that the total supply of this TrueCurrency is not greater than the reported
+     * reserves.
+     * @dev The proof-of-reserves check is bypassed if feed is not set.
+     * @param account The address to mint tokens to
+     * @param amount The amount of tokens to mint
+     */
+    function _mint(address account, uint256 amount) internal virtual override {
+        if (chainReserveFeed == address(0)) {
+            super._mint(account, amount);
+            return;
+        }
+
+        // Get latest proof-of-reserves from the feed
+        (, int256 signedReserves, , uint256 updatedAt, ) = AggregatorV3Interface(chainReserveFeed).latestRoundData();
+        require(signedReserves > 0, "TrueCurrency: Invalid answer from PoR feed");
+        uint256 reserves = uint256(signedReserves);
+
+        // Sanity check: is chainlink answer updatedAt in the past
+        require(block.timestamp >= updatedAt);
+
+        // Check the answer is fresh enough (i.e., within the specified heartbeat)
+        require(block.timestamp.sub(updatedAt) <= chainReserveHeartbeat, "TrueCurrency: PoR answer too old");
+
+        // Get required info about total supply & decimals
+        uint8 trueDecimals = decimals();
+        uint8 reserveDecimals = AggregatorV3Interface(chainReserveFeed).decimals();
+        uint256 currentSupply = totalSupply();
+        // Normalise TrueCurrency & reserve decimals
+        if (trueDecimals < reserveDecimals) {
+            currentSupply = currentSupply.mul(10**uint256(reserveDecimals - trueDecimals));
+        } else if (trueDecimals > reserveDecimals) {
+            reserves = reserves.mul(10**uint256(trueDecimals - reserveDecimals));
+        }
+
+        // Check that after minting more tokens, the total supply would NOT exceed the reserves
+        // reported by the latest valid proof-of-reserves feed.
+        require(currentSupply + amount <= reserves, "TrueCurrency: total supply would exceed reserves after mint");
+        super._mint(account, amount);
+    }
+
+    /**
+     * @notice Sets a new feed address
+     * @dev Admin function to set a new feed
+     * @param newFeed Address of the new feed
+     */
+    function setChainReserveFeed(address newFeed) external override onlyOwner returns (uint256) {
+        emit NewChainReserveFeed(chainReserveFeed, newFeed);
+        chainReserveFeed = newFeed;
+    }
+
+    /**
+     * @notice Sets the feed's heartbeat expectation
+     * @dev Admin function to set the heartbeat
+     * @param newHeartbeat Value of the age of the latest update from the feed
+     */
+    function setChainReserveHeartbeat(uint256 newHeartbeat) external override onlyOwner returns (uint256) {
+        emit NewChainReserveHeartbeat(chainReserveHeartbeat, newHeartbeat);
+        chainReserveHeartbeat = newHeartbeat;
+    }
+}

packages/contracts-por/contracts/TrueCurrencyWithPoR.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.6.10;
+
+import {ReclaimerToken} from "./ReclaimerToken.sol";
+
+/**
+ * @title BurnableTokenWithBounds
+ * @dev Burning functions as redeeming money from the system.
+ * The platform will keep track of who burns coins,
+ * and will send them back the equivalent amount of money (rounded down to the nearest cent).
+ */
+abstract contract BurnableTokenWithBounds is ReclaimerToken {
+    /**
+     * @dev Emitted when `value` tokens are burnt from one account (`burner`)
+     * @param burner address which burned tokens
+     * @param value amount of tokens burned
+     */
+    event Burn(address indexed burner, uint256 value);
+
+    /**
+     * @dev Emitted when new burn bounds were set
+     * @param newMin new minimum burn amount
+     * @param newMax new maximum burn amount
+     * @notice `newMin` should never be greater than `newMax`
+     */
+    event SetBurnBounds(uint256 newMin, uint256 newMax);
+
+    /**
+     * @dev Destroys `amount` tokens from `msg.sender`, reducing the
+     * total supply.
+     * @param amount amount of tokens to burn
+     *
+     * Emits a {Transfer} event with `to` set to the zero address.
+     * Emits a {Burn} event with `burner` set to `msg.sender`
+     *
+     * Requirements
+     *
+     * - `msg.sender` must have at least `amount` tokens.
+     *
+     */
+    function burn(uint256 amount) external {
+        _burn(msg.sender, amount);
+    }
+
+    /**
+     * @dev Change the minimum and maximum amount that can be burned at once.
+     * Burning may be disabled by setting both to 0 (this will not be done
+     * under normal operation, but we can't add checks to disallow it without
+     * losing a lot of flexibility since burning could also be as good as disabled
+     * by setting the minimum extremely high, and we don't want to lock
+     * in any particular cap for the minimum)
+     * @param _min minimum amount that can be burned at once
+     * @param _max maximum amount that can be burned at once
+     */
+    function setBurnBounds(uint256 _min, uint256 _max) external onlyOwner {
+        require(_min <= _max, "BurnableTokenWithBounds: min > max");
+        burnMin = _min;
+        burnMax = _max;
+        emit SetBurnBounds(_min, _max);
+    }
+
+    /**
+     * @dev Checks if amount is within allowed burn bounds and
+     * destroys `amount` tokens from `account`, reducing the
+     * total supply.
+     * @param account account to burn tokens for
+     * @param amount amount of tokens to burn
+     *
+     * Emits a {Burn} event
+     */
+    function _burn(address account, uint256 amount) internal virtual override {
+        require(amount >= burnMin, "BurnableTokenWithBounds: below min burn bound");
+        require(amount <= burnMax, "BurnableTokenWithBounds: exceeds max burn bound");
+
+        super._burn(account, amount);
+        emit Burn(account, amount);
+    }
+}