@nadohq/indexer-client 0.6.0 → 0.8.0

package/src/IndexerBaseClient.ts

@@ -1,6 +1,7 @@
 import {
   EIP712LeaderboardAuthenticationParams,
   EIP712LeaderboardAuthenticationValues,
+  EIP712SocialAuthenticationParams,
   getDefaultRecvTime,
   getNadoEIP712Values,
   getSignedTransactionRequest,
@@ -42,6 +43,8 @@ import {
   mapSnapshotsIntervalToServerParams,
 } from './dataMappers';
 import {
+  ConnectSocialAccountParams,
+  ConnectSocialAccountResponse,
   GetIndexerBacklogResponse,
   GetIndexerCandlesticksParams,
   GetIndexerCandlesticksResponse,
@@ -62,8 +65,8 @@ import {
   GetIndexerLeaderboardParams,
   GetIndexerLeaderboardParticipantParams,
   GetIndexerLeaderboardParticipantResponse,
-  GetIndexerLeaderboardRegistrationParams,
-  GetIndexerLeaderboardRegistrationResponse,
+  GetIndexerLeaderboardRegistrationsParams,
+  GetIndexerLeaderboardRegistrationsResponse,
   GetIndexerLeaderboardResponse,
   GetIndexerLinkedSignerParams,
   GetIndexerLinkedSignerResponse,
@@ -115,10 +118,14 @@ import {
   IndexerServerV2TickersResponse,
   IndexerSnapshotBalance,
   IndexerSubaccountSnapshot,
+  ListIndexerSocialAccountsParams,
+  ListIndexerSocialAccountsResponse,
   ListIndexerSubaccountsParams,
   ListIndexerSubaccountsResponse,
-  UpdateIndexerLeaderboardRegistrationParams,
-  UpdateIndexerLeaderboardRegistrationResponse,
+  RegisterLeaderboardParams,
+  RegisterLeaderboardResponse,
+  RevokeSocialAccountParams,
+  RevokeSocialAccountResponse,
 } from './types';
 
 export interface IndexerClientOpts {
@@ -664,6 +671,7 @@ export class IndexerBaseClient {
       rank_type: params.rankType,
       start: params.startCursor,
       limit: params.limit,
+      order: params.order,
     });
 
     return {
@@ -692,17 +700,18 @@ export class IndexerBaseClient {
   }
 
   /**
-   * Attempts to update a user's registration to the provided `contestId`. This requires signing.
-   * @param params
+   * Registers a subaccount for one or more contests. Requires EIP-712 signing.
+   *
+   * @param params - Registration parameters including contest IDs and signing config.
    */
-  async updateLeaderboardRegistration(
-    params: UpdateIndexerLeaderboardRegistrationParams,
-  ): Promise<UpdateIndexerLeaderboardRegistrationResponse> {
+  async registerLeaderboard(
+    params: RegisterLeaderboardParams,
+  ): Promise<RegisterLeaderboardResponse> {
     const signatureParams: EIP712LeaderboardAuthenticationParams = {
-      // Default to 90 seconds from now if no recvTime is provided
       expiration: toIntegerString(params.recvTime ?? getDefaultRecvTime()),
       subaccountName: params.subaccountName,
       subaccountOwner: params.subaccountOwner,
+      contestIds: params.contestIds,
     };
 
     const tx = getNadoEIP712Values(
@@ -711,8 +720,8 @@ export class IndexerBaseClient {
     );
     const signature = await this.sign(
       'leaderboard_authentication',
-      params.updateRegistration.verifyingAddr,
-      params.updateRegistration.chainId,
+      params.verifyingAddr,
+      params.chainId,
       signatureParams,
     );
 
@@ -722,40 +731,36 @@ export class IndexerBaseClient {
         signature,
       };
 
-    const baseResponse = await this.query('leaderboard_registration', {
-      subaccount: subaccountToHex({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName,
-      }),
-      contest_id: params.contestId,
+    const baseResponse = await this.query('leaderboard_register', {
       update_registration: updateRegistrationTx,
     });
+
     return {
-      registration: baseResponse.registration
-        ? mapIndexerLeaderboardRegistration(baseResponse.registration)
-        : null,
+      registrations: baseResponse.registrations.map(
+        mapIndexerLeaderboardRegistration,
+      ),
     };
   }
 
   /**
-   * Retrieves the registration status for a leaderboard participant for provided `contestId`.
-   * @param params
+   * Retrieves contest registrations for a subaccount. Supports batch lookup
+   * across multiple contests with an optional active filter.
+   *
+   * @param params - Query parameters including subaccount and contest IDs.
    */
-  async getLeaderboardRegistration(
-    params: GetIndexerLeaderboardRegistrationParams,
-  ): Promise<GetIndexerLeaderboardRegistrationResponse> {
-    const baseResponse = await this.query('leaderboard_registration', {
-      subaccount: subaccountToHex({
-        subaccountOwner: params.subaccountOwner,
-        subaccountName: params.subaccountName,
-      }),
-      contest_id: params.contestId,
-      update_registration: null,
+  async getLeaderboardRegistrations(
+    params: GetIndexerLeaderboardRegistrationsParams,
+  ): Promise<GetIndexerLeaderboardRegistrationsResponse> {
+    const baseResponse = await this.query('leaderboard_registrations', {
+      subaccount: subaccountToHex(params.subaccount),
+      contest_ids: params.contestIds,
+      active: params.active,
     });
+
     return {
-      registration: baseResponse.registration
-        ? mapIndexerLeaderboardRegistration(baseResponse.registration)
-        : null,
+      registrations: baseResponse.registrations.map(
+        mapIndexerLeaderboardRegistration,
+      ),
     };
   }
 
@@ -769,6 +774,7 @@ export class IndexerBaseClient {
   ): Promise<GetIndexerLeaderboardContestsResponse> {
     const baseResponse = await this.query('leaderboard_contests', {
       contest_ids: params.contestIds,
+      active: params.active,
     });
 
     return {
@@ -892,6 +898,96 @@ export class IndexerBaseClient {
     };
   }
 
+  /**
+   * Initiates a social account connection flow. Returns a URL the user must visit to complete the OAuth flow.
+   * Requires EIP-712 signing.
+   *
+   * @param params - Connection parameters including provider and signing config.
+   */
+  async connectSocialAccount(
+    params: ConnectSocialAccountParams,
+  ): Promise<ConnectSocialAccountResponse> {
+    const signatureParams: EIP712SocialAuthenticationParams = {
+      expiration: toIntegerString(params.recvTime ?? getDefaultRecvTime()),
+      subaccountName: params.subaccountName,
+      subaccountOwner: params.subaccountOwner,
+      provider: params.provider,
+    };
+
+    const tx = getNadoEIP712Values('social_authentication', signatureParams);
+    const signature = await this.sign(
+      'social_authentication',
+      params.verifyingAddr,
+      params.chainId,
+      signatureParams,
+    );
+
+    const baseResponse = await this.query('social_connect', {
+      update_social_account: { tx, signature },
+    });
+
+    return { url: baseResponse.url };
+  }
+
+  /**
+   * Lists linked social accounts for a given address.
+   *
+   * @param params - Query parameters including the wallet address.
+   */
+  async listSocialAccounts(
+    params: ListIndexerSocialAccountsParams,
+  ): Promise<ListIndexerSocialAccountsResponse> {
+    const baseResponse = await this.query('list_social_accounts', {
+      address: params.address,
+    });
+
+    return {
+      accounts: baseResponse.accounts.map((a) => ({
+        provider: a.provider,
+        username: a.username,
+        displayName: a.display_name,
+        profileImageUrl: a.profile_image_url,
+      })),
+    };
+  }
+
+  /**
+   * Revokes a linked social account. Requires EIP-712 signing.
+   *
+   * @param params - Revocation parameters including provider and signing config.
+   */
+  async revokeSocialAccount(
+    params: RevokeSocialAccountParams,
+  ): Promise<RevokeSocialAccountResponse> {
+    const signatureParams: EIP712SocialAuthenticationParams = {
+      expiration: toIntegerString(params.recvTime ?? getDefaultRecvTime()),
+      subaccountName: params.subaccountName,
+      subaccountOwner: params.subaccountOwner,
+      provider: params.provider,
+    };
+
+    const tx = getNadoEIP712Values('social_authentication', signatureParams);
+    const signature = await this.sign(
+      'social_authentication',
+      params.verifyingAddr,
+      params.chainId,
+      signatureParams,
+    );
+
+    const baseResponse = await this.query('revoke_social_account', {
+      update_social_account: { tx, signature },
+    });
+
+    return {
+      accounts: baseResponse.accounts.map((a) => ({
+        provider: a.provider,
+        username: a.username,
+        displayName: a.display_name,
+        profileImageUrl: a.profile_image_url,
+      })),
+    };
+  }
+
   /**
    * Get tickers from the v2 indexer endpoint
    * @param params

package/src/IndexerClient.ts

@@ -6,6 +6,7 @@ import {
   toBigNumber,
   toIntegerString,
 } from '@nadohq/shared';
+import BigNumber from 'bignumber.js';
 
 import { IndexerBaseClient } from './IndexerBaseClient';
 import {
@@ -447,11 +448,18 @@ export class IndexerClient extends IndexerBaseClient {
       startCursor: params.startCursor,
     });
 
-    // Next cursor is the rank number of the (requestedLimit+1)th item
-    const nextCursor =
-      params.rankType === 'pnl'
-        ? baseResponse.participants[requestedLimit]?.pnlRank
-        : baseResponse.participants[requestedLimit]?.roiRank;
+    const overflowParticipant = baseResponse.participants[requestedLimit];
+    let nextCursor: BigNumber | undefined;
+    if (overflowParticipant) {
+      // If rankType specified, use it directly. Otherwise it's a single-track
+      // contest so grab the rank from the only track present.
+      const trackData = (
+        params.rankType
+          ? overflowParticipant.tracks[params.rankType]
+          : Object.values(overflowParticipant.tracks)[0]
+      )!;
+      nextCursor = trackData.rank;
+    }
 
     return {
       ...baseResponse,

package/src/dataMappers.ts

@@ -256,16 +256,24 @@ export function mapIndexerMakerStatistics(
 export function mapIndexerLeaderboardPosition(
   position: IndexerServerLeaderboardPosition,
 ): IndexerLeaderboardParticipant {
+  const tracks = mapValues(position.tracks, (trackData) => ({
+    value: toBigNumber(trackData.value),
+    rank: toBigNumber(trackData.rank),
+    qualificationStatus: trackData.qualification_status,
+  }));
+
   return {
     subaccount: subaccountFromHex(position.subaccount),
     contestId: position.contest_id,
-    pnl: toBigNumber(position.pnl),
-    pnlRank: toBigNumber(position.pnl_rank),
-    percentRoi: toBigNumber(position.roi),
-    roiRank: toBigNumber(position.roi_rank),
     accountValue: toBigNumber(position.account_value),
-    volume: position.volume ? toBigNumber(position.volume) : undefined,
     updateTime: toBigNumber(position.update_time),
+    tracks,
+    socialAccounts: position.social_accounts.map((account) => ({
+      provider: account.provider,
+      username: account.username,
+      displayName: account.display_name,
+      profileImageUrl: account.profile_image_url,
+    })),
   };
 }
 
@@ -282,17 +290,25 @@ export function mapIndexerLeaderboardRegistration(
 export function mapIndexerLeaderboardContest(
   contest: IndexerServerLeaderboardContest,
 ): IndexerLeaderboardContest {
+  const startTime = toBigNumber(contest.start_time);
+  const endTime = toBigNumber(contest.end_time);
+
   return {
     contestId: contest.contest_id,
-    startTime: toBigNumber(contest.start_time),
-    endTime: toBigNumber(contest.end_time),
-    period: toBigNumber(contest.threshold),
+    startTime,
+    endTime,
     totalParticipants: toBigNumber(contest.count),
-    minRequiredAccountValue: toBigNumber(contest.threshold),
-    minRequiredVolume: toBigNumber(contest.volume_threshold),
     requiredProductIds: contest.product_ids,
     active: contest.active,
     lastUpdated: toBigNumber(contest.last_updated),
+    title: contest.title,
+    description: contest.description,
+    tracks: contest.tracks.map((track) => ({
+      trackId: track.track_id,
+      rankType: track.rank_type,
+      sortOrder: track.sort_order,
+      minRequiredAccountValue: toBigNumber(track.threshold),
+    })),
   };
 }
 

package/src/types/IndexerLeaderboardType.ts

@@ -1,2 +1,14 @@
-// `pnl` ranks by the absolute pnl value, whereas `roi` ranks by the % roi value
-export type IndexerLeaderboardRankType = 'pnl' | 'roi';
+/**
+ * Leaderboard ranking metric.
+ * - `pnl` ranks by absolute PnL value
+ * - `roi` ranks by percentage ROI value
+ * - `volume` ranks by trading volume
+ * - `liquidation` ranks by liquidation count
+ * - `balance` ranks by spot balance
+ */
+export type IndexerLeaderboardRankType =
+  | 'pnl'
+  | 'roi'
+  | 'volume'
+  | 'liquidation'
+  | 'balance';

package/src/types/clientTypes.ts

@@ -558,26 +558,43 @@ export interface GetIndexerMakerStatisticsResponse {
 
 export interface GetIndexerLeaderboardParams {
   contestId: number;
-  rankType: IndexerLeaderboardRankType;
+  /**
+   * The ranking metric to query by.
+   * Optional for single-track contests (auto-selects the only track).
+   * Required for multi-track contests — omitting it returns an error.
+   */
+  rankType?: IndexerLeaderboardRankType;
   // Min rank inclusive
   startCursor?: string;
   limit?: number;
+  /** Sort order. Defaults to `'DESC'`. */
+  order?: 'ASC' | 'DESC';
+}
+
+export interface IndexerSocialAccountInfo {
+  provider: 'twitter';
+  username: string;
+  displayName: string;
+  profileImageUrl: string;
+}
+
+export interface IndexerLeaderboardTrackPosition {
+  value: BigNumber;
+  rank: BigNumber;
+  qualificationStatus: 'qualified' | 'insufficient_account_value';
 }
 
 export interface IndexerLeaderboardParticipant {
   subaccount: Subaccount;
   contestId: number;
-  pnl: BigNumber;
-  pnlRank: BigNumber;
-  percentRoi: BigNumber;
-  roiRank: BigNumber;
   // Float indicating the ending account value at the time the snapshot was taken i.e: at updateTime
   accountValue: BigNumber;
-  // Float indicating the trading volume at the time the snapshot was taken i.e: at updateTime.
-  // Null for contests that have no volume requirement.
-  volume?: BigNumber;
   // Seconds
   updateTime: BigNumber;
+  tracks: Partial<
+    Record<IndexerLeaderboardRankType, IndexerLeaderboardTrackPosition>
+  >;
+  socialAccounts: IndexerSocialAccountInfo[];
 }
 
 export interface GetIndexerLeaderboardResponse {
@@ -595,19 +612,21 @@ export interface GetIndexerLeaderboardParticipantResponse {
   participant: Record<string, IndexerLeaderboardParticipant>;
 }
 
-interface LeaderboardSignatureParams {
-  // endpoint address
+interface SignatureParams {
   verifyingAddr: string;
   chainId: number;
 }
 
-export interface GetIndexerLeaderboardRegistrationParams extends Subaccount {
-  contestId: number;
+export interface GetIndexerLeaderboardRegistrationsParams {
+  subaccount: Subaccount;
+  contestIds: number[];
+  /** Filter to active contests only. Defaults to `true`. */
+  active?: boolean;
 }
 
-export interface UpdateIndexerLeaderboardRegistrationParams extends GetIndexerLeaderboardRegistrationParams {
-  updateRegistration: LeaderboardSignatureParams;
-  // In millis, defaults to 90s in the future
+export interface RegisterLeaderboardParams extends Subaccount, SignatureParams {
+  contestIds: number[];
+  /** In millis, defaults to 90s in the future. */
   recvTime?: BigNumber;
 }
 
@@ -618,45 +637,74 @@ export interface IndexerLeaderboardRegistration {
   updateTime: BigNumber;
 }
 
-export interface GetIndexerLeaderboardRegistrationResponse {
-  // For non-tiered contests, null if the user is not registered for the provided contestId.
-  // For tiered contests (i.e., related contests), null if the user is not registered for any of the contests in the tier group.
-  registration: IndexerLeaderboardRegistration | null;
+export interface GetIndexerLeaderboardRegistrationsResponse {
+  registrations: IndexerLeaderboardRegistration[];
 }
 
-export type UpdateIndexerLeaderboardRegistrationResponse =
-  GetIndexerLeaderboardRegistrationResponse;
+export type RegisterLeaderboardResponse =
+  GetIndexerLeaderboardRegistrationsResponse;
 
 export interface GetIndexerLeaderboardContestsParams {
   contestIds: number[];
+  /** Filter to active contests only. Defaults to `true`. Pass `false` to include inactive contests. */
+  active?: boolean;
+}
+
+export interface IndexerLeaderboardContestTrack {
+  trackId: number;
+  rankType: IndexerLeaderboardRankType;
+  sortOrder: 'ASC' | 'DESC';
+  // Float indicating the min account value required to qualify for this track e.g: 250.0
+  minRequiredAccountValue: BigNumber;
 }
 
 export interface IndexerLeaderboardContest {
   contestId: number;
-  // NOTE: Start / End times are ignored when `period` is non-zero.
   // Start time in seconds
   startTime: BigNumber;
   // End time in seconds
   endTime: BigNumber;
-  // Contest duration in seconds; when set to 0, contest duration is [startTime,endTime];
-  // Otherwise, contest runs indefinitely in the interval [lastUpdated - period, lastUpdated] if active;
-  period: BigNumber;
-  // Last updated time in Seconds
+  // Last updated time in seconds
   lastUpdated: BigNumber;
   totalParticipants: BigNumber;
-  // Float indicating the min account value required to be eligible for this contest e.g: 250.0
-  minRequiredAccountValue: BigNumber;
-  // Float indicating the min trading volume required to be eligible for this contest e.g: 1000.0
-  minRequiredVolume: BigNumber;
   // For market-specific contests, only the volume from these products will be counted.
   requiredProductIds: number[];
   active: boolean;
+  title: string;
+  description: string;
+  tracks: IndexerLeaderboardContestTrack[];
 }
 
 export interface GetIndexerLeaderboardContestsResponse {
   contests: IndexerLeaderboardContest[];
 }
 
+/**
+ * Social Accounts
+ */
+
+export interface ConnectSocialAccountParams
+  extends Subaccount, SignatureParams {
+  provider: 'twitter';
+  /** In millis, defaults to 90s in the future. */
+  recvTime?: BigNumber;
+}
+
+export interface ConnectSocialAccountResponse {
+  url: string;
+}
+
+export interface ListIndexerSocialAccountsParams {
+  address: Address;
+}
+
+export interface ListIndexerSocialAccountsResponse {
+  accounts: IndexerSocialAccountInfo[];
+}
+
+export type RevokeSocialAccountParams = ConnectSocialAccountParams;
+export type RevokeSocialAccountResponse = ListIndexerSocialAccountsResponse;
+
 export type GetIndexerFastWithdrawalSignatureParams =
   IndexerServerFastWithdrawalSignatureParams;
 

package/src/types/serverModelTypes.ts

@@ -6,6 +6,7 @@ import {
 } from '@nadohq/engine-client';
 import { EIP712OrderValues } from '@nadohq/shared';
 import { IndexerEventType } from './IndexerEventType';
+import { IndexerLeaderboardRankType } from './IndexerLeaderboardType';
 import { NadoTx } from './NadoTx';
 
 export interface IndexerServerSnapshotsInterval {
@@ -249,29 +250,48 @@ export interface IndexerServerMaker {
  * Leaderboard
  */
 
+export interface IndexerServerSocialAccount {
+  provider: 'twitter';
+  username: string;
+  display_name: string;
+  profile_image_url: string;
+}
+
+export interface IndexerServerLeaderboardTrackPosition {
+  value: string;
+  rank: string;
+  qualification_status: 'qualified' | 'insufficient_account_value';
+}
+
+export interface IndexerServerLeaderboardContestTrack {
+  track_id: number;
+  rank_type: IndexerLeaderboardRankType;
+  sort_order: 'ASC' | 'DESC';
+  threshold: string;
+}
+
 export interface IndexerServerLeaderboardPosition {
   subaccount: string;
   contest_id: number;
-  pnl: string;
-  pnl_rank: string;
-  roi: string;
-  roi_rank: string;
   account_value: string;
-  volume?: string;
   update_time: string;
+  tracks: Partial<
+    Record<IndexerLeaderboardRankType, IndexerServerLeaderboardTrackPosition>
+  >;
+  social_accounts: IndexerServerSocialAccount[];
 }
 
 export interface IndexerServerLeaderboardContest {
   contest_id: number;
   start_time: string;
   end_time: string;
-  timeframe: string;
   count: string;
-  threshold: string;
-  volume_threshold: string;
-  product_ids: number[];
   last_updated: string;
+  product_ids: number[];
   active: boolean;
+  title: string;
+  description: string;
+  tracks: IndexerServerLeaderboardContestTrack[];
 }
 
 export interface IndexerServerLeaderboardRegistration {