From 5611ced768d432e618bb5e1c3f344dabeb03249a Mon Sep 17 00:00:00 2001
From: CodeSandwich <igor.zuk@protonmail.com>
Date: Mon, 17 May 2021 10:21:04 +0200
Subject: [PATCH] Add dai pool
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Igor Żuk <igor.zuk@protonmail.com>
---
 contracts/Pool.sol    |  35 ++++++++++++-
 contracts/TestDai.sol |  55 ++++++++++++++++++++
 src/deploy.ts         |  22 +++++++-
 src/index.ts          |   1 +
 src/utils.ts          |  30 +++++++++++
 test/pool.test.ts     | 114 +++++++++++++++++++++++++++++++++++-------
 6 files changed, 238 insertions(+), 19 deletions(-)
 create mode 100644 contracts/TestDai.sol
 create mode 100644 src/utils.ts

diff --git a/contracts/Pool.sol b/contracts/Pool.sol
index f6d7871..37f1ef0 100644
--- a/contracts/Pool.sol
+++ b/contracts/Pool.sol
@@ -5,6 +5,7 @@ pragma experimental ABIEncoderV2;
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "./libraries/ProxyDeltas.sol";
 import "./libraries/ReceiverWeights.sol";
+import "./TestDai.sol";
 
 /// @notice Funding pool contract. Automatically sends funds to a configurable set of receivers.
 ///
@@ -863,7 +864,7 @@ contract Erc20Pool is Pool {
         uint128 amtPerSec,
         ReceiverWeight[] calldata updatedReceivers,
         ReceiverWeight[] calldata updatedProxies
-    ) public payable {
+    ) public {
         transferToContract(topUpAmt);
         uint128 withdrawn =
             updateSenderInternal(topUpAmt, withdraw, amtPerSec, updatedReceivers, updatedProxies);
@@ -878,3 +879,35 @@ contract Erc20Pool is Pool {
         if (amt != 0) erc20.transfer(msg.sender, amt);
     }
 }
+
+/// @notice Funding pool contract for DAI token.
+/// See the base `Pool` contract docs for more details.
+contract DaiPool is Erc20Pool {
+    // solhint-disable no-empty-blocks
+    /// @notice See `Erc20Pool` constructor documentation for more details.
+    constructor(uint64 cycleSecs, Dai dai) Erc20Pool(cycleSecs, dai) {}
+
+    /// @notice Updates all the sender parameters of the sender of the message
+    /// and permits spending sender's Dai by the pool.
+    /// This function is an extension of `updateSender`, see its documentation for more details.
+    ///
+    /// The sender must sign a Dai permission document allowing the pool to spend their funds.
+    /// The document's `nonce` and `expiry` must be passed here along the parts of its signature.
+    /// These parameters will be passed to the Dai contract by this function.
+    function updateSenderAndPermit(
+        uint128 topUpAmt,
+        uint128 withdraw,
+        uint128 amtPerSec,
+        ReceiverWeight[] calldata updatedReceivers,
+        ReceiverWeight[] calldata updatedProxies,
+        uint256 nonce,
+        uint256 expiry,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) public {
+        Dai dai = Dai(address(erc20));
+        dai.permit(msg.sender, address(this), nonce, expiry, true, v, r, s);
+        updateSender(topUpAmt, withdraw, amtPerSec, updatedReceivers, updatedProxies);
+    }
+}
diff --git a/contracts/TestDai.sol b/contracts/TestDai.sol
new file mode 100644
index 0000000..1d91b00
--- /dev/null
+++ b/contracts/TestDai.sol
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity ^0.7.5;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract Dai is ERC20 {
+    bytes32 private immutable domainSeparator;
+    bytes32 private immutable typehash;
+    mapping(address => uint256) public nonces;
+
+    constructor() ERC20("DAI Stablecoin", "DAI") {
+        // TODO replace with `block.chainid` after upgrade to Solidity 0.8
+        uint256 chainId;
+        // solhint-disable no-inline-assembly
+        assembly {
+            chainId := chainid()
+        }
+        domainSeparator = keccak256(
+            abi.encode(
+                keccak256(
+                    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
+                ),
+                keccak256(bytes(name())),
+                keccak256(bytes("1")),
+                chainId,
+                address(this)
+            )
+        );
+        typehash = keccak256(
+            "Permit(address holder,address spender,uint256 nonce,uint256 expiry,bool allowed)"
+        );
+        _mint(msg.sender, 10**9 * 10**18); // 1 billion DAI, 18 decimals
+    }
+
+    function permit(
+        address holder,
+        address spender,
+        uint256 nonce,
+        uint256 expiry,
+        bool allowed,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external {
+        bytes32 message = keccak256(abi.encode(typehash, holder, spender, nonce, expiry, allowed));
+        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, message));
+        address signer = ecrecover(digest, v, r, s);
+        require(holder == signer, "Invalid signature");
+        require(nonce == nonces[holder]++, "Invalid nonce");
+        require(expiry == 0 || expiry > block.timestamp, "Signature expired");
+        uint256 amount = allowed ? type(uint256).max : 0;
+        _approve(holder, spender, amount);
+    }
+}
diff --git a/src/deploy.ts b/src/deploy.ts
index c032ff7..28480b2 100644
--- a/src/deploy.ts
+++ b/src/deploy.ts
@@ -10,6 +10,8 @@ import {
   Signer,
 } from "ethers";
 import { Claims } from "../contract-bindings/ethers/Claims";
+import { Dai } from "../contract-bindings/ethers/Dai";
+import { DaiPool } from "../contract-bindings/ethers/DaiPool";
 import { ENS } from "../contract-bindings/ethers/ENS";
 import { EthPool } from "../contract-bindings/ethers/EthPool";
 import { Exchange } from "../contract-bindings/ethers/Exchange";
@@ -22,6 +24,8 @@ import { VestingToken } from "../contract-bindings/ethers/VestingToken";
 import {
   BaseRegistrarImplementation__factory,
   Claims__factory,
+  Dai__factory,
+  DaiPool__factory,
   ENSRegistry__factory,
   Erc20Pool__factory,
   Erc20Pool,
@@ -57,17 +61,20 @@ export async function nextDeployedContractAddr(
 export interface DeployedContracts {
   gov: Governor;
   rad: RadicleToken;
+  dai: Dai;
   registrar: Registrar;
   exchange: Exchange;
   ens: ENS;
   ethPool: EthPool;
   erc20Pool: Erc20Pool;
+  daiPool: DaiPool;
   claims: Claims;
 }
 
 export async function deployAll(signer: Signer): Promise<DeployedContracts> {
   const signerAddr = await signer.getAddress();
   const rad = await deployRadicleToken(signer, signerAddr);
+  const dai = await deployTestDai(signer);
   const timelock = await deployTimelock(signer, signerAddr, 2 * 60 * 60 * 24);
   const gov = await deployGovernance(signer, timelock.address, rad.address, signerAddr);
   const exchange = await deployExchange(rad, signer);
@@ -85,9 +92,10 @@ export async function deployAll(signer: Signer): Promise<DeployedContracts> {
   await transferEthDomain(ens, label, registrar.address);
   const ethPool = await deployEthPool(signer, 10);
   const erc20Pool = await deployErc20Pool(signer, 10, rad.address);
+  const daiPool = await deployDaiPool(signer, 10, dai.address);
   const claims = await deployClaims(signer);
 
-  return { gov, rad, exchange, registrar, ens, ethPool, erc20Pool, claims };
+  return { gov, rad, dai, exchange, registrar, ens, ethPool, erc20Pool, daiPool, claims };
 }
 
 export async function deployRadicleToken(signer: Signer, account: string): Promise<RadicleToken> {
@@ -252,6 +260,14 @@ export async function deployErc20Pool(
   return deployOk(new Erc20Pool__factory(signer).deploy(cycleSecs, erc20TokenAddress));
 }
 
+export async function deployDaiPool(
+  signer: Signer,
+  cycleSecs: number,
+  daiAddress: string
+): Promise<DaiPool> {
+  return deployOk(new DaiPool__factory(signer).deploy(cycleSecs, daiAddress));
+}
+
 // The signer becomes an owner of the '', 'eth' and '<label>.eth' domains,
 // the owner of the root ENS and the owner and controller of the 'eth' registrar
 export async function deployTestEns(signer: Signer, label: string): Promise<ENS> {
@@ -293,6 +309,10 @@ export async function deployClaims(signer: Signer): Promise<Claims> {
   return deployOk(new Claims__factory(signer).deploy());
 }
 
+export async function deployTestDai(signer: Signer): Promise<Dai> {
+  return deployOk(new Dai__factory(signer).deploy());
+}
+
 async function deployOk<T extends BaseContract>(contractPromise: Promise<T>): Promise<T> {
   const contract = await contractPromise;
   await contract.deployed();
diff --git a/src/index.ts b/src/index.ts
index 14ec26a..c45a60a 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1 +1,2 @@
 export { deployAll, DeployedContracts } from "./deploy";
+export { daiPermitDigest } from "./utils";
diff --git a/src/utils.ts b/src/utils.ts
new file mode 100644
index 0000000..72fe2d3
--- /dev/null
+++ b/src/utils.ts
@@ -0,0 +1,30 @@
+import { utils, BigNumberish } from "ethers";
+
+export function daiPermitDigest(
+  daiContract: string,
+  chainId: BigNumberish,
+  holder: string,
+  spender: string,
+  nonce: BigNumberish,
+  expiry: BigNumberish,
+  allowed: boolean
+): Uint8Array {
+  const domain = {
+    name: "DAI Stablecoin",
+    version: "1",
+    chainId,
+    verifyingContract: daiContract,
+  };
+  const types = {
+    Permit: [
+      { name: "holder", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "nonce", type: "uint256" },
+      { name: "expiry", type: "uint256" },
+      { name: "allowed", type: "bool" },
+    ],
+  };
+  const value = { holder, spender, nonce, expiry, allowed };
+  const hash = utils._TypedDataEncoder.hash(domain, types, value);
+  return utils.arrayify(hash);
+}
diff --git a/test/pool.test.ts b/test/pool.test.ts
index 400a1f3..e121195 100644
--- a/test/pool.test.ts
+++ b/test/pool.test.ts
@@ -1,23 +1,30 @@
-import {
-  Erc20Pool__factory,
-  EthPool__factory,
-  RadicleToken__factory,
-} from "../contract-bindings/ethers";
+import { Dai } from "../contract-bindings/ethers/Dai";
 import { IERC20 } from "../contract-bindings/ethers/IERC20";
+import { DaiPool } from "../contract-bindings/ethers/DaiPool";
 import { Erc20Pool } from "../contract-bindings/ethers/Erc20Pool";
 import { EthPool } from "../contract-bindings/ethers/EthPool";
 import { ethers } from "hardhat";
-import { Signer, BigNumber, BigNumberish, ContractReceipt, ContractTransaction } from "ethers";
+import {
+  utils,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  ContractReceipt,
+  ContractTransaction,
+} from "ethers";
 import { expect } from "chai";
 import {
   callOnNextBlock,
   elapseTime,
   elapseTimeUntil,
   expectBigNumberEq,
+  getSigningKey,
   randomAddress,
   submit,
   submitFailing,
 } from "./support";
+import { deployDaiPool, deployErc20Pool, deployEthPool, deployTestDai } from "../src/deploy";
+import { daiPermitDigest } from "../src/utils";
 
 const CYCLE_SECS = 10;
 
@@ -29,7 +36,7 @@ async function elapseTimeUntilCycleEnd(): Promise<void> {
   await elapseTimeUntil(Math.ceil((latestBlock.timestamp + 2) / CYCLE_SECS) * CYCLE_SECS - 1);
 }
 
-type AnyPool = EthPool | Erc20Pool;
+type AnyPool = EthPool | Erc20Pool | DaiPool;
 
 type ReceiverWeights = [PoolUser<AnyPool>, number][];
 type ReceiverWeightsAddr = Array<{
@@ -532,8 +539,7 @@ abstract class PoolUser<Pool extends AnyPool> {
 
 async function getEthPoolUsers(): Promise<EthPoolUser[]> {
   const signers = await ethers.getSigners();
-  const pool = await new EthPool__factory(signers[0]).deploy(CYCLE_SECS);
-  await pool.deployed();
+  const pool = await deployEthPool(signers[0], CYCLE_SECS);
   const constants = await poolConstants(pool);
   const poolSigners = signers.map(
     async (signer: Signer) => await EthPoolUser.new(pool, signer, constants)
@@ -572,14 +578,8 @@ class EthPoolUser extends PoolUser<EthPool> {
 
 async function getErc20PoolUsers(): Promise<Erc20PoolUser[]> {
   const signers = await ethers.getSigners();
-  const signer0 = signers[0];
-  const signer0Addr = await signer0.getAddress();
-
-  const erc20 = await new RadicleToken__factory(signer0).deploy(signer0Addr);
-  await erc20.deployed();
-
-  const pool = await new Erc20Pool__factory(signer0).deploy(CYCLE_SECS, erc20.address);
-  await pool.deployed();
+  const erc20 = await deployTestDai(signers[0]);
+  const pool = await deployErc20Pool(signers[0], CYCLE_SECS, erc20.address);
   const constants = await poolConstants(pool);
 
   const supplyPerUser = (await erc20.totalSupply()).div(signers.length);
@@ -629,6 +629,79 @@ class Erc20PoolUser extends PoolUser<Erc20Pool> {
   }
 }
 
+async function getDaiPoolUsers(): Promise<DaiPoolUser[]> {
+  const signers = await ethers.getSigners();
+  const dai = await deployTestDai(signers[0]);
+  const pool = await deployDaiPool(signers[0], CYCLE_SECS, dai.address);
+  const constants = await poolConstants(pool);
+
+  const supplyPerUser = (await dai.totalSupply()).div(signers.length);
+  const users = [];
+  for (const signer of signers) {
+    const user = await DaiPoolUser.new(pool, dai, signer, constants);
+    await dai.transfer(user.addr, supplyPerUser);
+    users.push(user);
+  }
+  return users;
+}
+
+class DaiPoolUser extends Erc20PoolUser {
+  dai: Dai;
+  daiPool: DaiPool;
+
+  constructor(daiPool: DaiPool, userAddr: string, constants: PoolConstants, dai: Dai) {
+    super(daiPool, userAddr, constants, dai);
+    this.dai = dai;
+    this.daiPool = daiPool;
+  }
+
+  static async new(
+    pool: DaiPool,
+    dai: Dai,
+    signer: Signer,
+    constants: PoolConstants
+  ): Promise<DaiPoolUser> {
+    const userPool = pool.connect(signer);
+    const userAddr = await signer.getAddress();
+    const userDai = dai.connect(signer);
+    return new DaiPoolUser(userPool, userAddr, constants, userDai);
+  }
+
+  async submitUpdateSender(
+    topUp: BigNumberish,
+    withdraw: BigNumberish,
+    amtPerSec: BigNumberish,
+    setReceivers: ReceiverWeightsAddr,
+    setProxies: ReceiverWeightsAddr
+  ): Promise<ContractTransaction> {
+    const nonce = await this.dai.nonces(this.addr);
+    const expiry = 0; // never expires
+    const digest = daiPermitDigest(
+      this.dai.address,
+      await this.pool.signer.getChainId(),
+      this.addr, // holder
+      this.pool.address, // spender
+      nonce,
+      expiry,
+      true // allowed
+    );
+    const signature = getSigningKey(this.addr).signDigest(digest);
+    const { r, s, v } = utils.splitSignature(signature);
+    return this.daiPool.updateSenderAndPermit(
+      topUp,
+      withdraw,
+      amtPerSec,
+      setReceivers,
+      setProxies,
+      nonce,
+      expiry,
+      v,
+      r,
+      s
+    );
+  }
+}
+
 describe("EthPool", function () {
   runCommonPoolTests(getEthPoolUsers);
 
@@ -1305,6 +1378,13 @@ describe("Erc20Pool", function () {
   });
 });
 
+describe("DaiPool", function () {
+  it("Allows sender update", async function () {
+    const [sender, receiver] = await getDaiPoolUsers();
+    await sender.updateSender(0, 10, 10, [[receiver, 1]], []);
+  });
+});
+
 function runCommonPoolTests(getPoolUsers: () => Promise<PoolUser<AnyPool>[]>): void {
   it("Allows full sender update with top up", async function () {
     const [sender, proxy, receiver1, receiver2] = await getPoolUsers();