feat: production release 🚀 (#314)

Author: amateima

packages/indexer-api/package.json

@@ -22,7 +22,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@across-protocol/sdk": "~4.2.1",
+    "@across-protocol/sdk": "^4.2.8",
     "@repo/error-handling": "workspace:*",
     "@repo/indexer": "workspace:*",
     "@repo/indexer-database": "workspace:*",

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

@@ -38,6 +38,20 @@ export class DepositsController {
     }
   };
 
+  public getDeposit = async (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ) => {
+    try {
+      const params = s.create(req.query, DepositParams);
+      const result = await this.service.getDeposit(params);
+      return res.json(result);
+    } catch (err) {
+      next(err);
+    }
+  };
+
   public getUnfilledDeposits = async (
     req: Request,
     res: Response,

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

@@ -1,4 +1,5 @@
 import * as s from "superstruct";
+import { utils } from "@across-protocol/sdk";
 import { entities } from "@repo/indexer-database";
 
 const stringToInt = s.coerce(s.number(), s.string(), (value) => {
@@ -9,13 +10,28 @@ const stringToInt = s.coerce(s.number(), s.string(), (value) => {
   return parseInt(value, 10);
 });
 
+const parseAddressField = s.coerce(s.string(), s.string(), (value) => {
+  // Try to parse as evm address
+  if (utils.isValidEvmAddress(value.toLowerCase())) {
+    return utils.toAddress(value.toLowerCase());
+  } else {
+    // Try to parse as svm address
+    try {
+      return utils.SvmAddress.from(value).toBase58();
+    } catch (error) {
+      // Otherwise use original value
+      return value;
+    }
+  }
+});
+
 export const DepositsParams = s.object({
-  depositor: s.optional(s.string()),
-  recipient: s.optional(s.string()),
+  depositor: s.optional(parseAddressField),
+  recipient: s.optional(parseAddressField),
   originChainId: s.optional(stringToInt),
   destinationChainId: s.optional(stringToInt),
-  inputToken: s.optional(s.string()),
-  outputToken: s.optional(s.string()),
+  inputToken: s.optional(parseAddressField),
+  outputToken: s.optional(parseAddressField),
   integratorId: s.optional(s.string()),
   status: s.optional(s.enums(Object.values(entities.RelayStatus))),
   // some kind of pagination options, skip could be the start point

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

@@ -9,6 +9,7 @@ export function getRouter(db: DataSource, redis: Redis): Router {
   const service = new DepositsService(db, redis);
   const controller = new DepositsController(service);
   router.get("/deposits", controller.getDeposits);
+  router.get("/deposit", controller.getDeposit);
   router.get("/deposit/status", controller.getDepositStatus);
   router.get("/deposits/unfilled", controller.getUnfilledDeposits);
   router.get("/deposits/filled", controller.getFilledDeposits);

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

@@ -285,6 +285,108 @@ export class DepositsService {
     return result;
   }
 
+  public async getDeposit(params: DepositParams) {
+    // in the validation rules each of these params are marked as optional
+    // but we need to check that at least one of them is present
+    if (
+      !(
+        (params.depositId && params.originChainId) ||
+        params.depositTxHash ||
+        params.relayDataHash
+      )
+    ) {
+      throw new IncorrectQueryParamsException();
+    }
+
+    // construct cache key
+    const cacheKey = this.getDepositCacheKey(params);
+    const cachedData = await this.redis.get(cacheKey);
+
+    if (cachedData) {
+      return JSON.parse(cachedData);
+    }
+
+    // no cached data, so we need to query the database
+    const repo = this.db.getRepository(entities.RelayHashInfo);
+    const queryBuilder = repo.createQueryBuilder("rhi");
+
+    queryBuilder.leftJoinAndSelect(
+      entities.V3FundsDeposited,
+      "deposit",
+      "rhi.depositEventId = deposit.id",
+    );
+    queryBuilder.leftJoinAndSelect(
+      entities.SwapBeforeBridge,
+      "swap",
+      "swap.id = rhi.swapBeforeBridgeEventId",
+    );
+    queryBuilder.leftJoinAndSelect(
+      entities.FilledV3Relay,
+      "fill",
+      "fill.id = rhi.fillEventId",
+    );
+
+    if (params.depositId && params.originChainId) {
+      queryBuilder.andWhere(
+        "rhi.depositId = :depositId AND rhi.originChainId = :originChainId",
+        {
+          depositId: params.depositId,
+          originChainId: params.originChainId,
+        },
+      );
+    }
+
+    if (params.depositTxHash) {
+      queryBuilder.andWhere("rhi.depositTxHash = :depositTxHash", {
+        depositTxHash: params.depositTxHash,
+      });
+    }
+
+    if (params.relayDataHash) {
+      queryBuilder.andWhere("rhi.relayHash = :relayDataHash", {
+        relayDataHash: params.relayDataHash,
+      });
+    }
+
+    const matchingRelays = await queryBuilder
+      .orderBy("rhi.depositEventId", "ASC")
+      .select([
+        ...DepositFields,
+        ...RelayHashInfoFields,
+        ...SwapBeforeBridgeFields,
+        ...FilledRelayFields,
+      ])
+      .execute();
+    const numberMatchingRelays = matchingRelays.length;
+    if (numberMatchingRelays === 0) throw new DepositNotFoundException();
+    const relay = matchingRelays[params.index];
+    if (!relay) {
+      throw new IndexParamOutOfRangeException(
+        `Index ${params.index} out of range. Index must be between 0 and ${numberMatchingRelays - 1}`,
+      );
+    }
+
+    const result = {
+      deposit: {
+        ...relay,
+      },
+      pagination: {
+        currentIndex: params.index,
+        maxIndex: numberMatchingRelays - 1,
+      },
+    };
+
+    if (this.shouldCacheDepositResponse(relay)) {
+      await this.redis.set(
+        cacheKey,
+        JSON.stringify(result),
+        "EX",
+        this.getDepositCacheTTLSeconds(relay),
+      );
+    }
+    return result;
+  }
+
   public async getUnfilledDeposits(
     params: FilterDepositsParams,
   ): Promise<ParsedDepositReturnType[]> {
@@ -493,6 +595,27 @@ export class DepositsService {
     }
   }
 
+  private getDepositCacheTTLSeconds(deposit: DepositReturnType) {
+    const minute = 60;
+    const hour = 60 * minute;
+    const day = 24 * hour;
+
+    if (
+      deposit.status === entities.RelayStatus.Filled &&
+      deposit.depositBlockTimestamp &&
+      deposit.fillBlockTimestamp &&
+      deposit.bridgeFeeUsd
+    ) {
+      return hour;
+    }
+
+    if (deposit.status === entities.RelayStatus.Refunded) {
+      return hour;
+    }
+
+    return 0;
+  }
+
   private shouldCacheDepositStatusResponse(status: entities.RelayStatus) {
     return [
       entities.RelayStatus.Expired,
@@ -502,6 +625,23 @@ export class DepositsService {
     ].includes(status);
   }
 
+  private shouldCacheDepositResponse(deposit: DepositReturnType) {
+    if (
+      deposit.status === entities.RelayStatus.Filled &&
+      deposit.depositBlockTimestamp &&
+      deposit.fillBlockTimestamp &&
+      deposit.bridgeFeeUsd
+    ) {
+      return true;
+    }
+
+    if (deposit.status === entities.RelayStatus.Refunded) {
+      return true;
+    }
+
+    return false;
+  }
+
   private getDepositStatusCacheKey(params: DepositParams) {
     if (params.depositId && params.originChainId) {
       return `depositStatus-${params.depositId}-${params.originChainId}-${params.index}`;
@@ -519,4 +659,20 @@ export class DepositsService {
       "Could not get deposit status: could not locate cache data",
     );
   }
+
+  private getDepositCacheKey(params: DepositParams) {
+    if (params.depositId && params.originChainId) {
+      return `deposit-${params.depositId}-${params.originChainId}-${params.index}`;
+    }
+    if (params.depositTxHash) {
+      return `deposit-${params.depositTxHash}-${params.index}`;
+    }
+    if (params.relayDataHash) {
+      return `deposit-${params.relayDataHash}-${params.index}`;
+    }
+
+    // in theory this should never happen because we have already checked
+    // that at least one of the params is present
+    throw new Error("Could not get deposit: could not locate cache data");
+  }
 }

packages/indexer-api/src/tests/deposit.test.ts

@@ -0,0 +1,68 @@
+import { expect } from "chai";
+import request from "supertest";
+import { ExpressApp } from "../express-app";
+import express from "express";
+import {
+  createDataSource,
+  DataSource,
+  entities,
+  fixtures,
+} from "@repo/indexer-database";
+import Redis from "ioredis";
+import * as Indexer from "@repo/indexer";
+import * as utils from "../utils";
+import * as routers from "../routers";
+
+describe("/deposit", () => {
+  let app: express.Express;
+  let dataSource: DataSource;
+  let redis: Redis;
+  let depositsFixture: fixtures.FundsDepositedFixture;
+  let relayHashInfoFixture: fixtures.RelayHashInfoFixture;
+
+  before(async () => {
+    // Set up database and Redis
+    const databaseConfig = utils.getPostgresConfig(process.env);
+    dataSource = await createDataSource(databaseConfig).initialize();
+
+    const redisConfig = Indexer.parseRedisConfig(process.env);
+    redis = new Redis(redisConfig);
+
+    // Initialize fixtures
+    depositsFixture = new fixtures.FundsDepositedFixture(dataSource);
+    relayHashInfoFixture = new fixtures.RelayHashInfoFixture(dataSource);
+    await depositsFixture.deleteAllDeposits();
+    await relayHashInfoFixture.deleteAllRelayHashInfoRows();
+
+    // Initialize the Express app with the deposits router
+    const depositsRouter = routers.deposits.getRouter(dataSource, redis);
+    app = ExpressApp({ deposits: depositsRouter });
+  });
+
+  after(async () => {
+    // Clean up resources
+    await depositsFixture.deleteAllDeposits();
+    await dataSource.destroy();
+    await redis.quit();
+  });
+
+  it("should return 200 and one deposit by depositId and originChainId", async () => {
+    // Insert a test deposit
+    const [deposit] = await depositsFixture.insertDeposits([]);
+    const relayHashInfoData = {
+      id: 1,
+      depositId: deposit.depositId,
+      originChainId: deposit.originChainId,
+      depositEventId: deposit.id,
+      status: entities.RelayStatus.Unfilled,
+    };
+    await relayHashInfoFixture.insertRelayHashInfos([relayHashInfoData]);
+    const response = await request(app).get("/deposit").query({
+      depositId: deposit.depositId,
+      originChainId: deposit.originChainId,
+    });
+    console.log(response.body);
+    expect(response.status).to.equal(200);
+    expect(response.body.deposit.id).to.equal(deposit.id);
+  });
+});

packages/indexer-database/package.json

@@ -25,7 +25,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@across-protocol/sdk": "~4.2.1",
+    "@across-protocol/sdk": "^4.2.8",
     "pg": "^8.4.0",
     "reflect-metadata": "^0.1.13",
     "superstruct": "2.0.3-1",

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

@@ -40,7 +40,7 @@ export class ExecutedRelayerRefundRoot {
   @Column({ nullable: true })
   deferredRefunds: boolean;
 
-  @Column()
+  @Column({ nullable: true })
   caller: string;
 
   @Column()

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

@@ -13,6 +13,12 @@ import { RelayHashInfo } from "../RelayHashInfo";
 @Entity({ schema: "evm" })
 @Unique("UK_filledV3Relay_internalHash", ["internalHash"])
 @Index("IX_filledV3Relay_blockTimestamp", ["blockTimestamp"])
+@Index("IX_filledV3Relay_relayer", ["relayer"])
+@Index("IX_filledV3Relay_destinationChainId", ["destinationChainId"])
+@Index("IX_filledV3Relay_depositId_originChainId", [
+  "depositId",
+  "originChainId",
+])
 export class FilledV3Relay {
   @PrimaryGeneratedColumn()
   id: number;

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

@@ -17,8 +17,8 @@ export class RequestedSpeedUpV3Deposit {
   @PrimaryGeneratedColumn()
   id: number;
 
-  @Column()
-  originChainId: number;
+  @Column({ type: "bigint" })
+  originChainId: string;
 
   @Column({ type: "decimal" })
   depositId: string;