chore(app): fix referral query of volume (#982)

packages/sdk/src/queries/futures.ts

@@ -232,7 +232,7 @@ export const queryVolumeByTrader = async (
 	mintedTime: string
 ): Promise<FuturesTradeByReferral[]> => {
 	let queryResponseCount = 0
-	let lastMintedAtInSeconds = Math.floor(Number(mintedTime) / 1000)
+	let lastMintedAtInSeconds = Math.floor(Number(mintedTime))
 	const currentTimeInSeconds = Math.floor(new Date().getTime() / 1000)
 	const futuresTrades: FuturesTradeByReferral[] = []
 

packages/sdk/src/queries/referrals.ts

@@ -58,17 +58,37 @@ export const queryCodesByReferrer = async (
 }
 
 export const queryTradersByCode = async (sdk: KwentaSDK, code: string): Promise<BoostHolder[]> => {
-	const response: { boostHolders: BoostHolder[] } = await request(
-		sdk.referrals.referralsGqlEndpoint,
-		gql`
-			query boostHolders($code: String!) {
-				boostHolders(where: { code: $code }) {
-					id
-					lastMintedAt
+	let queryResponseCount = 0
+	const currentTimeInSeconds = Math.floor(new Date().getTime() / 1000)
+	const boostHolders: BoostHolder[] = []
+	let maxTimestamp = currentTimeInSeconds
+
+	do {
+		const response: { boostHolders: BoostHolder[] } = await request(
+			sdk.referrals.referralsGqlEndpoint,
+			gql`
+				query boostHolders($code: String!, $maxTimestamp: BigInt!) {
+					boostHolders(
+						where: { lastMintedAt_lte: $maxTimestamp, code: $code }
+						orderBy: lastMintedAt
+						orderDirection: desc
+						first: 1000
+					) {
+						id
+						lastMintedAt
+					}
 				}
-			}
-		`,
-		{ code: formatBytes32String(code) }
-	)
-	return response?.boostHolders || []
+			`,
+			{ code: formatBytes32String(code), maxTimestamp }
+		)
+
+		queryResponseCount = response.boostHolders.length
+
+		if (queryResponseCount > 0) {
+			maxTimestamp = Number(response.boostHolders[queryResponseCount - 1].lastMintedAt)
+			boostHolders.push(...response.boostHolders)
+		}
+	} while (queryResponseCount === 1000)
+
+	return boostHolders
 }

packages/sdk/src/queries/utils.ts

@@ -0,0 +1,25 @@
+export async function limitConcurrency<T, R>(
+	tasks: T[],
+	handler: (task: T) => Promise<R>,
+	limit: number
+): Promise<R[]> {
+	const results: R[] = []
+	const taskQueue: T[] = [...tasks]
+
+	const executeTask = async () => {
+		if (taskQueue.length === 0) return
+
+		const task = taskQueue.pop()
+		if (task !== undefined) {
+			const result = await handler(task)
+			results.push(result)
+		}
+
+		await executeTask()
+	}
+
+	const initialPromises = Array.from({ length: limit }).map(() => executeTask())
+	await Promise.all(initialPromises)
+
+	return results
+}

packages/sdk/src/utils/referrals.ts

@@ -2,6 +2,7 @@ import KwentaSDK from '..'
 import { REFERRALS_ENDPOINTS } from '../constants/referrals'
 import { queryVolumeByTrader } from '../queries/futures'
 import { queryCodesByReferrer, queryTradersByCode } from '../queries/referrals'
+import { limitConcurrency } from '../queries/utils'
 import { FuturesTradeByReferral } from '../types/futures'
 import { ReferralCumulativeStats } from '../types/referrals'
 
@@ -25,10 +26,17 @@ export const getReferralStatisticsByAccount = async (
 		codes.map(async (code) => {
 			const traders = await queryTradersByCode(sdk, code)
 
-			const totalVolume = await traders.reduce(async (accVolume, trader) => {
-				const volume = await queryVolumeByTrader(sdk, trader.id, trader.lastMintedAt)
-				return (await accVolume) + calculateTraderVolume(volume)
-			}, Promise.resolve(0))
+			const totalVolumeByTrader = await limitConcurrency(
+				traders,
+				async ({ id, lastMintedAt }) => {
+					const trades = await queryVolumeByTrader(sdk, id, lastMintedAt)
+					if (!trades.length) return 0
+					return calculateTraderVolume(trades)
+				},
+				200
+			)
+
+			const totalVolume = totalVolumeByTrader.reduce((acc, curr) => acc + curr, 0)
 
 			return {
 				code,