🏊‍♂️ Freeze Watr native token on blacklisting (#1256)

* Freeze account on whitelisting

* Freeze native asset on pausing

* Revert "Freeze native asset on pausing"

This reverts commit c91e8bf.

* Update `IMintableXC20` interface

* Add blacklisting test to `verifyDeployments`

packages/contracts-watr/contracts/TrueCurrency.sol

@@ -96,6 +96,7 @@ abstract contract TrueCurrency is BurnableTokenWithBounds {
      */
     function setBlacklisted(address account, bool _isBlacklisted) external override onlyOwner {
         require(uint256(account) >= REDEMPTION_ADDRESS_COUNT, "TrueCurrency: blacklisting of redemption address is not allowed");
+        _setBlacklistedXC20(account, _isBlacklisted);
         isBlacklisted[account] = _isBlacklisted;
         emit Blacklisted(account, _isBlacklisted);
     }
@@ -179,4 +180,15 @@ abstract contract TrueCurrency is BurnableTokenWithBounds {
     function isRedemptionAddress(address account) internal pure returns (bool) {
         return uint256(account) < REDEMPTION_ADDRESS_COUNT && account != address(0);
     }
+
+    function _setBlacklistedXC20(address account, bool _isBlacklisted) internal {
+        if (isBlacklisted[account] == _isBlacklisted) {
+            return;
+        }
+        if (_isBlacklisted) {
+            _freeze(account);
+        } else {
+            _thaw(account);
+        }
+    }
 }

packages/contracts-watr/contracts/common/XC20Wrapper.sol

@@ -7,17 +7,17 @@ import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 
 import {ClaimableOwnable} from "./ClaimableOwnable.sol";
-import {IERC20Plus} from "../interface/IERC20Plus.sol";
+import {IMintableXC20} from "../interface/IMintableXC20.sol";
 
 abstract contract XC20Wrapper is IERC20, ClaimableOwnable, Context {
     using SafeMath for uint256;
 
     function totalSupply() public view virtual override returns (uint256) {
-        return IERC20Plus(nativeToken).totalSupply();
+        return IMintableXC20(nativeToken).totalSupply();
     }
 
     function balanceOf(address account) external view virtual override returns (uint256) {
-        return IERC20Plus(nativeToken).balanceOf(account);
+        return IMintableXC20(nativeToken).balanceOf(account);
     }
 
     function transfer(address recipient, uint256 amount) external virtual override returns (bool) {
@@ -54,7 +54,7 @@ abstract contract XC20Wrapper is IERC20, ClaimableOwnable, Context {
     }
 
     function decimals() public view virtual returns (uint8) {
-        return IERC20Plus(nativeToken).decimals();
+        return IMintableXC20(nativeToken).decimals();
     }
 
     function name() public pure virtual returns (string memory);
@@ -63,12 +63,12 @@ abstract contract XC20Wrapper is IERC20, ClaimableOwnable, Context {
 
     function _mint(address account, uint256 amount) internal virtual {
         require(account != address(0), "XC20: mint to the zero address");
-        IERC20Plus(nativeToken).mint(account, amount);
+        IMintableXC20(nativeToken).mint(account, amount);
         emit Transfer(address(0), account, amount);
     }
 
     function _burn(address account, uint256 amount) internal virtual {
-        IERC20Plus(nativeToken).burn(account, amount);
+        IMintableXC20(nativeToken).burn(account, amount);
         emit Transfer(account, address(0), amount);
     }
 
@@ -97,8 +97,16 @@ abstract contract XC20Wrapper is IERC20, ClaimableOwnable, Context {
         address recipient,
         uint256 amount
     ) internal virtual {
-        require(IERC20Plus(nativeToken).balanceOf(sender) >= amount, "XC20: amount exceeds balance");
-        IERC20Plus(nativeToken).burn(sender, amount);
-        IERC20Plus(nativeToken).mint(recipient, amount);
+        require(IMintableXC20(nativeToken).balanceOf(sender) >= amount, "XC20: amount exceeds balance");
+        IMintableXC20(nativeToken).burn(sender, amount);
+        IMintableXC20(nativeToken).mint(recipient, amount);
+    }
+
+    function _freeze(address account) internal {
+        IMintableXC20(nativeToken).freeze(account);
+    }
+
+    function _thaw(address account) internal {
+        IMintableXC20(nativeToken).thaw(account);
     }
 }

packages/contracts-watr/contracts/interface/IMintableXC20.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.6.10;
+
+import {IERC20Plus} from "./IERC20Plus.sol";
+
+interface IMintableXC20 is IERC20Plus {
+    function freeze(address account) external returns (bool);
+
+    function thaw(address account) external returns (bool);
+
+    function freezeAsset() external returns (bool);
+
+    function thawAsset() external returns (bool);
+}

packages/contracts-watr/contracts/mocks/MockXC20.sol

@@ -6,6 +6,8 @@ contract MockXC20 {
     mapping(address => uint256) public balanceOf;
     uint8 public decimals;
 
+    mapping(address => bool) public frozen;
+
     constructor(uint8 _decimals) public {
         decimals = _decimals;
     }
@@ -24,4 +26,16 @@ contract MockXC20 {
 
         return true;
     }
+
+    function freeze(address account) public returns (bool) {
+        frozen[account] = true;
+
+        return true;
+    }
+
+    function thaw(address account) public returns (bool) {
+        frozen[account] = false;
+
+        return true;
+    }
 }

packages/contracts-watr/test/TrueMintableBurnable.test.ts

@@ -1,7 +1,7 @@
 import { expect, use } from 'chai'
 import { solidity } from 'ethereum-waffle'
 import { BigNumber, BigNumberish, constants, Wallet } from 'ethers'
-import { MockXC20__factory, TrueUSD, TrueUSD__factory } from 'contracts'
+import { MockXC20, MockXC20__factory, TrueUSD, TrueUSD__factory } from 'contracts'
 import { beforeEachWithFixture } from 'fixtures/beforeEachWithFixture'
 import { AddressZero, Zero } from '@ethersproject/constants'
 import { parseEther } from '@ethersproject/units'
@@ -15,13 +15,14 @@ describe('TrueCurrency - Mint/Burn', () => {
   let owner: Wallet
   let initialHolder: Wallet
   let secondAccount: Wallet
+  let mockXC20: MockXC20
   let token: TrueUSD
 
   const initialSupply = parseTrueUSD('1000')
 
   beforeEachWithFixture(async (wallets) => {
     [owner, initialHolder, secondAccount] = wallets
-    const mockXC20 = await new MockXC20__factory(owner).deploy(trueUSDDecimals)
+    mockXC20 = await new MockXC20__factory(owner).deploy(trueUSDDecimals)
     token = await new TrueUSD__factory(owner).deploy()
     await token.initialize(mockXC20.address)
     await token.connect(owner).mint(initialHolder.address, initialSupply)
@@ -382,5 +383,16 @@ describe('TrueCurrency - Mint/Burn', () => {
         await expect(token.setBlacklisted(AddressZero, true)).to.be.revertedWith('TrueCurrency: blacklisting of redemption address is not allowed')
       })
     })
+
+    describe('xc-20', () => {
+      it('calls "freeze" when blacklisting account', async () => {
+        expect(await mockXC20.frozen(blacklistedAccount.address)).to.be.true
+      })
+
+      it('calls "thaw" when de-blacklisting account', async () => {
+        await token.setBlacklisted(blacklistedAccount.address, false)
+        expect(await mockXC20.frozen(blacklistedAccount.address)).to.be.false
+      })
+    })
   })
 })

packages/contracts-watr/test/verifyDeployment/verifyDeployment.test.ts

@@ -71,6 +71,14 @@ describe('verify deployment', () => {
 
     await expect(tx).to.changeTokenBalances(token, [deployer, toAccount(otherAddress)], [parseEther('-0.5'), parseEther('0.5')])
   }).timeout(100000)
+
+  it('can blacklist', async () => {
+    const deployer = new ethers.Wallet(process.env['PRIVATE_KEY_DEPLOYER'], provider)
+    const tokenController = TokenControllerV3__factory.connect(deployments.tokenControllerV3_proxy.address, deployer)
+    const otherAddress = '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984'
+
+    await waitFor(tokenController.setBlacklisted(otherAddress, true))
+  })
 })
 
 async function waitFor<T>(tx: Promise<{ wait: () => Promise<T> }>) {