@zircuit/ovault-evm 0.0.1

package/src/oVaultSync/tracking.ts

@@ -0,0 +1,614 @@
+import {
+  Chain,
+  createPublicClient,
+  decodeEventLog,
+  http,
+  PublicClient,
+  type Abi,
+} from "viem";
+import {
+  OVaultFailureReason,
+  OVaultTransactionStep,
+  OVaultMessageWithTxHash,
+  OVaultWithdrawalInfo,
+} from "../types";
+import { V2 as scanClient, V2Types } from "@layerzerolabs/scan-client-v2";
+import { OVaultComposerSyncAbi } from "../contracts/OVaultComposerSync";
+import { OVaultComposerAbi } from "../contracts/OVaultComposer";
+
+interface TrackingChainConfigs {
+  sourceChain: Chain;
+  hubChain: Chain;
+  dstChain: Chain;
+  rpcUrls?: {
+    sourceChain?: string;
+    hubChain?: string;
+    dstChain?: string;
+  };
+}
+
+async function getTxStatus(txHash: `0x${string}`, client: PublicClient) {
+  const receipt = await client.getTransactionReceipt({ hash: txHash });
+  if (receipt.status === "reverted") {
+    return {
+      success: false,
+      error: OVaultFailureReason.UNKNOWN,
+    };
+  } else if (receipt.status === "success") {
+    return {
+      success: true,
+    };
+  }
+
+  return {
+    success: false,
+  };
+}
+
+async function isRefunded(txHash: `0x${string}`, client: PublicClient) {
+  const receipt = await client.waitForTransactionReceipt({
+    hash: txHash,
+  });
+
+  if (receipt.status !== "success") {
+    return false;
+  }
+
+  for (const log of receipt.logs) {
+    try {
+      const values = decodeEventLog({
+        abi: OVaultComposerSyncAbi,
+        data: log.data as `0x${string}`,
+        topics: log.topics,
+      });
+
+      if (values.eventName === "Refunded") {
+        return true;
+      }
+    } catch (e) {
+      // Ignore errors in decoding logs, they might not be OFT events
+    }
+  }
+
+  return false;
+}
+
+// Helper function to find the withdrawal index by looking at WithdrawalProcessed events
+const findWithdrawalIndexInReceipt = async (
+  message: V2Types.ScanAPIMessage | OVaultMessageWithTxHash | undefined,
+  withdrawalInfo: OVaultWithdrawalInfo,
+  client: PublicClient,
+): Promise<number | null> => {
+  try {
+    // Get the transaction hash from the source
+    const txHash = message?.source?.tx?.txHash;
+    if (!txHash) {
+      console.warn("No txHash found in message");
+      return null;
+    }
+
+    // Get the transaction receipt
+    const receipt = await client.getTransactionReceipt({ hash: txHash });
+
+    if (!receipt || receipt.logs.length === 0) {
+      console.warn("No receipt or logs found for transaction", txHash);
+      return null;
+    }
+
+    const withdrawalProcessedEvents: Array<{
+      index: bigint;
+      initiator: `0x${string}`;
+      timestamp: bigint;
+    }> = [];
+
+    for (const log of receipt.logs) {
+      try {
+        const decoded = decodeEventLog({
+          abi: OVaultComposerAbi as Abi,
+          data: log.data as `0x${string}`,
+          topics: log.topics,
+          eventName: "WithdrawalProcessed",
+        });
+
+        const args = decoded.args as unknown as {
+          index: bigint;
+          initiator: `0x${string}`;
+          timestamp: bigint;
+        };
+
+        withdrawalProcessedEvents.push({
+          index: args.index,
+          initiator: args.initiator,
+          timestamp: args.timestamp,
+        });
+      } catch {
+        // Ignore, event is not WithdrawalProcessed
+      }
+    }
+
+    const matchIndex = withdrawalProcessedEvents.findIndex((event) => {
+      const indexMatch =
+        event.index?.toString() === withdrawalInfo.index?.toString();
+      const initiatorMatch =
+        event.initiator?.toLowerCase() ===
+        withdrawalInfo.initiator?.toLowerCase();
+
+      if (indexMatch && initiatorMatch) {
+        return true;
+      }
+
+      return false;
+    });
+
+    if (matchIndex < 0) {
+      console.warn("Could not find matching withdrawal in events", {
+        searchingForIndex: withdrawalInfo.index,
+        searchingForInitiator: withdrawalInfo.initiator,
+        foundInEvents: withdrawalProcessedEvents.map((e) => ({
+          index: e.index.toString(),
+          initiator: e.initiator,
+          timestamp: e.timestamp.toString(),
+        })),
+      });
+    }
+
+    return matchIndex >= 0 ? matchIndex : null;
+  } catch (error) {
+    console.error("Error finding withdrawal in receipt:", error);
+    return null;
+  }
+};
+
+async function getLzTxStatus(txHash: `0x${string}`) {
+  try {
+    const messages = await scanClient.getMessagesBySrcTxHash(txHash);
+    if (!Array.isArray(messages)) {
+      console.error("Invalid response from LayerZero scan API", {
+        txHash,
+        messages,
+      });
+      return [];
+    }
+    return messages;
+  } catch (error) {
+    console.error("Error fetching LayerZero messages", {
+      txHash,
+      error: error instanceof Error ? error.message : error,
+    });
+    return [];
+  }
+}
+
+async function trackBBB(
+  txHash: `0x${string}`,
+  viemConfigs: TrackingChainConfigs,
+) {
+  const { sourceChain } = viemConfigs;
+
+  const sourceClient = createPublicClient({
+    chain: sourceChain,
+    transport: http(viemConfigs.rpcUrls?.sourceChain),
+  });
+
+  const sourceTx = await getTxStatus(txHash, sourceClient);
+
+  // In a BBB transaction, the source chain transaction is the only transaction.
+  // If the source chain transaction fails, the transaction is refunded.
+  return {
+    step: sourceTx.success
+      ? OVaultTransactionStep.COMPLETED
+      : OVaultTransactionStep.HUB_CHAIN_TRANSACTION,
+    refunded: sourceTx.error ? true : undefined,
+    failureReason: sourceTx.error,
+    destinationTxHash: sourceTx.success ? txHash : undefined,
+  };
+}
+
+async function trackABB(
+  txHash: `0x${string}`,
+  viemConfigs: TrackingChainConfigs,
+  withdrawalInfo?: OVaultWithdrawalInfo,
+) {
+  const { sourceChain, hubChain } = viemConfigs;
+
+  const sourceClient = createPublicClient({
+    chain: sourceChain,
+    transport: http(viemConfigs.rpcUrls?.sourceChain),
+  });
+
+  const hubClient = createPublicClient({
+    chain: hubChain,
+    transport: http(viemConfigs.rpcUrls?.hubChain),
+  });
+
+  const sourceTx = await getTxStatus(txHash, sourceClient);
+
+  if (sourceTx.error) {
+    return {
+      step: OVaultTransactionStep.SOURCE_CHAIN_TRANSACTION,
+      failureReason: OVaultFailureReason.UNKNOWN,
+    };
+  } else if (!sourceTx.success) {
+    // Transaction is still in progress
+    return {
+      step: OVaultTransactionStep.SOURCE_CHAIN_TRANSACTION,
+    };
+  }
+
+  // Source Tx is successful, now we need to track the hub chain transaction.
+  const sourceToHubMessages = await getLzTxStatus(txHash);
+
+  if (sourceToHubMessages.length === 0) {
+    return {
+      step: OVaultTransactionStep.SOURCE_TO_HUB_LZ_TRANSACTION,
+    };
+  }
+
+  let sourceToHubMessage: V2Types.ScanAPIMessage = sourceToHubMessages[0];
+
+  // For withdrawals, find which message index corresponds to this specific withdrawal
+  if (withdrawalInfo) {
+    const msgIndex = await findWithdrawalIndexInReceipt(
+      sourceToHubMessage,
+      withdrawalInfo,
+      sourceClient,
+    );
+
+    if (msgIndex === null) {
+      console.warn(
+        "Could not find withdrawal in receipt events",
+        withdrawalInfo,
+      );
+      return {
+        step: OVaultTransactionStep.HUB_CHAIN_TRANSACTION,
+      };
+    }
+
+    sourceToHubMessage = sourceToHubMessages[msgIndex];
+  }
+
+  if (
+    sourceToHubMessage.status.name === "INFLIGHT" ||
+    sourceToHubMessage.status.name === "CONFIRMING"
+  ) {
+    // Transaction is still in progress
+    return {
+      step: OVaultTransactionStep.SOURCE_TO_HUB_LZ_TRANSACTION,
+    };
+  }
+
+  if (sourceToHubMessage.status.name !== "DELIVERED") {
+    return {
+      step: OVaultTransactionStep.SOURCE_TO_HUB_LZ_TRANSACTION,
+      failureReason: OVaultFailureReason.UNKNOWN,
+    };
+  }
+
+  // Track hub chain transaction
+  const executorDst = sourceToHubMessage.destination as V2Types.ExecutorTx;
+  const composeTxHash = executorDst?.lzCompose?.txs?.[0]
+    ?.txHash as `0x${string}`;
+  const failedCompose = executorDst?.lzCompose?.failedTx?.[0]
+    ?.txHash as `0x${string}`;
+  if (failedCompose) {
+    return {
+      step: OVaultTransactionStep.HUB_CHAIN_TRANSACTION,
+      failureReason: OVaultFailureReason.UNKNOWN,
+      refunded: false,
+      hubTxHash: failedCompose,
+    };
+  }
+  if (!composeTxHash) {
+    // Waiting for the compose tx to be created
+    return {
+      step: OVaultTransactionStep.HUB_CHAIN_TRANSACTION,
+    };
+  }
+  const hubTx = await getTxStatus(composeTxHash, hubClient);
+
+  const refunded = await isRefunded(composeTxHash, hubClient);
+
+  return {
+    step: hubTx.success
+      ? OVaultTransactionStep.COMPLETED
+      : OVaultTransactionStep.HUB_CHAIN_TRANSACTION,
+    refunded: hubTx.error || refunded ? true : undefined,
+    failureReason:
+      hubTx.error || (refunded ? OVaultFailureReason.UNKNOWN : undefined),
+    destinationTxHash: hubTx.success ? composeTxHash : undefined,
+    hubTxHash: composeTxHash,
+  };
+}
+
+async function trackBBA(
+  txHash: `0x${string}`,
+  viemConfigs: TrackingChainConfigs,
+  withdrawalInfo?: OVaultWithdrawalInfo,
+) {
+  const { sourceChain, dstChain } = viemConfigs;
+
+  const sourceClient = createPublicClient({
+    chain: sourceChain,
+    transport: http(viemConfigs.rpcUrls?.sourceChain),
+  });
+
+  const dstClient = createPublicClient({
+    chain: dstChain,
+    transport: http(viemConfigs.rpcUrls?.dstChain),
+  });
+
+  const sourceTx = await getTxStatus(txHash, sourceClient);
+
+  if (sourceTx.error) {
+    return {
+      step: OVaultTransactionStep.SOURCE_CHAIN_TRANSACTION,
+      failureReason: OVaultFailureReason.UNKNOWN,
+    };
+  } else if (!sourceTx.success) {
+    // Transaction is still in progress
+    return {
+      step: OVaultTransactionStep.SOURCE_CHAIN_TRANSACTION,
+    };
+  }
+
+  const hubToDstMessages = await getLzTxStatus(txHash);
+
+  if (hubToDstMessages.length === 0) {
+    return {
+      step: OVaultTransactionStep.HUB_TO_DST_LZ_TRANSACTION,
+    };
+  }
+
+  let hubToDstMessage: V2Types.ScanAPIMessage = hubToDstMessages[0];
+
+  // For withdrawals, find which message index corresponds to this specific withdrawal
+  if (withdrawalInfo) {
+    const msgIndex = await findWithdrawalIndexInReceipt(
+      hubToDstMessage,
+      withdrawalInfo,
+      sourceClient,
+    );
+
+    if (msgIndex === null) {
+      console.warn(
+        "Could not find withdrawal in receipt events",
+        withdrawalInfo,
+      );
+      return {
+        step: OVaultTransactionStep.HUB_TO_DST_LZ_TRANSACTION,
+      };
+    }
+
+    hubToDstMessage = hubToDstMessages[msgIndex];
+  }
+
+  if (
+    hubToDstMessage.status.name === "INFLIGHT" ||
+    hubToDstMessage.status.name === "CONFIRMING"
+  ) {
+    return {
+      step: OVaultTransactionStep.HUB_TO_DST_LZ_TRANSACTION,
+    };
+  }
+
+  if (hubToDstMessage.status.name !== "DELIVERED") {
+    return {
+      step: OVaultTransactionStep.HUB_TO_DST_LZ_TRANSACTION,
+      failureReason: OVaultFailureReason.UNKNOWN,
+    };
+  }
+
+  // Track dst chain transaction
+  const dstTxHash = hubToDstMessage.destination?.tx?.txHash as `0x${string}`;
+  if (!dstTxHash) {
+    return {
+      step: OVaultTransactionStep.DST_CHAIN_TRANSACTION,
+    };
+  }
+
+  const dstTx = await getTxStatus(dstTxHash, dstClient);
+
+  return {
+    step: dstTx.success
+      ? OVaultTransactionStep.COMPLETED
+      : OVaultTransactionStep.DST_CHAIN_TRANSACTION,
+    refunded: false,
+    failureReason: dstTx.error,
+    destinationTxHash: dstTx.success ? dstTxHash : undefined,
+  };
+}
+
+async function trackABA(
+  txHash: `0x${string}`,
+  viemConfigs: TrackingChainConfigs,
+  withdrawalInfo?: OVaultWithdrawalInfo,
+) {
+  const { sourceChain, hubChain, dstChain } = viemConfigs;
+
+  const sourceClient = createPublicClient({
+    chain: sourceChain,
+    transport: http(viemConfigs.rpcUrls?.sourceChain),
+  });
+
+  const hubClient = createPublicClient({
+    chain: hubChain,
+    transport: http(viemConfigs.rpcUrls?.hubChain),
+  });
+
+  const dstClient = createPublicClient({
+    chain: dstChain,
+    transport: http(viemConfigs.rpcUrls?.dstChain),
+  });
+
+  const sourceTx = await getTxStatus(txHash, sourceClient);
+
+  if (sourceTx.error) {
+    return {
+      step: OVaultTransactionStep.SOURCE_CHAIN_TRANSACTION,
+      failureReason: OVaultFailureReason.UNKNOWN,
+    };
+  } else if (!sourceTx.success) {
+    // Transaction is still in progress
+    return {
+      step: OVaultTransactionStep.SOURCE_CHAIN_TRANSACTION,
+    };
+  }
+
+  const sourceToHubMessages = await getLzTxStatus(txHash);
+
+  if (sourceToHubMessages.length === 0) {
+    return {
+      step: OVaultTransactionStep.SOURCE_TO_HUB_LZ_TRANSACTION,
+    };
+  }
+
+  let sourceToHubMessage: V2Types.ScanAPIMessage = sourceToHubMessages[0];
+
+  // For withdrawals, find which message index corresponds to this specific withdrawal
+  if (withdrawalInfo) {
+    const msgIndex = await findWithdrawalIndexInReceipt(
+      sourceToHubMessage,
+      withdrawalInfo,
+      sourceClient,
+    );
+
+    if (msgIndex === null) {
+      console.warn(
+        "Could not find withdrawal in receipt events",
+        withdrawalInfo,
+      );
+      return {
+        step: OVaultTransactionStep.HUB_CHAIN_TRANSACTION,
+      };
+    }
+
+    sourceToHubMessage = sourceToHubMessages[msgIndex];
+  }
+
+  if (
+    sourceToHubMessage.status.name === "INFLIGHT" ||
+    sourceToHubMessage.status.name === "CONFIRMING"
+  ) {
+    return {
+      step: OVaultTransactionStep.SOURCE_TO_HUB_LZ_TRANSACTION,
+    };
+  }
+
+  if (sourceToHubMessage.status.name !== "DELIVERED") {
+    return {
+      step: OVaultTransactionStep.SOURCE_TO_HUB_LZ_TRANSACTION,
+      failureReason: OVaultFailureReason.UNKNOWN,
+    };
+  }
+
+  // Track hub chain transaction
+  const executorDst = sourceToHubMessage.destination as V2Types.ExecutorTx;
+  const composeTxHash = executorDst?.lzCompose?.txs?.[0]
+    ?.txHash as `0x${string}`;
+  if (!composeTxHash) {
+    return {
+      step: OVaultTransactionStep.HUB_CHAIN_TRANSACTION,
+    };
+  }
+  const failedCompose = executorDst?.lzCompose?.failedTx?.[0]
+    ?.txHash as `0x${string}`;
+  if (executorDst?.lzCompose?.status !== "SUCCEEDED" && failedCompose) {
+    return {
+      step: OVaultTransactionStep.HUB_CHAIN_TRANSACTION,
+      failureReason: OVaultFailureReason.UNKNOWN,
+      refunded: false,
+      hubTxHash: failedCompose,
+    };
+  }
+  const hubTx = await getTxStatus(composeTxHash, hubClient);
+
+  const refunded = await isRefunded(composeTxHash, hubClient);
+
+  if (hubTx.success && refunded) {
+    // Something went wrong on the hub chain, but the funds were refunded.
+    return {
+      step: OVaultTransactionStep.HUB_CHAIN_TRANSACTION,
+      refunded: true,
+      failureReason: OVaultFailureReason.UNKNOWN,
+      hubTxHash: composeTxHash,
+    };
+  }
+
+  // Track hub to dst chain transaction
+  const hubToDstLzMessages = await getLzTxStatus(composeTxHash);
+  if (hubToDstLzMessages.length === 0) {
+    return {
+      step: OVaultTransactionStep.HUB_TO_DST_LZ_TRANSACTION,
+      hubTxHash: composeTxHash,
+    };
+  }
+
+  const hubToDstMessage: V2Types.ScanAPIMessage = hubToDstLzMessages[0];
+
+  if (
+    hubToDstMessage.status.name === "INFLIGHT" ||
+    hubToDstMessage.status.name === "CONFIRMING"
+  ) {
+    return {
+      step: OVaultTransactionStep.HUB_TO_DST_LZ_TRANSACTION,
+      hubTxHash: composeTxHash,
+    };
+  }
+
+  if (hubToDstMessage.status.name !== "DELIVERED") {
+    return {
+      step: OVaultTransactionStep.HUB_TO_DST_LZ_TRANSACTION,
+      failureReason: OVaultFailureReason.UNKNOWN,
+      hubTxHash: composeTxHash,
+    };
+  }
+
+  // Track dst chain transaction
+  const dstTxHash = hubToDstMessage.destination?.tx?.txHash as `0x${string}`;
+  if (!dstTxHash) {
+    // Waiting for the dst tx to be created
+    return {
+      step: OVaultTransactionStep.DST_CHAIN_TRANSACTION,
+      hubTxHash: composeTxHash,
+    };
+  }
+
+  const dstTx = await getTxStatus(dstTxHash, dstClient);
+
+  return {
+    step: dstTx.success
+      ? OVaultTransactionStep.COMPLETED
+      : OVaultTransactionStep.DST_CHAIN_TRANSACTION,
+    refunded: false,
+    failureReason: dstTx.error,
+    destinationTxHash: dstTx.success ? dstTxHash : undefined,
+    hubTxHash: composeTxHash,
+  };
+}
+
+/**
+ * Track the OVault transaction
+ * There are 4 possible scenarios:
+ * 1. BBB - source chain, hub chain, dst chain are the same
+ * 2. BBA - source chain, hub chain are the same, dst chain is different
+ * 3. ABB - hub chain, dst chain are the same, source chain is different
+ * 4. ABA - source chain, hub chain, dst chain are different. Source chain can optionally be the same as the dst chain.
+ *
+ * @param txHash - The hash of the transaction to track on the source chain.
+ */
+export async function trackOVaultSyncTransaction(
+  txHash: `0x${string}`,
+  viemConfigs: TrackingChainConfigs,
+  withdrawalInfo?: OVaultWithdrawalInfo,
+) {
+  const { sourceChain, hubChain, dstChain } = viemConfigs;
+  if (sourceChain.id === hubChain.id && sourceChain.id === dstChain.id) {
+    return trackBBB(txHash, viemConfigs);
+  } else if (sourceChain.id === hubChain.id && hubChain.id !== dstChain.id) {
+    return trackBBA(txHash, viemConfigs, withdrawalInfo);
+  } else if (sourceChain.id !== hubChain.id && hubChain.id === dstChain.id) {
+    return trackABB(txHash, viemConfigs, withdrawalInfo);
+  } else {
+    return trackABA(txHash, viemConfigs, withdrawalInfo);
+  }
+}