feat: production release 🚀 (#384)

Author: amateima

packages/indexer-api/src/dtos/deposits.dto.ts

@@ -120,6 +120,7 @@ export type DepositReturnType = {
   fillGasFeeUsd?: string;
   fillGasTokenPriceUsd?: string;
   actionsSucceeded?: boolean | null;
+  actionsTargetChainId?: string;
 
   // from fill
   relayer?: string;

packages/indexer-api/src/services/deposits.ts

@@ -56,6 +56,7 @@ const RelayHashInfoFields = [
     WHEN rhi.includedActions = true AND rhi.status = 'filled' THEN (rhi.callsFailedEventId IS NULL)
     ELSE NULL
   END as "actionsSucceeded"`,
+  `rhi.actionsTargetChainId as "actionsTargetChainId"`,
 ];
 
 const FilledRelayFields = [

packages/indexer-database/src/entities/RelayHashInfo.ts

@@ -153,6 +153,9 @@ export class RelayHashInfo {
   @Column({ nullable: true })
   includedActions: boolean;
 
+  @Column({ nullable: true, type: "bigint" })
+  actionsTargetChainId: string;
+
   @UpdateDateColumn()
   updatedAt: Date;
 }

packages/indexer-database/src/migrations/1758762765600-RelayHashInfo.ts

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class RelayHashInfo1758762765600 implements MigrationInterface {
+  name = "RelayHashInfo1758762765600";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "relay_hash_info" ADD "actionsTargetChainId" bigint`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "relay_hash_info" DROP COLUMN "actionsTargetChainId"`,
+    );
+  }
+}

packages/indexer/src/data-indexing/service/SpokePoolIndexerDataHandler.ts

@@ -26,6 +26,7 @@ import { IntegratorIdMessage } from "../../messaging/IntegratorIdWorker";
 import { getMaxBlockLookBack } from "../../web3/constants";
 import { PriceMessage } from "../../messaging/priceWorker";
 import { EventDecoder } from "../../web3/EventDecoder";
+import { matchFillEventsWithTargetChainActions } from "../../utils/targetChainActionsUtils";
 
 export type FetchEventsResult = {
   v3FundsDepositedEvents: utils.V3FundsDepositedWithIntegradorId[];
@@ -166,6 +167,28 @@ export class SpokePoolIndexerDataHandler implements IndexerDataHandler {
         lastFinalisedBlock,
       );
 
+    // Match fill events with target chain action events
+    const fillTargetChainActionPairs = matchFillEventsWithTargetChainActions(
+      storedEvents.fills.map((f) => f.data),
+      transactionReceipts,
+    );
+
+    if (fillTargetChainActionPairs.length > 0) {
+      this.logger.debug({
+        at: "Indexer#SpokePoolIndexerDataHandler#processBlockRange",
+        message:
+          "Found fill transactions with target chain action destinations",
+        count: fillTargetChainActionPairs.length,
+        pairs: fillTargetChainActionPairs.map((pair) => ({
+          fillEventId: pair.fill.id,
+          transactionHash: pair.fill.transactionHash,
+          destinationChainId: pair.fill.destinationChainId,
+          outputAmount: pair.fill.outputAmount,
+          actionsTargetChainId: pair.actionsTargetChainId,
+        })),
+      });
+    }
+
     //FIXME: Remove performance timing
     const timeToStoreEvents = performance.now();
 
@@ -195,6 +218,7 @@ export class SpokePoolIndexerDataHandler implements IndexerDataHandler {
       deletedDeposits,
       depositSwapPairs,
       fillCallsFailedPairs,
+      fillTargetChainActionPairs,
       fillsGasFee,
     );
 

packages/indexer/src/data-indexing/service/SvmSpokePoolIndexerDataHandler.ts

@@ -142,6 +142,7 @@ export class SvmSpokePoolIndexerDataHandler implements IndexerDataHandler {
       deletedDeposits,
       [], // swapBeforeBridge events
       [], // callsFailed events
+      [], // targetChainAction pairs
       fillsGasFee,
     );
 

packages/indexer/src/services/spokePoolProcessor.ts

@@ -17,6 +17,7 @@ import {
   DepositSwapPair,
   FillCallsFailedPair,
 } from "../data-indexing/service/SpokePoolIndexerDataHandler";
+import { FillTargetChainActionPair } from "../utils/targetChainActionsUtils";
 import { StoreEventsResult } from "../database/SpokePoolRepository";
 import { getDbLockKeyForDeposit } from "../utils";
 
@@ -39,6 +40,7 @@ export class SpokePoolProcessor {
     deletedDeposits: entities.V3FundsDeposited[],
     depositSwapPairs: DepositSwapPair[],
     fillCallsFailedPairs: FillCallsFailedPair[],
+    fillTargetChainActionPairs: FillTargetChainActionPair[],
     fillsGasFee?: Record<string, bigint | undefined>,
   ) {
     // Update relay hash info records related to deleted deposits
@@ -54,6 +56,9 @@ export class SpokePoolProcessor {
     });
     await this.assignSwapEventToRelayHashInfo(depositSwapPairs);
     await this.assignCallsFailedEventToRelayHashInfo(fillCallsFailedPairs);
+    await this.assignTargetChainActionEventToRelayHashInfo(
+      fillTargetChainActionPairs,
+    );
     const timeToAssignSpokeEventsToRelayHashInfoEnd = performance.now();
 
     // Update expired deposits
@@ -548,6 +553,28 @@ export class SpokePoolProcessor {
     );
   }
 
+  /**
+   * Assigns target chain action information to the relay hash info
+   */
+  private async assignTargetChainActionEventToRelayHashInfo(
+    fillTargetChainActionPairs: FillTargetChainActionPair[],
+  ) {
+    const relayHashInfoRepository = this.postgres.getRepository(
+      entities.RelayHashInfo,
+    );
+    await Promise.all(
+      fillTargetChainActionPairs.map((fillTargetChainActionPair) =>
+        relayHashInfoRepository.update(
+          { fillEventId: fillTargetChainActionPair.fill.id },
+          {
+            actionsTargetChainId:
+              fillTargetChainActionPair.actionsTargetChainId,
+          },
+        ),
+      ),
+    );
+  }
+
   private notifyWebhooks(
     deposits: entities.V3FundsDeposited[],
     fills: entities.FilledV3Relay[],

packages/indexer/src/utils/targetChainActionsUtils.ts

@@ -0,0 +1,106 @@
+import { providers } from "ethers";
+import { EventDecoder } from "../web3/EventDecoder";
+import { entities } from "@repo/indexer-database";
+
+export const TARGET_CHAIN_ACTION_ADDRESSES: Record<string, string> = {
+  "0x200000000000000000000000000000000000010C": "1337", // HyperCore
+};
+
+export interface FillTargetChainActionPair {
+  fill: entities.FilledV3Relay;
+  actionsTargetChainId: string;
+}
+
+/**
+ * Matches fill events with Transfer events to target chain action destinations
+ * @param fills - Array of fill events
+ * @param transactionReceipts - Map of transaction receipts
+ * @returns Array of matched fill and target chain action pairs
+ */
+export function matchFillEventsWithTargetChainActions(
+  fills: entities.FilledV3Relay[],
+  transactionReceipts: Record<string, providers.TransactionReceipt>,
+): FillTargetChainActionPair[] {
+  const transactionReceiptsList = Object.values(transactionReceipts);
+  const targetChainActionEvents = transactionReceiptsList
+    .map((transactionReceipt) =>
+      EventDecoder.decodeTransferEvents(transactionReceipt),
+    )
+    .flat();
+
+  const fillsAndTargetChainActionsByTxHash = targetChainActionEvents.reduce(
+    (acc, targetChainAction) => {
+      acc[targetChainAction.transactionHash] = {
+        fills: fills.filter(
+          (f) =>
+            f.transactionHash.toLowerCase() ===
+            targetChainAction.transactionHash.toLowerCase(),
+        ),
+        targetChainActions: targetChainActionEvents.filter(
+          (t) =>
+            t.transactionHash.toLowerCase() ===
+            targetChainAction.transactionHash.toLowerCase(),
+        ),
+      };
+      return acc;
+    },
+    {} as Record<
+      string,
+      {
+        fills: entities.FilledV3Relay[];
+        targetChainActions: any[];
+      }
+    >,
+  );
+
+  // Match fills with their corresponding target chain action events
+  const fillTargetChainActionPairs: FillTargetChainActionPair[] = Object.values(
+    fillsAndTargetChainActionsByTxHash,
+  )
+    .map((fillAndTargetChainAction) => {
+      const { fills: txFills, targetChainActions } = fillAndTargetChainAction;
+      const sortedFills = txFills.sort((a, b) => a.logIndex - b.logIndex);
+      const sortedTargetChainActions = targetChainActions.sort(
+        (a, b) => a.logIndex - b.logIndex,
+      );
+      const matchedPairs: FillTargetChainActionPair[] = [];
+      const usedTargetChainActions = new Set<number>(); // Track used target chain actions by their log index
+
+      sortedFills.forEach((fill) => {
+        const matchingTargetChainAction = sortedTargetChainActions.find(
+          (targetChainAction) =>
+            targetChainAction.logIndex > fill.logIndex &&
+            !usedTargetChainActions.has(targetChainAction.logIndex) &&
+            targetChainAction.args.value.toString() === fill.outputAmount &&
+            Object.keys(TARGET_CHAIN_ACTION_ADDRESSES).some(
+              (targetChainAddress) =>
+                targetChainAction.args.to.toLowerCase() ===
+                targetChainAddress.toLowerCase(),
+            ),
+        );
+        if (matchingTargetChainAction) {
+          // Get the target chain action chain ID
+          const targetChainAddress = Object.keys(
+            TARGET_CHAIN_ACTION_ADDRESSES,
+          ).find(
+            (addr) =>
+              addr.toLowerCase() ===
+              matchingTargetChainAction.args.to.toLowerCase(),
+          );
+          const actionsTargetChainId = targetChainAddress
+            ? TARGET_CHAIN_ACTION_ADDRESSES[targetChainAddress]
+            : null;
+
+          if (actionsTargetChainId) {
+            matchedPairs.push({ fill, actionsTargetChainId });
+            usedTargetChainActions.add(matchingTargetChainAction.logIndex); // Mark this target chain action as used
+          }
+        }
+      });
+
+      return matchedPairs;
+    })
+    .flat();
+
+  return fillTargetChainActionPairs;
+}

packages/indexer/src/web3/EventDecoder.ts

@@ -1,6 +1,10 @@
 import { ethers } from "ethers";
 import { MulticallHandler__factory } from "@across-protocol/contracts";
-import { SwapBeforeBridgeEvent, CallsFailedEvent } from "./model/events";
+import {
+  SwapBeforeBridgeEvent,
+  CallsFailedEvent,
+  TransferEvent,
+} from "./model/events";
 import {
   BASE_SWAP_BEFORE_BRIDGE_ABI,
   SPOKE_POOL_PERIPHERY_SWAP_BEFORE_BRIDGE_ABI,
@@ -47,17 +51,36 @@ export class EventDecoder {
     return events;
   }
 
+  static decodeTransferEvents(receipt: ethers.providers.TransactionReceipt) {
+    const transferEventTopic =
+      "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+    const transferABI = [
+      "event Transfer(address indexed from, address indexed to, uint256 value)",
+    ];
+
+    const events: TransferEvent[] = this.decodeTransactionReceiptLogs(
+      receipt,
+      transferEventTopic,
+      transferABI,
+      true,
+    );
+
+    return events;
+  }
+
   static decodeTransactionReceiptLogs(
     receipt: ethers.providers.TransactionReceipt,
     eventTopic: string,
     abi: any,
+    skipEmptyLogs: boolean = false,
   ) {
     const events: (ethers.providers.Log & { args: any })[] = [];
 
     for (const log of receipt.logs) {
       const contractInterface = new ethers.utils.Interface(abi);
 
-      if (log.topics.length === 0) continue;
+      if (log.topics.length === 0 || (log.data === "0x" && skipEmptyLogs))
+        continue;
 
       try {
         const parsedLog = contractInterface.parseLog(log);

packages/indexer/src/web3/model/events.ts

@@ -19,3 +19,11 @@ export interface CallsFailedEvent extends providers.Log {
     fallbackRecipient: string;
   };
 }
+
+export interface TransferEvent extends providers.Log {
+  args: {
+    from: string;
+    to: string;
+    value: BigNumber;
+  };
+}