test: add rescue-funds tests

Author: aimensahnoun

packages/smart-contracts/src/contracts/test/ForceSend.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract ForceSend {
+  function forceSend(address payable recipient) public payable {
+    selfdestruct(recipient);
+  }
+}

packages/smart-contracts/test/contracts/ERC20SingleRequestProxy.test.ts

@@ -254,39 +254,23 @@ describe('contract: ERC20SingleRequestProxy', () => {
     ).to.be.reverted;
   });
 
-  // it('should work with USDT-like non-standard ERC20 tokens', async () => {
-  //   const usdtProxy = await new ERC20SingleRequestProxy__factory(deployer).deploy(
-  //     user2Addr,
-  //     usdtFake.address,
-  //     feeRecipientAddr,
-  //     feeAmount,
-  //     paymentReference,
-  //     erc20FeeProxy.address,
-  //   );
-
-  //   const paymentAmount = BN.from(100).mul(USDT_DECIMAL);
-  //   const totalAmount = paymentAmount.add(feeAmount);
-
-  //   await usdtFake.transfer(usdtProxy.address, totalAmount);
-
-  //   const usdtProxyBalanceBefore = await usdtFake.balanceOf(usdtProxy.address);
-  //   expect(usdtProxyBalanceBefore).to.equal(totalAmount);
-
-  //   await expect(
-  //     user1.sendTransaction({
-  //       to: usdtProxy.address,
-  //       value: 0,
-  //     }),
-  //   )
-  //     .to.emit(erc20FeeProxy, 'TransferWithReferenceAndFee')
-  //     .withArgs(usdtFake.address, user2Addr, paymentAmount, paymentReference, feeAmount, feeRecipientAddr);
-
-  //   const usdtProxyBalanceAfter = await usdtFake.balanceOf(usdtProxy.address);
-  //   const user2BalanceAfter = await usdtFake.balanceOf(user2Addr);
-  //   const feeRecipientBalanceAfter = await usdtFake.balanceOf(feeRecipientAddr);
-
-  //   expect(usdtProxyBalanceAfter).to.equal(0);
-  //   expect(user2BalanceAfter).to.equal(paymentAmount);
-  //   expect(feeRecipientBalanceAfter).to.equal(feeAmount);
-  // });
+  it('should rescue ERC20 tokens', async () => {
+    const rescueAmount = BN.from(100).mul(BASE_DECIMAL);
+
+    // Transfer tokens directly to the contract
+    await testToken.transfer(erc20SingleRequestProxy.address, rescueAmount);
+
+    const contractBalanceBefore = await testToken.balanceOf(erc20SingleRequestProxy.address);
+    expect(contractBalanceBefore).to.equal(rescueAmount);
+
+    const payeeBalanceBefore = await testToken.balanceOf(user2Addr);
+
+    await erc20SingleRequestProxy.rescueFunds();
+
+    const contractBalanceAfter = await testToken.balanceOf(erc20SingleRequestProxy.address);
+    expect(contractBalanceAfter).to.equal(0);
+
+    const payeeBalanceAfter = await testToken.balanceOf(user2Addr);
+    expect(payeeBalanceAfter.sub(payeeBalanceBefore)).to.equal(rescueAmount);
+  });
 });

packages/smart-contracts/test/contracts/EthereumSingleRequestProxy.test.ts

@@ -114,4 +114,30 @@ describe('contract : EthereumSingleRequestProxy', () => {
     expect(await ethers.provider.getBalance(newEthereumSingleRequestProxy.address)).to.equal(0);
     expect(await ethers.provider.getBalance(mockEthereumFeeProxy.address)).to.equal(0);
   });
+
+  it('should rescue funds', async () => {
+    const paymentAmount = ethers.utils.parseEther('1');
+    const totalAmount = paymentAmount.add(feeAmount);
+
+    const ForceSendFactory = await ethers.getContractFactory('ForceSend');
+    const forceSend = await ForceSendFactory.deploy();
+    await forceSend.deployed();
+
+    await forceSend.forceSend(ethereumSingleRequestProxy.address, { value: totalAmount });
+
+    const balanceAfterForceSend = await ethers.provider.getBalance(
+      ethereumSingleRequestProxy.address,
+    );
+    expect(balanceAfterForceSend).to.be.gt(0);
+    expect(balanceAfterForceSend).to.equal(totalAmount);
+
+    const initialPayeeBalance = await ethers.provider.getBalance(payeeAddress);
+
+    await ethereumSingleRequestProxy.rescueFunds();
+
+    expect(await ethers.provider.getBalance(ethereumSingleRequestProxy.address)).to.equal(0);
+
+    const finalPayeeBalance = await ethers.provider.getBalance(payeeAddress);
+    expect(finalPayeeBalance.sub(initialPayeeBalance)).to.equal(balanceAfterForceSend);
+  });
 });