Fix cancelation refunds (#3690)

Author: portuu3

.changeset/tasty-shrimps-grow.md

@@ -0,0 +1,5 @@
+---
+"@human-protocol/core": patch
+---
+
+Add CancelationRefund event to any cancelation

packages/apps/job-launcher/server/src/modules/job/job.service.spec.ts

@@ -1741,16 +1741,78 @@ describe('JobService', () => {
       expect(mockJobRepository.updateOne).toHaveBeenCalledWith(jobEntity);
     });
 
-    it('should throw ConflictError if no refund is found', async () => {
+    it('should not create a refund and set status to CANCELED when no refund is found', async () => {
       const jobEntity = createJobEntity();
       mockPaymentService.getJobPayments.mockResolvedValueOnce([]);
       mockedEscrowUtils.getCancellationRefund.mockResolvedValueOnce(
         null as any,
       );
 
-      await expect(jobService.cancelJob(jobEntity)).rejects.toThrow(
-        new ConflictError(ErrorJob.NoRefundFound),
+      jest
+        .spyOn(jobService as any, 'getRefundAmount')
+        .mockResolvedValueOnce(0n);
+
+      mockJobRepository.updateOne.mockResolvedValueOnce(jobEntity);
+
+      await jobService.cancelJob(jobEntity);
+
+      expect(mockPaymentService.getJobPayments).toHaveBeenCalledWith(
+        jobEntity.id,
+        PaymentType.SLASH,
       );
+      expect(EscrowUtils.getCancellationRefund).toHaveBeenCalledWith(
+        jobEntity.chainId,
+        jobEntity.escrowAddress,
+      );
+      expect(mockPaymentService.createRefundPayment).not.toHaveBeenCalled();
+      expect(jobEntity.status).toBe(JobStatus.CANCELED);
+      expect(mockJobRepository.updateOne).toHaveBeenCalledWith(jobEntity);
+    });
+
+    it('should create a refund when on-chain refund amount is greater than 0', async () => {
+      const jobEntity = createJobEntity();
+      const tokenDecimals = (TOKEN_ADDRESSES[jobEntity.chainId as ChainId] ??
+        {})[jobEntity.token as EscrowFundToken]?.decimals;
+
+      mockPaymentService.getJobPayments.mockResolvedValueOnce([]);
+      mockedEscrowUtils.getCancellationRefund.mockResolvedValueOnce(
+        null as any,
+      );
+
+      const refundAmount = faker.number.float({
+        min: 1,
+        max: 10,
+        fractionDigits: tokenDecimals,
+      });
+
+      // Mock on-chain refund lookup to return a positive amount
+      jest
+        .spyOn(jobService as any, 'getRefundAmount')
+        .mockResolvedValueOnce(
+          ethers.parseUnits(refundAmount.toString(), tokenDecimals),
+        );
+
+      mockPaymentService.createRefundPayment.mockResolvedValueOnce(undefined);
+      mockJobRepository.updateOne.mockResolvedValueOnce(jobEntity);
+
+      await jobService.cancelJob(jobEntity);
+
+      expect(mockPaymentService.getJobPayments).toHaveBeenCalledWith(
+        jobEntity.id,
+        PaymentType.SLASH,
+      );
+      expect(EscrowUtils.getCancellationRefund).toHaveBeenCalledWith(
+        jobEntity.chainId,
+        jobEntity.escrowAddress,
+      );
+      expect(mockPaymentService.createRefundPayment).toHaveBeenCalledWith({
+        refundAmount: refundAmount,
+        refundCurrency: jobEntity.token,
+        userId: jobEntity.userId,
+        jobId: jobEntity.id,
+      });
+      expect(jobEntity.status).toBe(JobStatus.CANCELED);
+      expect(mockJobRepository.updateOne).toHaveBeenCalledWith(jobEntity);
     });
 
     it('should throw ConflictError if refund.amount is empty', async () => {

packages/apps/job-launcher/server/src/modules/job/job.service.ts

@@ -3,6 +3,7 @@ import {
   EscrowClient,
   EscrowStatus,
   EscrowUtils,
+  ICancellationRefund,
   KVStoreKeys,
   KVStoreUtils,
   NETWORKS,
@@ -79,6 +80,7 @@ import {
 } from './job.dto';
 import { JobEntity } from './job.entity';
 import { JobRepository } from './job.repository';
+import { Escrow, Escrow__factory } from '@human-protocol/core/typechain-types';
 
 @Injectable()
 export class JobService {
@@ -876,24 +878,95 @@ export class JobService {
       PaymentType.SLASH,
     );
     if (!slash?.length) {
-      const refund = await EscrowUtils.getCancellationRefund(
-        jobEntity.chainId,
-        jobEntity.escrowAddress!,
-      );
+      let refund: ICancellationRefund | null = null;
+      try {
+        refund = await EscrowUtils.getCancellationRefund(
+          jobEntity.chainId,
+          jobEntity.escrowAddress!,
+        );
+      } catch {
+        // Ignore error
+      }
 
-      if (!refund || !refund.amount) {
-        throw new ConflictError(ErrorJob.NoRefundFound);
+      let amount = 0n;
+
+      if (!refund) {
+        //Temp fix
+        amount = await this.getRefundAmount(
+          jobEntity.chainId,
+          jobEntity.escrowAddress!,
+          token.address,
+        );
+      } else {
+        if (!refund.amount) {
+          throw new ConflictError(ErrorJob.NoRefundFound);
+        }
+        amount = refund.amount;
       }
 
-      await this.paymentService.createRefundPayment({
-        refundAmount: Number(ethers.formatUnits(refund.amount, token.decimals)),
-        refundCurrency: jobEntity.token,
-        userId: jobEntity.userId,
-        jobId: jobEntity.id,
-      });
+      if (amount > 0n) {
+        await this.paymentService.createRefundPayment({
+          refundAmount: Number(ethers.formatUnits(amount, token.decimals)),
+          refundCurrency: jobEntity.token,
+          userId: jobEntity.userId,
+          jobId: jobEntity.id,
+        });
+      }
     }
 
     jobEntity.status = JobStatus.CANCELED;
     await this.jobRepository.updateOne(jobEntity);
   }
+
+  public async getRefundAmount(
+    chainId: ChainId,
+    escrowAddress: string,
+    tokenAddress: string,
+  ): Promise<bigint> {
+    const signer = this.web3Service.getSigner(chainId);
+    const provider = signer.provider!;
+    const contract: Escrow = Escrow__factory.connect(escrowAddress!, provider);
+    const fromBlock = 79278120; //This issue started at this block
+    const toBlock = 'latest';
+    const cancelledFilter = contract.filters?.Cancelled?.();
+    const cancelledLogs = await contract.queryFilter(
+      cancelledFilter,
+      fromBlock,
+      toBlock,
+    );
+
+    for (const log of cancelledLogs) {
+      const erc20Interface = new ethers.Interface([
+        'event Transfer(address indexed from, address indexed to, uint256 value)',
+      ]);
+
+      const transferTopic = erc20Interface.getEvent('Transfer')!.topicHash;
+      const receipt = await provider.getTransactionReceipt(log.transactionHash);
+
+      const transferLogs = receipt!.logs.filter(
+        (l) =>
+          l.address.toLowerCase() === tokenAddress.toLowerCase() &&
+          l.topics[0] === transferTopic,
+      );
+      for (const tlog of transferLogs) {
+        const decoded = erc20Interface.decodeEventLog(
+          'Transfer',
+          tlog.data,
+          tlog.topics,
+        );
+
+        const from = decoded.from as string;
+        const to = decoded.to as string;
+        const value = decoded.value as bigint;
+        if (
+          from.toLowerCase() === escrowAddress.toLowerCase() &&
+          to.toLowerCase() === signer.address.toLowerCase()
+        ) {
+          return value;
+        }
+      }
+    }
+
+    return 0n;
+  }
 }

packages/core/.openzeppelin/bsc-testnet.json

@@ -2956,6 +2956,163 @@
         },
         "namespaces": {}
       }
+    },
+    "addfe6d6ad3f78f6ccf914624fcf7eba6c970f5ba3a20a52f0184991b3d172e1": {
+      "address": "0xa68c1566f23C2335c142D798f8094F460d487044",
+      "txHash": "0x69327fb1132a9f7f15e2550822477c921c531375a50dc429eef4ecfefefe841a",
+      "layout": {
+        "solcVersion": "0.8.23",
+        "storage": [
+          {
+            "label": "_initialized",
+            "offset": 0,
+            "slot": "0",
+            "type": "t_uint8",
+            "contract": "Initializable",
+            "src": "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol:63",
+            "retypedFrom": "bool"
+          },
+          {
+            "label": "_initializing",
+            "offset": 1,
+            "slot": "0",
+            "type": "t_bool",
+            "contract": "Initializable",
+            "src": "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol:68"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "1",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "ContextUpgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol:40"
+          },
+          {
+            "label": "_owner",
+            "offset": 0,
+            "slot": "51",
+            "type": "t_address",
+            "contract": "OwnableUpgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol:22"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "52",
+            "type": "t_array(t_uint256)49_storage",
+            "contract": "OwnableUpgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol:94"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "101",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "ERC1967UpgradeUpgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol:169"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "151",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "UUPSUpgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol:111"
+          },
+          {
+            "label": "counter",
+            "offset": 0,
+            "slot": "201",
+            "type": "t_uint256",
+            "contract": "EscrowFactory",
+            "src": "contracts/EscrowFactory.sol:17"
+          },
+          {
+            "label": "escrowCounters",
+            "offset": 0,
+            "slot": "202",
+            "type": "t_mapping(t_address,t_uint256)",
+            "contract": "EscrowFactory",
+            "src": "contracts/EscrowFactory.sol:18"
+          },
+          {
+            "label": "lastEscrow",
+            "offset": 0,
+            "slot": "203",
+            "type": "t_address",
+            "contract": "EscrowFactory",
+            "src": "contracts/EscrowFactory.sol:19"
+          },
+          {
+            "label": "staking",
+            "offset": 0,
+            "slot": "204",
+            "type": "t_address",
+            "contract": "EscrowFactory",
+            "src": "contracts/EscrowFactory.sol:20"
+          },
+          {
+            "label": "minimumStake",
+            "offset": 0,
+            "slot": "205",
+            "type": "t_uint256",
+            "contract": "EscrowFactory",
+            "src": "contracts/EscrowFactory.sol:21"
+          },
+          {
+            "label": "admin",
+            "offset": 0,
+            "slot": "206",
+            "type": "t_address",
+            "contract": "EscrowFactory",
+            "src": "contracts/EscrowFactory.sol:22"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "207",
+            "type": "t_array(t_uint256)44_storage",
+            "contract": "EscrowFactory",
+            "src": "contracts/EscrowFactory.sol:189"
+          }
+        ],
+        "types": {
+          "t_address": {
+            "label": "address",
+            "numberOfBytes": "20"
+          },
+          "t_array(t_uint256)44_storage": {
+            "label": "uint256[44]",
+            "numberOfBytes": "1408"
+          },
+          "t_array(t_uint256)49_storage": {
+            "label": "uint256[49]",
+            "numberOfBytes": "1568"
+          },
+          "t_array(t_uint256)50_storage": {
+            "label": "uint256[50]",
+            "numberOfBytes": "1600"
+          },
+          "t_bool": {
+            "label": "bool",
+            "numberOfBytes": "1"
+          },
+          "t_mapping(t_address,t_uint256)": {
+            "label": "mapping(address => uint256)",
+            "numberOfBytes": "32"
+          },
+          "t_uint256": {
+            "label": "uint256",
+            "numberOfBytes": "32"
+          },
+          "t_uint8": {
+            "label": "uint8",
+            "numberOfBytes": "1"
+          }
+        },
+        "namespaces": {}
+      }
     }
   }
 }