Deploy and proposal for USDT market on Goerli

.github/workflows/run-scenarios.yaml

@@ -7,7 +7,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        bases: [ development, mainnet, mainnet-weth, goerli, goerli-weth, fuji, mumbai, polygon, arbitrum, arbitrum-goerli-usdc, arbitrum-goerli-usdc.e, base-usdbc, base-weth, base-goerli, base-goerli-weth, linea-goerli]
+        bases: [ development, mainnet, mainnet-weth, goerli, goerli-weth, goerli-usdt, fuji, mumbai, polygon, arbitrum, arbitrum-goerli-usdc, arbitrum-goerli-usdc.e, base-usdbc, base-weth, base-goerli, base-goerli-weth, linea-goerli]
     name: Run scenarios
     env:
       ETHERSCAN_KEY: ${{ secrets.ETHERSCAN_KEY }}

contracts/Comet.sol

@@ -2,7 +2,7 @@
 pragma solidity 0.8.15;
 
 import "./CometMainInterface.sol";
-import "./ERC20.sol";
+import "./IERC20NonStandard.sol";
 import "./IPriceFeed.sol";
 
 /**
@@ -139,7 +139,7 @@ contract Comet is CometMainInterface {
      **/
     constructor(Configuration memory config) {
         // Sanity checks
-        uint8 decimals_ = ERC20(config.baseToken).decimals();
+        uint8 decimals_ = IERC20NonStandard(config.baseToken).decimals();
         if (decimals_ > MAX_BASE_DECIMALS) revert BadDecimals();
         if (config.storeFrontPriceFactor > FACTOR_SCALE) revert BadDiscount();
         if (config.assetConfigs.length > MAX_ASSETS) revert TooManyAssets();
@@ -241,7 +241,7 @@ contract Comet is CometMainInterface {
 
         // Sanity check price feed and asset decimals
         if (IPriceFeed(priceFeed).decimals() != PRICE_FEED_DECIMALS) revert BadDecimals();
-        if (ERC20(asset).decimals() != decimals_) revert BadDecimals();
+        if (IERC20NonStandard(asset).decimals() != decimals_) revert BadDecimals();
 
         // Ensure collateral factors are within range
         if (assetConfig.borrowCollateralFactor >= assetConfig.liquidateCollateralFactor) revert BorrowCFTooLarge();
@@ -482,15 +482,15 @@ contract Comet is CometMainInterface {
      * @param asset The collateral asset
      */
     function getCollateralReserves(address asset) override public view returns (uint) {
-        return ERC20(asset).balanceOf(address(this)) - totalsCollateral[asset].totalSupplyAsset;
+        return IERC20NonStandard(asset).balanceOf(address(this)) - totalsCollateral[asset].totalSupplyAsset;
     }
 
     /**
      * @notice Gets the total amount of protocol reserves of the base asset
      */
     function getReserves() override public view returns (int) {
         (uint64 baseSupplyIndex_, uint64 baseBorrowIndex_) = accruedInterestIndices(getNowInternal() - lastAccrualTime);
-        uint balance = ERC20(baseToken).balanceOf(address(this));
+        uint balance = IERC20NonStandard(baseToken).balanceOf(address(this));
         uint totalSupply_ = presentValueSupply(baseSupplyIndex_, totalSupplyBase);
         uint totalBorrow_ = presentValueBorrow(baseBorrowIndex_, totalBorrowBase);
         return signed256(balance) - signed256(totalSupply_) + signed256(totalBorrow_);
@@ -760,18 +760,50 @@ contract Comet is CometMainInterface {
     }
 
     /**
-     * @dev Safe ERC20 transfer in, assumes no fee is charged and amount is transferred
+     * @dev Safe ERC20 transfer in and returns the final amount transferred (taking into account any fees)
+     * @dev Note: Safely handles non-standard ERC-20 tokens that do not return a value. See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
      */
-    function doTransferIn(address asset, address from, uint amount) internal {
-        bool success = ERC20(asset).transferFrom(from, address(this), amount);
+    function doTransferIn(address asset, address from, uint amount) internal returns (uint) {
+        uint256 preTransferBalance = IERC20NonStandard(asset).balanceOf(address(this));
+        IERC20NonStandard(asset).transferFrom(from, address(this), amount);
+        bool success;
+        assembly {
+            switch returndatasize()
+                case 0 {                       // This is a non-standard ERC-20
+                    success := not(0)          // set success to true
+                }
+                case 32 {                      // This is a compliant ERC-20
+                    returndatacopy(0, 0, 32)
+                    success := mload(0)        // Set `success = returndata` of override external call
+                }
+                default {                      // This is an excessively non-compliant ERC-20, revert.
+                    revert(0, 0)
+                }
+        }
         if (!success) revert TransferInFailed();
+        return IERC20NonStandard(asset).balanceOf(address(this)) - preTransferBalance;
     }
 
     /**
      * @dev Safe ERC20 transfer out
+     * @dev Note: Safely handles non-standard ERC-20 tokens that do not return a value. See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
      */
     function doTransferOut(address asset, address to, uint amount) internal {
-        bool success = ERC20(asset).transfer(to, amount);
+        IERC20NonStandard(asset).transfer(to, amount);
+        bool success;
+        assembly {
+            switch returndatasize()
+                case 0 {                       // This is a non-standard ERC-20
+                    success := not(0)          // set success to true
+                }
+                case 32 {                      // This is a compliant ERC-20
+                    returndatacopy(0, 0, 32)
+                    success := mload(0)        // Set `success = returndata` of override external call
+                }
+                default {                      // This is an excessively non-compliant ERC-20, revert.
+                    revert(0, 0)
+                }
+        }
         if (!success) revert TransferOutFailed();
     }
 
@@ -827,7 +859,7 @@ contract Comet is CometMainInterface {
      * @dev Supply an amount of base asset from `from` to dst
      */
     function supplyBase(address from, address dst, uint256 amount) internal {
-        doTransferIn(baseToken, from, amount);
+        amount = doTransferIn(baseToken, from, amount);
 
         accrueInternal();
 
@@ -854,7 +886,7 @@ contract Comet is CometMainInterface {
      * @dev Supply an amount of collateral asset from `from` to dst
      */
     function supplyCollateral(address from, address dst, address asset, uint128 amount) internal {
-        doTransferIn(asset, from, amount);
+        amount = safe128(doTransferIn(asset, from, amount));
 
         AssetInfo memory assetInfo = getAssetInfoByAddress(asset);
         TotalsCollateral memory totals = totalsCollateral[asset];
@@ -1199,7 +1231,7 @@ contract Comet is CometMainInterface {
         if (reserves >= 0 && uint(reserves) >= targetReserves) revert NotForSale();
 
         // Note: Re-entrancy can skip the reserves check above on a second buyCollateral call.
-        doTransferIn(baseToken, msg.sender, baseAmount);
+        baseAmount = doTransferIn(baseToken, msg.sender, baseAmount);
 
         uint collateralAmount = quoteCollateral(asset, baseAmount);
         if (collateralAmount < minAmount) revert TooMuchSlippage();
@@ -1261,7 +1293,7 @@ contract Comet is CometMainInterface {
     function approveThis(address manager, address asset, uint amount) override external {
         if (msg.sender != governor) revert Unauthorized();
 
-        ERC20(asset).approve(manager, amount);
+        IERC20NonStandard(asset).approve(manager, amount);
     }
 
     /**
@@ -1322,4 +1354,4 @@ contract Comet is CometMainInterface {
             default { return(0, returndatasize()) }
         }
     }
-}
+}

contracts/IERC20NonStandard.sol

@@ -7,6 +7,7 @@ pragma solidity 0.8.15;
  *  See https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca
  */
 interface IERC20NonStandard {
+    function decimals() external view returns (uint8);
     function approve(address spender, uint256 amount) external;
     function transfer(address to, uint256 value) external;
     function transferFrom(address from, address to, uint256 value) external;

contracts/test/NonStandardFaucetFeeToken.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.15;
+
+/**
+ * @title Non-standard ERC20 token
+ * @dev Implementation of the basic standard token.
+ *  See https://github.com/ethereum/EIPs/issues/20
+ * @dev With USDT fee token mechanism
+ * @dev Note: `transfer` and `transferFrom` do not return a boolean
+ */
+contract NonStandardFeeToken {
+    string public name;
+    string public symbol;
+    uint8 public decimals;
+    uint256 public totalSupply;
+    mapping (address => mapping (address => uint256)) public allowance;
+    mapping(address => uint256) public balanceOf;
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Params(uint feeBasisPoints, uint maxFee);
+
+    // additional variables for use if transaction fees ever became necessary
+    uint public basisPointsRate = 0;
+    uint public maximumFee = 0;
+
+    constructor(uint256 _initialAmount, string memory _tokenName, uint8 _decimalUnits, string memory _tokenSymbol) {
+        totalSupply = _initialAmount;
+        balanceOf[msg.sender] = _initialAmount;
+        name = _tokenName;
+        symbol = _tokenSymbol;
+        decimals = _decimalUnits;
+    }
+
+    function transfer(address dst, uint256 amount) external virtual {
+        require(amount <= balanceOf[msg.sender], "ERC20: transfer amount exceeds balance");
+        uint256 fee = amount * basisPointsRate / 10000;
+        uint256 sendAmount = amount - fee;
+        if (fee > maximumFee) {
+            fee = maximumFee;
+        }
+
+        // For testing purpose, just forward fee to contract itself
+        if (fee > 0) {
+            balanceOf[address(this)] = balanceOf[address(this)] + fee;
+        }
+
+        balanceOf[msg.sender] = balanceOf[msg.sender] - amount;
+        balanceOf[dst] = balanceOf[dst] + sendAmount;
+        emit Transfer(msg.sender, dst, sendAmount);
+    }
+
+    function transferFrom(address src, address dst, uint256 amount) external virtual {
+        require(amount <= allowance[src][msg.sender], "ERC20: transfer amount exceeds allowance");
+        require(amount <= balanceOf[src], "ERC20: transfer amount exceeds balance");
+        uint256 fee = amount * basisPointsRate / 10000;
+        uint256 sendAmount = amount - fee;
+        if (fee > maximumFee) {
+            fee = maximumFee;
+        }
+
+        // For testing purpose, just forward fee to contract itself
+        if (fee > 0) {
+            balanceOf[address(this)] = balanceOf[address(this)] + fee;
+        }
+
+        allowance[src][msg.sender] = allowance[src][msg.sender] - amount;
+        balanceOf[src] = balanceOf[src] - amount;
+        balanceOf[dst] = balanceOf[dst] + sendAmount;
+        emit Transfer(src, dst, sendAmount);
+    }
+
+    function approve(address _spender, uint256 amount) external returns (bool) {
+        allowance[msg.sender][_spender] = amount;
+        emit Approval(msg.sender, _spender, amount);
+        return true;
+    }
+
+    // For testing, just don't limit access on setting fees
+    function setParams(uint256 newBasisPoints, uint256 newMaxFee) public {
+        basisPointsRate = newBasisPoints;
+        maximumFee = newMaxFee * (10**decimals);
+
+        emit Params(basisPointsRate, maximumFee);
+    }
+}
+
+/**
+ * @title The Compound Faucet Test Token
+ * @author Compound
+ * @notice A simple test token that lets anyone get more of it.
+ */
+contract NonStandardFaucetFeeToken is NonStandardFeeToken {
+    constructor(uint256 _initialAmount, string memory _tokenName, uint8 _decimalUnits, string memory _tokenSymbol)
+        NonStandardFeeToken(_initialAmount, _tokenName, _decimalUnits, _tokenSymbol) {
+    }
+
+    function allocateTo(address _owner, uint256 value) public {
+        balanceOf[_owner] += value;
+        totalSupply += value;
+        emit Transfer(address(this), _owner, value);
+    }
+}

deployments/goerli/usdt/configuration.json

@@ -0,0 +1,54 @@
+{
+  "name": "Compound USDT",
+  "symbol": "cUSDTv3",
+  "baseToken": "USDT",
+  "baseTokenPriceFeed": "0xAb5c49580294Aff77670F839ea425f5b78ab3Ae7",
+  "borrowMin": "1e0",
+  "governor": "0x8Fa336EB4bF58Cfc508dEA1B0aeC7336f55B1399",
+  "pauseGuardian": "0x8Fa336EB4bF58Cfc508dEA1B0aeC7336f55B1399",
+  "storeFrontPriceFactor": 0.5,
+  "targetReserves": "5000000e6",
+  "rates": {
+    "supplyKink": 0.8,
+    "supplySlopeLow": 0.0325,
+    "supplySlopeHigh": 0.4,
+    "supplyBase": 0,
+    "borrowKink": 0.8,
+    "borrowSlopeLow": 0.035,
+    "borrowSlopeHigh": 0.25,
+    "borrowBase": 0.015
+  },
+  "rewardToken": "COMP",
+  "tracking": {
+    "indexScale": "1e15",
+    "baseSupplySpeed": "0",
+    "baseBorrowSpeed": "0",
+    "baseMinForRewards": "500e6"
+  },
+  "assets": {
+    "COMP": {
+      "priceFeed": "0x54a06047087927D9B0fb21c1cf0ebd792764dDB8",
+      "decimals": "18",
+      "borrowCF": 0.65,
+      "liquidateCF": 0.7,
+      "liquidationFactor": 0.92,
+      "supplyCap": "0e18"
+    },
+    "WBTC": {
+      "priceFeed": "0xA39434A63A52E749F02807ae27335515BA4b07F7",
+      "decimals": "8",
+      "borrowCF": 0.7,
+      "liquidateCF": 0.75,
+      "liquidationFactor": 0.93,
+      "supplyCap": "0e8"
+    },
+    "WETH": {
+      "priceFeed": "0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e",
+      "decimals": "18",
+      "borrowCF": 0.82,
+      "liquidateCF": 0.85,
+      "liquidationFactor": 0.93,
+      "supplyCap": "0e18"
+    }
+  }
+}

deployments/goerli/usdt/deploy.ts

@@ -0,0 +1,50 @@
+import { Deployed, DeploymentManager } from '../../../plugins/deployment_manager';
+import { debug, DeploySpec, deployComet, exp, sameAddress, wait } from '../../../src/deploy';
+
+const clone = {
+  usdt: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+};
+
+export default async function deploy(deploymentManager: DeploymentManager, deploySpec: DeploySpec): Promise<Deployed> {
+  const trace = deploymentManager.tracer();
+  const ethers = deploymentManager.hre.ethers;
+  const signer = await deploymentManager.getSigner();
+
+  // Clone/fork USDT from mainnet which is non-standard erc20 to testnet
+  const USDT = await deploymentManager.clone('USDT', clone.usdt, [100_000_000_000_000, 'Tether USD', 'USDT', 6]);
+
+  // Declare existing assets as aliases
+  const COMP = await deploymentManager.existing('COMP', '0x3587b2F7E0E2D6166d6C14230e7Fe160252B0ba4', 'goerli');
+  const WBTC = await deploymentManager.existing('WBTC', '0xAAD4992D949f9214458594dF92B44165Fb84dC19', 'goerli');
+  const WETH = await deploymentManager.existing('WETH', '0x42a71137C09AE83D8d05974960fd607d40033499', 'goerli');
+
+  // Import shared contracts from cUSDCv3
+  const cometAdmin = await deploymentManager.fromDep('cometAdmin', 'goerli', 'usdc');
+  // Purposely don't use the factory because Comet implementation changed.
+  // const cometFactory = await deploymentManager.fromDep('cometFactory', 'goerli', 'usdc');
+  const $configuratorImpl = await deploymentManager.fromDep('configurator:implementation', 'goerli', 'usdc');
+  const configurator = await deploymentManager.fromDep('configurator', 'goerli', 'usdc');
+  const rewards = await deploymentManager.fromDep('rewards', 'goerli', 'usdc');
+  const fauceteer = await deploymentManager.fromDep('fauceteer', 'goerli', 'usdc');
+  const bulker = await deploymentManager.fromDep('bulker', 'goerli', 'usdc');
+  const timelock = await deploymentManager.fromDep('timelock', 'goerli', 'usdc');
+
+
+  // Send some forked USDT to timelock
+  await deploymentManager.idempotent(
+    async () => await USDT.connect(signer).balanceOf(timelock.address) == 0,
+    async () => {
+      trace(`Sending USDT to timelock`);
+      await USDT.connect(signer).transfer(
+        timelock.address,
+        exp(50_000_000, 6),
+      );
+      trace(`Sent USDT to timelock completed`);
+    }
+  );
+
+  // Deploy all Comet-related contracts
+  const deployed = await deployComet(deploymentManager, deploySpec);
+
+  return { ...deployed, bulker, fauceteer };
+}

deployments/goerli/usdt/relations.ts

@@ -0,0 +1,5 @@
+import baseRelationConfig from '../../relations';
+
+export default {
+  ...baseRelationConfig
+};