feat: swap flow initialized event

packages/indexer-database/src/entities/evm/SwapFlowInitialized.ts

@@ -0,0 +1,78 @@
+import {
+  Column,
+  Entity,
+  PrimaryGeneratedColumn,
+  Index,
+  CreateDateColumn,
+  DeleteDateColumn,
+  Unique,
+} from "typeorm";
+
+@Entity({ schema: "evm" })
+@Unique("UK_swapFlowInitialized_chain_block_tx_log", [
+  "chainId",
+  "blockNumber",
+  "transactionHash",
+  "logIndex",
+])
+@Index("IX_SwapFlowInitialized_chainId", ["chainId"])
+@Index("IX_SwapFlowInitialized_quoteNonce", ["quoteNonce"])
+@Index("IX_SwapFlowInitialized_finalRecipient", ["finalRecipient"])
+@Index("IX_SwapFlowInitialized_blockNumber", ["blockNumber"])
+@Index("IX_SwapFlowInitialized_createdAt", ["createdAt"])
+@Index("IX_SwapFlowInitialized_deletedAt", ["deletedAt"])
+export class SwapFlowInitialized {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  chainId: string;
+
+  @Column({ nullable: true })
+  quoteNonce: string;
+
+  @Column()
+  finalRecipient: string;
+
+  @Column()
+  finalToken: string;
+
+  @Column({ type: "bigint" })
+  evmAmountIn: string;
+
+  @Column({ type: "bigint" })
+  bridgingFeesIncurred: string;
+
+  @Column({ type: "bigint" })
+  coreAmountIn: string;
+
+  @Column()
+  minAmountToSend: string;
+
+  @Column()
+  maxAmountToSend: string;
+
+  @Column()
+  blockNumber: number;
+
+  @Column()
+  transactionHash: string;
+
+  @Column()
+  transactionIndex: number;
+
+  @Column()
+  logIndex: number;
+
+  @Column()
+  finalised: boolean;
+
+  @Column()
+  blockTimestamp: Date;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @DeleteDateColumn({ nullable: true })
+  deletedAt?: Date;
+}

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

@@ -44,3 +44,4 @@ export * from "./OftTransfer";
 
 // HyperEVM
 export * from "./evm/SimpleTransferFlowCompleted";
+export * from "./evm/SwapFlowInitialized";

packages/indexer-database/src/main.ts

@@ -75,6 +75,7 @@ export const createDataSource = (config: DatabaseConfig): DataSource => {
       entities.OftTransfer,
       // HyperEVM
       entities.SimpleTransferFlowCompleted,
+      entities.SwapFlowInitialized,
     ],
     migrationsTableName: "_migrations",
     migrations: ["migrations/*.ts"],

packages/indexer/src/data-indexing/adapter/hyper-evm/model.ts

@@ -19,6 +19,19 @@ export type SimpleTransferFlowCompleted = {
 export type SimpleTransferFlowCompletedWithBlock = SimpleTransferFlowCompleted &
   Block;
 
+export type SwapFlowInitialized = {
+  quoteNonce: string;
+  finalRecipient: string;
+  finalToken: string;
+  evmAmountIn: string;
+  bridgingFeesIncurred: string;
+  coreAmountIn: string;
+  minAmountToSend: string;
+  maxAmountToSend: string;
+};
+
+export type SwapFlowInitializedWithBlock = SwapFlowInitialized & Block;
+
 export const SimpleTransferFlowCompletedABI = new utils.Interface([
   `event SimpleTransferFlowCompleted(
     bytes32 indexed quoteNonce,
@@ -29,3 +42,16 @@ export const SimpleTransferFlowCompletedABI = new utils.Interface([
     uint256 evmAmountSponsored
   )`,
 ]);
+
+export const SwapFlowInitializedABI = new utils.Interface([
+  `event SwapFlowInitialized(
+    bytes32 indexed quoteNonce,
+    address indexed finalRecipient,
+    address indexed finalToken,
+    uint256 evmAmountIn,
+    uint256 bridgingFeesIncurred,
+    uint256 coreAmountIn,
+    uint64 minAmountToSend,
+    uint64 maxAmountToSend
+  )`,
+]);

packages/indexer/src/data-indexing/adapter/hyper-evm/service.ts

@@ -5,6 +5,9 @@ import {
   SimpleTransferFlowCompleted,
   SimpleTransferFlowCompletedABI,
   SimpleTransferFlowCompletedWithBlock,
+  SwapFlowInitialized,
+  SwapFlowInitializedABI,
+  SwapFlowInitializedWithBlock,
 } from "./model";
 
 // we need to fetch only recent events, so
@@ -66,3 +69,38 @@ export async function getSimpleTransferFlowCompletedEvents(
     };
   });
 }
+
+export async function getSwapFlowInitializedEvents(
+  provider: ethers.providers.JsonRpcProvider,
+  address: string,
+  fromBlock: number,
+  toBlock: number,
+): Promise<SwapFlowInitializedWithBlock[]> {
+  const eventFilter = {
+    address,
+    topics: [SwapFlowInitializedABI.getEventTopic("SwapFlowInitialized")],
+  };
+  const logs = await provider.getLogs({
+    ...eventFilter,
+    fromBlock,
+    toBlock,
+  });
+
+  return logs.map((log) => {
+    const decodedLog = SwapFlowInitializedABI.parseLog(log);
+    return {
+      quoteNonce: decodedLog.args.quoteNonce,
+      finalRecipient: decodedLog.args.finalRecipient,
+      finalToken: decodedLog.args.finalToken,
+      evmAmountIn: decodedLog.args.evmAmountIn.toString(),
+      bridgingFeesIncurred: decodedLog.args.bridgingFeesIncurred.toString(),
+      coreAmountIn: decodedLog.args.coreAmountIn.toString(),
+      minAmountToSend: decodedLog.args.minAmountToSend.toString(),
+      maxAmountToSend: decodedLog.args.maxAmountToSend.toString(),
+      blockNumber: log.blockNumber,
+      logIndex: log.logIndex,
+      transactionIndex: log.transactionIndex,
+      transactionHash: log.transactionHash,
+    };
+  });
+}

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

@@ -7,12 +7,18 @@ import { SimpleTransferFlowCompletedRepository } from "../../database/SimpleTran
 import {
   getIndexingStartBlockNumber,
   getSimpleTransferFlowCompletedEvents,
+  getSwapFlowInitializedEvents,
   HYPERCORE_FLOW_EXECUTOR_ADDRESS,
 } from "../adapter/hyper-evm/service";
-import { SimpleTransferFlowCompletedWithBlock } from "../adapter/hyper-evm/model";
+import {
+  SimpleTransferFlowCompletedWithBlock,
+  SwapFlowInitializedWithBlock,
+} from "../adapter/hyper-evm/model";
+import { SwapFlowInitializedRepository } from "../../database/SwapFlowInitializedRepository";
 
 export type FetchEventsResult = {
   simpleTransferFlowCompletedEvents: SimpleTransferFlowCompletedWithBlock[];
+  swapFlowInitializedEvents: SwapFlowInitializedWithBlock[];
   blocks: Record<string, providers.Block>;
 };
 export type StoreEventsResult = {};
@@ -25,6 +31,7 @@ export class HyperEVMIndexerDataHandler implements IndexerDataHandler {
     private chainId: number,
     private provider: across.providers.RetryProvider,
     private simpleTransferFlowCompletedRepository: SimpleTransferFlowCompletedRepository,
+    private swapFlowInitializedRepository: SwapFlowInitializedRepository,
   ) {
     this.isInitialized = false;
   }
@@ -61,10 +68,16 @@ export class HyperEVMIndexerDataHandler implements IndexerDataHandler {
     const events = await this.fetchEventsByRange(blockRange);
     await this.storeEvents(events, lastFinalisedBlock);
     const timeToStoreEvents = performance.now();
-    await this.simpleTransferFlowCompletedRepository.deleteUnfinalisedSimpleTransferFlowCompletedEvents(
-      this.chainId,
-      lastFinalisedBlock,
-    );
+    await Promise.all([
+      this.simpleTransferFlowCompletedRepository.deleteUnfinalisedSimpleTransferFlowCompletedEvents(
+        this.chainId,
+        lastFinalisedBlock,
+      ),
+      this.swapFlowInitializedRepository.deleteUnfinalisedSwapFlowInitializedEvents(
+        this.chainId,
+        lastFinalisedBlock,
+      ),
+    ]);
     const timeToDeleteEvents = performance.now();
     const finalPerfTime = performance.now();
 
@@ -91,27 +104,40 @@ export class HyperEVMIndexerDataHandler implements IndexerDataHandler {
       });
       return {
         simpleTransferFlowCompletedEvents: [],
+        swapFlowInitializedEvents: [],
         blocks: {},
       };
     }
-    const simpleTransferFlowCompletedEvents =
-      await getSimpleTransferFlowCompletedEvents(
-        this.provider,
-        address,
-        blockRange.from,
-        blockRange.to,
-      );
+    const [simpleTransferFlowCompletedEvents, swapFlowInitializedEvents] =
+      await Promise.all([
+        getSimpleTransferFlowCompletedEvents(
+          this.provider,
+          address,
+          blockRange.from,
+          blockRange.to,
+        ),
+        getSwapFlowInitializedEvents(
+          this.provider,
+          address,
+          blockRange.from,
+          blockRange.to,
+        ),
+      ]);
 
     const blocks = await this.getBlocks([
-      ...new Set(
-        simpleTransferFlowCompletedEvents.map((event) =>
+      ...new Set([
+        ...simpleTransferFlowCompletedEvents.map((event) =>
           event.blockNumber.toString(),
         ),
-      ),
+        ...swapFlowInitializedEvents.map((event) =>
+          event.blockNumber.toString(),
+        ),
+      ]),
     ]);
 
     return {
       simpleTransferFlowCompletedEvents,
+      swapFlowInitializedEvents,
       blocks,
     };
   }
@@ -135,15 +161,27 @@ export class HyperEVMIndexerDataHandler implements IndexerDataHandler {
     events: FetchEventsResult,
     lastFinalisedBlock: number,
   ): Promise<StoreEventsResult> {
-    const { simpleTransferFlowCompletedEvents, blocks } = events;
+    const {
+      simpleTransferFlowCompletedEvents,
+      swapFlowInitializedEvents,
+      blocks,
+    } = events;
     const blocksTimestamps = this.getBlocksTimestamps(blocks);
 
-    await this.simpleTransferFlowCompletedRepository.formatAndSaveSimpleTransferFlowCompletedEvents(
-      simpleTransferFlowCompletedEvents,
-      lastFinalisedBlock,
-      this.chainId,
-      blocksTimestamps,
-    );
+    await Promise.all([
+      this.simpleTransferFlowCompletedRepository.formatAndSaveSimpleTransferFlowCompletedEvents(
+        simpleTransferFlowCompletedEvents,
+        lastFinalisedBlock,
+        this.chainId,
+        blocksTimestamps,
+      ),
+      this.swapFlowInitializedRepository.formatAndSaveSwapFlowInitializedEvents(
+        swapFlowInitializedEvents,
+        lastFinalisedBlock,
+        this.chainId,
+        blocksTimestamps,
+      ),
+    ]);
 
     return {};
   }

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

@@ -11,6 +11,7 @@ import { Indexer, EvmIndexer } from "./Indexer";
 import { RetryProvidersFactory } from "../../web3/RetryProvidersFactory";
 import { HyperEVMIndexerDataHandler } from "./HyperEVMIndexerDataHandler";
 import { SimpleTransferFlowCompletedRepository } from "../../database/SimpleTransferFlowCompletedRepository";
+import { SwapFlowInitializedRepository } from "../../database/SwapFlowInitializedRepository";
 
 const MAX_BLOCK_RANGE_SIZE = 1000;
 
@@ -23,6 +24,7 @@ export class HyperEVMIndexerManager {
     private postgres: DataSource,
     private retryProvidersFactory: RetryProvidersFactory,
     private simpleTransferFlowCompletedRepository: SimpleTransferFlowCompletedRepository,
+    private swapFlowInitializedRepository: SwapFlowInitializedRepository,
     private testNet: boolean = false,
   ) {}
 
@@ -65,6 +67,7 @@ export class HyperEVMIndexerManager {
       chainId,
       provider,
       this.simpleTransferFlowCompletedRepository,
+      this.swapFlowInitializedRepository,
     );
     const indexer = new EvmIndexer(
       {

packages/indexer/src/data-indexing/tests/HyperEVMIndexerDataHandler.integration.test.ts

@@ -6,6 +6,7 @@ import * as sinon from "sinon";
 import { getTestDataSource } from "../../tests/setup";
 import { HyperEVMIndexerDataHandler } from "../service/HyperEVMIndexerDataHandler";
 import { SimpleTransferFlowCompletedRepository } from "../../database/SimpleTransferFlowCompletedRepository";
+import { SwapFlowInitializedRepository } from "../../database/SwapFlowInitializedRepository";
 import { BlockRange } from "../model";
 import { createTestRetryProvider } from "../../tests/testProvider";
 import { entities } from "../../../../indexer-database/dist/src";
@@ -14,6 +15,7 @@ import { CHAIN_IDs } from "@across-protocol/constants";
 describe("HyperEVMIndexerDataHandler", () => {
   let dataSource: DataSource;
   let simpleTransferFlowCompletedRepository: SimpleTransferFlowCompletedRepository;
+  let swapFlowInitializedRepository: SwapFlowInitializedRepository;
   let logger: Logger;
   let provider: across.providers.RetryProvider;
   let handler: HyperEVMIndexerDataHandler;
@@ -30,13 +32,18 @@ describe("HyperEVMIndexerDataHandler", () => {
 
     simpleTransferFlowCompletedRepository =
       new SimpleTransferFlowCompletedRepository(dataSource, logger);
+    swapFlowInitializedRepository = new SwapFlowInitializedRepository(
+      dataSource,
+      logger,
+    );
     provider = createTestRetryProvider(CHAIN_IDs.HYPEREVM_TESTNET, logger);
 
     handler = new HyperEVMIndexerDataHandler(
       logger,
       CHAIN_IDs.HYPEREVM_TESTNET,
       provider,
       simpleTransferFlowCompletedRepository,
+      swapFlowInitializedRepository,
     );
   });