[PFT-709] Add function to get referral data for partners

src/common/subgraphMapper.ts

@@ -5,6 +5,7 @@ import {
   Position,
   PriceFeedSnapshot,
   PythData,
+  Referral,
   Token,
   Vault,
   VaultPosition,
@@ -294,3 +295,31 @@ export const mapVaultsArrayToInterface = (response: any): Vault[] | undefined =>
     throw error;
   }
 };
+
+export const mapReferralDataToInterface = (response: any): Referral | undefined => {
+  try {
+    return {
+      id: response.id,
+      partner: response.partner ? mapSubgraphResponseToAccountInterface(response.partner) : undefined,
+      referredUser: response.partner ? mapSubgraphResponseToAccountInterface(response.partner) : undefined,
+      sizeInUsd: response.sizeInUsd,
+      timestamp: response.timestamp,
+      txHash: response.txHash,
+      referralRewardsInUsd: response.referralRewardsInUsd,
+    };
+  } catch (error) {
+    console.log('Error while mapping data', error);
+    throw error;
+  }
+};
+
+export const mapReferralsArrayToInterface = (response: any): Referral[] | undefined => {
+  try {
+    return response.referrals.map((referral: Referral) => {
+      return mapReferralDataToInterface(referral);
+    });
+  } catch (error) {
+    console.log('Error while mapping data', error);
+    throw error;
+  }
+};

src/interfaces/subgraphTypes.ts

@@ -1,3 +1,8 @@
+//// NOTE: All fields from the subgraph interfaces have their type as string
+//// and are marked as optional. This is because the logic to fetch these data might
+//// differ based on the requirement or function, and only required fields are fetched
+//// with queries to keep it concise and avoid fetching unnecessary data.
+
 ////////////////////////////////////////////////////////////////
 ////////////////////    ENUMS     //////////////////////////////
 ////////////////////////////////////////////////////////////////
@@ -51,10 +56,10 @@ export interface Account {
   referralFeesInUsd?: string;
 
   // " Total Realized P&L from Positions in USD "
-  totalRealizedPnlPositions: string
+  totalRealizedPnlPositions?: string;
 
   // " Total Realized P&L from Vaults in USD "
-  totalRealizedPnlVaults: string
+  totalRealizedPnlVaults?: string;
 }
 
 ////////////////////////////////////////////////////////////////
@@ -525,3 +530,27 @@ export interface VaultPosition {
 export interface VaultPositionsResponse {
   vaultPositions: VaultPosition[];
 }
+
+// Subgraph interface for partner referrals
+export interface Referral {
+  // " Partner (Referrer) address + Referred address + log Index "
+  id?: string;
+
+  // " Partner (Referrer) address that referred another user "
+  partner?: Account;
+
+  // " Referred user - User that was referred by the partner"
+  referredUser?: Account;
+
+  // " Position Size in USD "
+  sizeInUsd?: string;
+
+  // " Timestamp "
+  timestamp?: string;
+
+  // " Transaction hash of the create position tx for user referral "
+  txHash?: string;
+
+  // " Referral rewards in USD "
+  referralRewardsInUsd?: string;
+}

src/subgraph/index.ts

@@ -1,4 +1,10 @@
-import { getAllOrdersByUserAddress, getAllPendingOrders, getOrderById, getPythPriceIdsForOrderIds } from './orders';
+import {
+  getAllOrdersByUserAddress,
+  getAllPendingOrders,
+  getOrderById,
+  getPythPriceIdsForOrderIds,
+  getReferralDataForPartner,
+} from './orders';
 import { PythConfig, RpcConfig, SubgraphConfig } from '../interfaces/classConfigs';
 import {
   getAllPositionsByUserAddress,
@@ -13,7 +19,7 @@ import {
   getTotalUnrealizedPnlInUsd,
 } from './positions';
 import { getAllMarketsFromSubgraph, getMarketById } from './markets';
-import { Market, Order, Position, Vault } from '../interfaces/subgraphTypes';
+import { Market, Order, Position, Referral, Vault } from '../interfaces/subgraphTypes';
 import { Chain } from '@parifi/references';
 import request, { GraphQLClient } from 'graphql-request';
 import { getPublicSubgraphEndpoint } from './common';
@@ -22,6 +28,7 @@ import {
   getTotalPoolsValue,
   getUserTotalPoolsValue,
   getUserVaultDataByChain,
+  getVaultApr,
   getVaultDataByChain,
 } from './vaults';
 import { Pyth } from '../pyth';
@@ -222,4 +229,18 @@ export class Subgraph {
     const subgraphEndpoint = this.getSubgraphEndpoint(this.rpcConfig.chainId);
     return await getUserTotalPoolsValue(userAddress, this.rpcConfig.chainId, subgraphEndpoint, this.pyth.pythClient);
   }
+
+  public async getVaultApr(vaultId: string): Promise<{ apr7Days: Decimal; apr30Days: Decimal; aprAllTime: Decimal }> {
+    const subgraphEndpoint = this.getSubgraphEndpoint(this.rpcConfig.chainId);
+    return await getVaultApr(subgraphEndpoint, vaultId);
+  }
+
+  public async getReferralDataForPartner(
+    partnerAddress: string,
+    count: number = 20,
+    skip: number = 0,
+  ): Promise<Referral[]> {
+    const subgraphEndpoint = this.getSubgraphEndpoint(this.rpcConfig.chainId);
+    return await getReferralDataForPartner(subgraphEndpoint, partnerAddress, count, skip);
+  }
 }

src/subgraph/orders/index.ts

@@ -1,12 +1,17 @@
 import { request } from 'graphql-request';
-import { Order } from '../../interfaces/subgraphTypes';
+import { Order, Referral } from '../../interfaces/subgraphTypes';
 import {
   fetchOrdersByIdQuery,
   fetchOrdersByUserQuery,
+  fetchPartnerRewards,
   fetchPendingOrdersQuery,
   fetchPriceIdsFromOrderIdsQuery,
 } from './subgraphQueries';
-import { mapOrdersArrayToInterface, mapSingleOrderToInterface } from '../../common/subgraphMapper';
+import {
+  mapOrdersArrayToInterface,
+  mapReferralsArrayToInterface,
+  mapSingleOrderToInterface,
+} from '../../common/subgraphMapper';
 import { EMPTY_BYTES32, getPriceIdsForCollaterals, getUniqueValuesFromArray } from '../../common';
 import { NotFoundError } from '../../error/not-found.error';
 
@@ -86,3 +91,20 @@ export const getPythPriceIdsForOrderIds = async (subgraphEndpoint: string, order
     throw error;
   }
 };
+
+// Returns the referral data of a partner
+export const getReferralDataForPartner = async (
+  subgraphEndpoint: string,
+  partnerAddress: string,
+  count: number = 20,
+  skip: number = 0,
+): Promise<Referral[]> => {
+  try {
+    const query = fetchPartnerRewards(partnerAddress.toLowerCase(), count, skip);
+    const subgraphResponse = await request(subgraphEndpoint, query);
+    const referrals: Referral[] = mapReferralsArrayToInterface(subgraphResponse) ?? [];
+    return referrals;
+  } catch (error) {
+    throw error;
+  }
+};

src/subgraph/orders/subgraphQueries.ts

@@ -138,3 +138,23 @@ export const fetchPriceIdsFromOrderIdsQuery = (orderIds: string[]) =>
     }
   }
 `;
+
+export const fetchPartnerRewards = (partnerAddress: string, count: number = 20, skip: number = 0) => gql`
+  {
+    referrals(
+      first: ${count}
+      skip: ${skip}
+      orderBy: timestamp
+      orderDirection: desc
+      where: { partner: "${partnerAddress}" }
+    ) {
+      id
+      partner { id }
+      referredUser { id }
+      sizeInUsd
+      timestamp
+      txHash
+      referralRewardsInUsd
+    }
+  }
+`;

src/subgraph/vaults/index.ts

@@ -1,19 +1,15 @@
 import { request } from 'graphql-request';
 import { Vault, VaultPositionsResponse } from '../../interfaces';
-import { fetchAllVaultsQuery, fetchUserAllVaultsQuery } from './subgraphQueries';
+import { fetchAllVaultsQuery, fetchUserAllVaultsQuery, fetchVaultAprDetails } from './subgraphQueries';
 import { mapVaultsArrayToInterface } from '../../common/subgraphMapper';
 import { NotFoundError } from '../../error/not-found.error';
 import { Chain as SupportedChain, availableVaultsPerChain } from '@parifi/references';
 
-import { PRICE_FEED_DECIMALS, getNormalizedPriceByIdFromPriceIdArray } from '../../common';
+import { DECIMAL_ZERO, PRICE_FEED_DECIMALS, getNormalizedPriceByIdFromPriceIdArray } from '../../common';
 import Decimal from 'decimal.js';
 import { getLatestPricesFromPyth, normalizePythPriceForParifi } from '../../pyth/pyth';
 import { AxiosInstance } from 'axios';
 
-// const matchChain: Record<SupportedChain, Chain> = {
-//   [SupportedChain.ARBITRUM_SEPOLIA]: arbitrumSepolia,
-// };
-
 // Get all vaults from subgraph
 export const getAllVaults = async (subgraphEndpoint: string): Promise<Vault[]> => {
   try {
@@ -135,3 +131,55 @@ export const getTotalPoolsValue = async (
   const totalPoolValue = data.reduce((a, b) => a + b.totatVaultValue, 0);
   return { data, totalPoolValue };
 };
+
+export const getVaultApr = async (
+  subgraphEndpoint: string,
+  vaultId: string,
+): Promise<{ apr7Days: Decimal; apr30Days: Decimal; aprAllTime: Decimal }> => {
+  // Interface for subgraph response
+  interface VaultAprInterface {
+    vaultDailyDatas: {
+      apr: Decimal;
+      vault: {
+        allTimeApr: Decimal;
+      };
+    }[];
+  }
+
+  let apr7Days: Decimal = DECIMAL_ZERO;
+  let apr30Days: Decimal = DECIMAL_ZERO;
+  let aprAllTime: Decimal = DECIMAL_ZERO;
+
+  try {
+    const subgraphResponse: VaultAprInterface = await request(subgraphEndpoint, fetchVaultAprDetails(vaultId));
+    console.log(subgraphResponse);
+    const vaultDatas = subgraphResponse.vaultDailyDatas;
+
+    // If no APR data found, return 0;
+    if (vaultDatas.length == 0) {
+      return { apr7Days, apr30Days, aprAllTime };
+    } else {
+      // Set All Time APR for the vault from response
+      aprAllTime = vaultDatas[0].vault.allTimeApr;
+    }
+
+    /// Calculate the APR of vault based on timeframe data. If enough data points are not available,
+    /// the value is set to 0;
+    for (let index = 0; index < vaultDatas.length; index++) {
+      const vaultData = vaultDatas[index];
+
+      // Do not calculate 7 day APR if less than 7 days of data is available
+      if (index < 7 && vaultDatas.length >= 7) {
+        apr7Days = apr7Days.add(vaultData.apr);
+      }
+
+      // Do not calculate 30 day APR if less than 30 days of data is available
+      if (index < 30 && vaultDatas.length >= 30) {
+        apr30Days = apr30Days.add(vaultData.apr);
+      }
+    }
+    return { apr7Days: apr7Days.div(7), apr30Days: apr30Days.div(30), aprAllTime: aprAllTime };
+  } catch (error) {
+    throw error;
+  }
+};

src/subgraph/vaults/subgraphQueries.ts

@@ -76,3 +76,17 @@ query vaultInfo {
   }
 }
 `;
+
+export const fetchVaultAprDetails = (vaultId: string) => gql`
+  {
+    vaultDailyDatas(
+      first: 30
+      orderBy: startTimestamp
+      orderDirection: desc
+      where: { vault: "${vaultId}" }
+    ) {
+    	vault { allTimeApr }
+      apr
+    }
+  }
+`;

test/subgraph-tests/orders.test.ts

@@ -47,4 +47,12 @@ describe('Order fetching logic from subgraph', () => {
     const { gelatoTaskId: taskId } = await parifiSdk.core.settleOrderUsingGelato(orderId);
     console.log('taskId', taskId);
   });
+
+  it('should return referral data for partner address', async () => {
+    await parifiSdk.init();
+    const partnerAddress = '0x30f06f86f107f9523f5b91a8e8aeb602b7b260bd';
+
+    const referralData = await parifiSdk.subgraph.getReferralDataForPartner(partnerAddress);
+    console.log('referralData', referralData);
+  });
 });

test/subgraph-tests/vaults.test.ts

@@ -1,14 +1,33 @@
 import { Chain } from '@parifi/references';
 import { PRICE_FEED_DECIMALS, ParifiSdk } from '../../src';
-import { RpcConfig } from '../../src/interfaces/classConfigs';
 import { assert } from 'ethers';
 import Decimal from 'decimal.js';
+import { PythConfig, RelayerConfig, RelayerI, RpcConfig, SubgraphConfig } from '../../src/interfaces/classConfigs';
 
 const rpcConfig: RpcConfig = {
-  chainId: Chain.ARBITRUM_SEPOLIA,
+  chainId: Chain.ARBITRUM_MAINNET,
 };
 
-const parifiSdk = new ParifiSdk(rpcConfig, {}, {}, {});
+const subgraphConfig: SubgraphConfig = {
+  subgraphEndpoint: process.env.SUBGRAPH_ENDPOINT,
+};
+
+const pythConfig: PythConfig = {
+  pythEndpoint: process.env.PYTH_SERVICE_ENDPOINT,
+  username: process.env.PYTH_SERVICE_USERNAME,
+  password: process.env.PYTH_SERVICE_PASSWORD,
+  isStable: true,
+};
+
+const gelatoConfig: RelayerI = {
+  apiKey: process.env.GELATO_KEY,
+};
+
+const relayerConfig: RelayerConfig = {
+  gelatoConfig: gelatoConfig,
+};
+
+const parifiSdk = new ParifiSdk(rpcConfig, subgraphConfig, relayerConfig, pythConfig);
 
 describe('Vault fetching logic from subgraph', () => {
   it('should return correct vault details', async () => {
@@ -19,33 +38,35 @@ describe('Vault fetching logic from subgraph', () => {
 
     expect(vaults.length).not.toBe(0);
   });
-});
 
-describe('Vault fetching logic from subgraph', () => {
-  it('should return correct vault details', async () => {
+  it('should return correct Total Pool Value', async () => {
     await parifiSdk.init();
     const data = await parifiSdk.subgraph.getTotalPoolsValue();
     console.log(data);
 
     expect(data.totalPoolValue).not.toBe(0);
   });
-});
 
-describe('Vault fetching logic from subgraph', () => {
-  it('should return correct vault details', async () => {
+  it('should return correct user vault data', async () => {
     await parifiSdk.init();
     const data = await parifiSdk.subgraph.getUserVaultDataByChain('0x30f06f86F107f9523f5b91A8E8AEB602b7b260BD');
     console.log(data);
 
     expect(data.length).not.toBe(0);
   });
-});
-describe('Vault fetching logic from subgraph', () => {
-  it('should return correct vault details', async () => {
+
+  it('should return correct user total pools vaule', async () => {
     await parifiSdk.init();
     const data = await parifiSdk.subgraph.getUserTotalPoolsValue('0x30f06f86F107f9523f5b91A8E8AEB602b7b260BD');
     console.log(data);
 
     expect(data.myTotalPoolValue).not.toBe(0);
   });
+
+  it('should return correct APR details', async () => {
+    await parifiSdk.init();
+    const vaultId = '0x13a78809528b02ad5e7c42f39232d332761dfb1d';
+    const data = await parifiSdk.subgraph.getVaultApr(vaultId);
+    console.log(data);
+  });
 });