Leaderboard on GraphQL

* checkpoint

* compiles

* looks like it works

* fix

* fix

Author: llamalm

packages/api/schema.graphql

@@ -38,6 +38,17 @@ type MarketType {
   vaultAddress: String!
 }
 
+type PnLType {
+  epochId: Int!
+  openPositionsPnL: String!
+  owner: String!
+  positionCount: Int!
+  positions: [Int!]!
+  totalDeposits: String!
+  totalPnL: String!
+  totalWithdrawals: String!
+}
+
 type PositionType {
   baseToken: String!
   borrowedBaseToken: String
@@ -59,6 +70,7 @@ type PositionType {
 
 type Query {
   epochs(marketId: Int): [EpochType!]!
+  getEpochLeaderboard(address: String!, chainId: Int!, epochId: String!): [PnLType!]!
   indexCandles(address: String!, chainId: Int!, epochId: String!, from: Int!, interval: Int!, to: Int!): [CandleType!]!
   indexPriceAtTime(address: String!, chainId: Int!, epochId: String!, timestamp: Int!): CandleType
   legacyMarketCandles(address: String!, chainId: Int!, epochId: String!, from: Int!, interval: Int!, to: Int!): [CandleType!]!

packages/api/src/graphql/resolvers/PnLResolver.ts

@@ -0,0 +1,38 @@
+import { Resolver, Query, Arg, Int } from 'type-graphql';
+import { PnLType } from '../types';
+import { PnLPerformance } from '../../performance';
+
+@Resolver(() => PnLType)
+export class PnLResolver {
+  @Query(() => [PnLType])
+  async getEpochLeaderboard(
+    @Arg('chainId', () => Int) chainId: number,
+    @Arg('address', () => String) address: string,
+    @Arg('epochId', () => String) epochId: string
+  ): Promise<PnLType[]> {
+    try {
+      const pnlPerformance = PnLPerformance.getInstance();
+      const pnlData = await pnlPerformance.getEpochPnLs(
+        chainId,
+        address,
+        parseInt(epochId)
+      );
+
+      return pnlData.map((pnl) => {
+        return {
+          epochId: parseInt(epochId),
+          owner: pnl.owner,
+          totalDeposits: pnl.totalDeposits.toString(),
+          totalWithdrawals: pnl.totalWithdrawals.toString(),
+          openPositionsPnL: pnl.openPositionsPnL.toString(),
+          totalPnL: pnl.totalPnL.toString(),
+          positions: Array.from(pnl.positionIds),
+          positionCount: pnl.positionCount,
+        };
+      });
+    } catch (error) {
+      console.error('Error fetching epochs:', error);
+      throw new Error('Failed to fetch epochs');
+    }
+  }
+}

packages/api/src/graphql/resolvers/index.ts

@@ -4,3 +4,4 @@ export { PositionResolver } from './PositionResolver';
 export { TransactionResolver } from './TransactionResolver';
 export { EpochResolver } from './EpochResolver';
 export { CandleResolver } from './CandleResolver';
+export { PnLResolver } from './PnLResolver';

packages/api/src/graphql/startApolloServer.ts

@@ -9,6 +9,7 @@ import {
   ResourceResolver,
   TransactionResolver,
   CandleResolver,
+  PnLResolver,
 } from './resolvers';
 
 export const initializeApolloServer = async () => {
@@ -21,6 +22,7 @@ export const initializeApolloServer = async () => {
       TransactionResolver,
       EpochResolver,
       CandleResolver,
+      PnLResolver,
     ],
     emitSchemaFile: true,
     validate: false,

packages/api/src/graphql/types/PnLType.ts

@@ -0,0 +1,29 @@
+import { Field, ObjectType, Int, Directive } from 'type-graphql';
+
+@Directive('@cacheControl(maxAge: 3)')
+@ObjectType()
+export class PnLType {
+  @Field(() => Int)
+  epochId: number;
+
+  @Field(() => String)
+  owner: string;
+
+  @Field(() => String)
+  totalDeposits: string;
+
+  @Field(() => String)
+  totalWithdrawals: string;
+
+  @Field(() => String)
+  openPositionsPnL: string;
+
+  @Field(() => String)
+  totalPnL: string;
+
+  @Field(() => [Int])
+  positions: number[];
+
+  @Field(() => Int)
+  positionCount: number;
+}

packages/api/src/graphql/types/index.ts

@@ -5,3 +5,4 @@ export { TransactionType } from './TransactionType';
 export { EpochType } from './EpochType';
 export { ResourcePriceType } from './ResourcePriceType';
 export { CandleType } from './CandleType';
+export { PnLType } from './PnLType';

packages/api/src/helpers/positionPnL.ts

@@ -0,0 +1,47 @@
+import { PublicClient } from 'viem';
+
+export const calculateOpenPositionValue = async (
+  positionId: number,
+  marketAddress: string,
+  client: PublicClient
+): Promise<bigint> => {
+  const collateralValue = await client.readContract({
+    address: marketAddress as `0x${string}`,
+    abi: [
+      {
+        type: 'function',
+        name: 'getPositionCollateralValue',
+        inputs: [
+          {
+            name: 'positionId',
+            type: 'uint256',
+            internalType: 'uint256',
+          },
+        ],
+        outputs: [
+          {
+            name: 'collateralValue',
+            type: 'uint256',
+            internalType: 'uint256',
+          },
+        ],
+        stateMutability: 'view',
+      },
+      {
+        inputs: [
+          {
+            internalType: 'uint256',
+            name: 'positionId',
+            type: 'uint256',
+          },
+        ],
+        type: 'error',
+        name: 'InvalidPositionId',
+      },
+    ],
+    functionName: 'getPositionCollateralValue',
+    args: [BigInt(positionId)],
+  });
+
+  return collateralValue;
+};

packages/api/src/performance/helper.ts

@@ -148,3 +148,24 @@ export function maxBigInt(a: bigint, b: bigint) {
 export function minBigInt(a: bigint, b: bigint) {
   return a < b ? a : b;
 }
+
+export function startOfCurrentInterval(
+  timestamp: number,
+  interval: number
+): number {
+  return Math.floor(timestamp / interval) * interval;
+}
+
+export function startOfNextInterval(
+  timestamp: number,
+  interval: number
+): number {
+  return (Math.floor(timestamp / interval) + 1) * interval;
+}
+
+export function getTimeWindow(from: number, to: number, interval: number) {
+  return {
+    from: startOfCurrentInterval(from, interval),
+    to: startOfNextInterval(to, interval),
+  };
+}

packages/api/src/performance/index.ts

@@ -1,2 +1,3 @@
 export * from './resourcePerformance';
 export * from './resourcePerformanceManager';
+export * from './pnlPerformance';