Allow Repayer to initiate Repay to remote self (#243)

Author: lastperson

contracts/Repayer.sol

@@ -214,8 +214,7 @@ contract Repayer is
         }
 
         if (provider == Provider.LOCAL) {
-            // This should always pass because isRouteAllowed check will fail earlier.
-            // It is put here for explicitness.
+            require(destinationPool != address(this), RouteDenied());
             require(destinationDomain == DOMAIN, UnsupportedDomain());
             // For local we proceed to the process right away.
             _processRepayLOCAL(token, amount, destinationPool);
@@ -416,6 +415,11 @@ contract Repayer is
     }
 
     function isRouteAllowed(address pool, Domain domain, Provider provider) public view returns (bool) {
+        // As long as we deploy the Repayer contract on the same address on every supported domain this will work.
+        // If we are to ever deploy it to new address, we will need to change this logic.
+        if (pool == address(this)) {
+            return true;
+        }
         return _getStorage().allowedRoutes[pool].get(_toIndex(domain, provider));
     }
 

coverage-baseline.json

@@ -1,6 +1,6 @@
 {
   "lines": "99.66",
   "functions": "99.64",
-  "branches": "92.39",
+  "branches": "92.56",
   "statements": "99.66"
 }

test/Repayer.ts

@@ -4307,4 +4307,65 @@ describe("Repayer", function () {
       }
     );
   });
+
+  it("Should not allow initiating local repay to repayer's own address", async function () {
+    const {repayer, usdc, USDC_DEC, repayUser} = await loadFixture(deployAll);
+
+    await usdc.transfer(repayer, 10n * USDC_DEC);
+    await expect(repayer.connect(repayUser).initiateRepay(
+      usdc,
+      4n * USDC_DEC,
+      repayer,
+      Domain.BASE,
+      Provider.LOCAL,
+      "0x"
+    )).to.be.revertedWithCustomError(repayer, "RouteDenied()");
+  });
+
+  it("Should allow initiating remote repay to repayer's own address without an explicit route", async function () {
+    const {repayer, usdc, USDC_DEC, repayUser, cctpTokenMessenger} = await loadFixture(deployAll);
+
+    await usdc.transfer(repayer, 10n * USDC_DEC);
+    const tx = repayer.connect(repayUser).initiateRepay(
+      usdc,
+      4n * USDC_DEC,
+      repayer,
+      Domain.ETHEREUM,
+      Provider.CCTP,
+      "0x"
+    );
+    await expect(tx)
+      .to.emit(repayer, "InitiateRepay")
+      .withArgs(usdc.target, 4n * USDC_DEC, repayer.target, Domain.ETHEREUM, Provider.CCTP);
+    await expect(tx)
+      .to.emit(usdc, "Transfer")
+      .withArgs(repayer.target, cctpTokenMessenger.target, 4n * USDC_DEC);
+    await expect(tx)
+      .to.emit(usdc, "Transfer")
+      .withArgs(cctpTokenMessenger.target, ZERO_ADDRESS, 4n * USDC_DEC);
+
+    expect(await usdc.balanceOf(repayer)).to.equal(6n * USDC_DEC);
+  });
+
+  it("Should allow processing repay to repayer's own address without an explicit route", async function () {
+    const {repayer, usdc, USDC_DEC, repayUser} = await loadFixture(deployAll);
+
+    expect(await repayer.isRouteAllowed(repayer, Domain.BASE, Provider.LOCAL)).to.be.true;
+
+    const message = AbiCoder.defaultAbiCoder().encode(
+      ["address", "address", "uint256"],
+      [usdc.target, repayer.target, 4n * USDC_DEC]
+    );
+    const signature = AbiCoder.defaultAbiCoder().encode(["bool", "bool"], [true, true]);
+    const extraData = AbiCoder.defaultAbiCoder().encode(["bytes", "bytes"], [message, signature]);
+    const tx = repayer.connect(repayUser).processRepay(repayer, Provider.CCTP, extraData);
+    await expect(tx)
+      .to.emit(repayer, "ProcessRepay")
+      .withArgs(usdc.target, 4n * USDC_DEC, repayer.target, Provider.CCTP);
+    await expect(tx)
+      .to.emit(usdc, "Transfer")
+      .withArgs(ZERO_ADDRESS, repayer.target, 4n * USDC_DEC);
+
+    expect(await usdc.balanceOf(repayer)).to.equal(4n * USDC_DEC);
+  });
 });