@instadapp/interop-x 0.0.0-dev.a9cd1d2 → 0.0.0-dev.acc4865

package/src/tasks/InteropX/SyncLogSubmitEvents.ts

@@ -1,136 +1,138 @@
 import { BaseTask } from "../BaseTask";
-import Logger from '@/logger';
+import Logger from "@/logger";
 import { ethers } from "ethers";
 import abi from "@/abi";
 import { Transaction } from "@/db";
-import { generateInteropTransactionHash, getContract, getRpcProviderUrl } from "@/utils";
+import {
+  generateInteropTransactionHash,
+  getContract,
+  getRpcProviderUrl,
+} from "@/utils";
 import { addresses } from "@/constants";
 import { ChainId } from "@/types";
 import config from "@/config";
 import { InteropX } from "@/typechain";
 
 class SyncLogSubmitEvents extends BaseTask {
-    contractAddress: string;
-    provider: ethers.providers.JsonRpcProvider;
-    contract: InteropX;
-    chainId: ChainId;
-
-    constructor({ chainId }: { chainId: ChainId }) {
-        super({
-            logger: new Logger("InteropX::SyncLogSubmitEvents"),
-        })
-        this.chainId = chainId;
-    }
+  contractAddress: string;
+  provider: ethers.providers.JsonRpcProvider;
+  contract: InteropX;
+  chainId: ChainId;
+
+  constructor({ chainId }: { chainId: ChainId }) {
+    super({
+      logger: new Logger("InteropX::SyncLogSubmitEvents"),
+    });
+    this.chainId = chainId;
+  }
+
+  async pollHandler() {
+    const currentBlock = await this.provider.getBlockNumber();
+
+    const events = await this.contract.queryFilter(
+      this.contract.filters.LogSubmit(),
+      currentBlock - 2000,
+      currentBlock
+    );
+
+    let processedEvents = 0;
+
+    for (const event of events) {
+      try {
+        if (!event.args) {
+          continue;
+        }
 
-    async pollHandler() {
-        const currentBlock = await this.provider.getBlockNumber();
-
-        const events = await this.contract.queryFilter(
-            this.contract.filters.LogSubmit(),
-            currentBlock - 2000,
-            currentBlock,
-        );
-
-        let processedEvents = 0;
-
-        for (const event of events) {
-
-            try {
-                if (!event.args) {
-                    continue;
-                }
-
-                const {
-                    position,
-                    actionId,
-                    actionIdHashHash,
-                    sourceSender,
-                    sourceDsaId,
-                    targetDsaId,
-                    sourceChainId,
-                    targetChainId,
-                    vnonce,
-                    metadata,
-
-                } = event.args;
-
-                const uniqueIdentifier = {
-                    actionId,
-                    vnonce: vnonce.toString(),
-                    sourceSender: sourceSender.toString(),
-                    sourceChainId: sourceChainId.toNumber(),
-                    targetChainId: targetChainId.toNumber(),
-                    sourceDsaId: sourceDsaId.toString(),
-                    targetDsaId: targetDsaId.toString(),
-                }
-
-                let transactionHash = generateInteropTransactionHash(uniqueIdentifier);
-
-                const transaction = await Transaction.findOne({ where: { transactionHash } });
-
-                if (transaction) {
-                    continue;
-                }
-
-                await Transaction.create({
-                    transactionHash,
-                    ...uniqueIdentifier,
-                    submitChainId: this.chainId,
-                    submitTransactionHash: event.transactionHash,
-                    submitBlockNumber: event.blockNumber,
-                    submitCreatedAt: new Date(),
-                    submitEvent: {
-                        actionId,
-                        actionIdHashHash,
-                        vnonce: vnonce.toString(),
-                        position: {
-                            withdraw: position.withdraw.map((v) => ({
-                                sourceToken: v.sourceToken,
-                                targetToken: v.targetToken,
-                                amount: v.amount.toString()
-                            })),
-                            supply: position.supply.map((v) => ({
-                                sourceToken: v.sourceToken,
-                                targetToken: v.targetToken,
-                                amount: v.amount.toString()
-                            })),
-                        },
-                        sourceChainId: sourceChainId.toNumber(),
-                        targetChainId: targetChainId.toNumber(),
-                        sourceSender,
-                        sourceDsaId: sourceDsaId.toString(),
-                        targetDsaId: targetDsaId.toString(),
-                        metadata,
-                    }
-                })
-
-                this.logger.info(
-                    `New InteropX tranaction: ${transactionHash} `
-                );
-            } catch (error) {
-                this.logger.error(error);
-            }
+        const {
+          position,
+          actionId,
+          actionIdHashHash,
+          sourceSender,
+          sourceDsaId,
+          targetDsaId,
+          sourceChainId,
+          targetChainId,
+          vnonce,
+          metadata,
+        } = event.args;
+
+        const uniqueIdentifier = {
+          actionId,
+          vnonce: vnonce.toString(),
+          sourceSender: sourceSender.toString(),
+          sourceChainId: sourceChainId.toNumber(),
+          targetChainId: targetChainId.toNumber(),
+          sourceDsaId: sourceDsaId.toString(),
+          targetDsaId: targetDsaId.toString(),
+        };
+
+        let transactionHash = generateInteropTransactionHash(uniqueIdentifier);
+
+        const transaction = await Transaction.findOne({
+          where: { transactionHash },
+        });
+
+        if (transaction) {
+          continue;
         }
 
-        if (processedEvents > 0)
-            this.logger.info(`${processedEvents} events processed`);
+        await Transaction.create({
+          transactionHash,
+          ...uniqueIdentifier,
+          submitChainId: this.chainId,
+          submitTransactionHash: event.transactionHash,
+          submitBlockNumber: event.blockNumber,
+          submitCreatedAt: new Date(),
+          submitEvent: {
+            actionId,
+            actionIdHashHash,
+            vnonce: vnonce.toString(),
+            position: {
+              withdraw: position.withdraw.map((v) => ({
+                sourceToken: v.sourceToken,
+                targetToken: v.targetToken,
+                amount: v.amount.toString(),
+              })),
+              supply: position.supply.map((v) => ({
+                sourceToken: v.sourceToken,
+                targetToken: v.targetToken,
+                amount: v.amount.toString(),
+              })),
+            },
+            sourceChainId: sourceChainId.toNumber(),
+            targetChainId: targetChainId.toNumber(),
+            sourceSender,
+            sourceDsaId: sourceDsaId.toString(),
+            targetDsaId: targetDsaId.toString(),
+            metadata,
+          },
+        });
+
+        this.logger.info(`New InteropX tranaction: ${transactionHash} `);
+      } catch (error) {
+        this.logger.error(error);
+      }
     }
 
-    async start(): Promise<void> {
-        this.contractAddress = addresses[this.chainId].interopX;
+    if (processedEvents > 0)
+      this.logger.info(`${processedEvents} events processed`);
+  }
 
-        this.provider = new ethers.providers.JsonRpcProvider(
-            getRpcProviderUrl(this.chainId)
-        );
+  async start(): Promise<void> {
+    this.contractAddress = addresses[this.chainId].interopX;
 
-        this.contract = getContract<InteropX>(
-            this.contractAddress,
-            abi.interopX,
-            new ethers.Wallet(config.privateKey!, this.provider)
-        );
+    this.provider = new ethers.providers.JsonRpcProvider(
+      getRpcProviderUrl(this.chainId)
+    );
 
-        await super.start()
-    }
+    this.contract = getContract<InteropX>(
+      this.contractAddress,
+      abi.interopX,
+      new ethers.Wallet(config.privateKey!, this.provider)
+    );
+
+    await super.start();
+  }
 }
 
-export default SyncLogSubmitEvents;
+export default SyncLogSubmitEvents;

package/src/tasks/Transactions/SyncTransactionStatusTask.ts

@@ -20,16 +20,17 @@ class SyncTransactionStatusTask extends BaseTask {
         const leadNode = peerPool.getLeadPeer();
 
         if (!leadNode) {
+            console.log("No lead node found");
             return;
         }
 
         const transaction = await Transaction.findOne({
             where: {
-                sourceStatus: {
+                status: {
                     [Op.notIn] : ['success', 'failed'],
                 },
-                sourceCreatedAt: {
-                    [Op.gte]: new Date(Date.now() - 15 * 60 * 1000),
+                createdAt: {
+                    [Op.lt]: new Date(Date.now() - 15 * 60 * 1000),
                 },
             }
         })

package/src/tasks/index.ts

@@ -5,8 +5,8 @@ import SyncTransactionStatusTask from "./Transactions/SyncTransactionStatusTask"
 
 import AutoUpdateTask from "./AutoUpdateTask";
 
-import SyncBridgeRequestEvents from "./InteropX/SyncLogSubmitEvents";
 import SyncLogSubmitEvents from "./InteropX/SyncLogSubmitEvents";
+import ProcessSubmitSubmitEvents from "./InteropX/ProcessSubmitSubmitEvents";
 
 export class Tasks {
 
@@ -17,6 +17,11 @@ export class Tasks {
         // InteropX
         new SyncLogSubmitEvents({ chainId: 137 }),
         new SyncLogSubmitEvents({ chainId: 43114 }),
+
+        new ProcessSubmitSubmitEvents({ chainId: 137 }),
+        new ProcessSubmitSubmitEvents({ chainId: 43114 }),
+
+        new SyncTransactionStatusTask(),
     ];
 
     async start() {