@azuro-org/toolkit 5.2.0-beta.1 → 6.0.0-beta.0

package/dist/utils/cashout/getCalculatedCashout.d.ts

@@ -1,7 +1,7 @@
 import { type Address } from 'viem';
 import { type Environment } from '../../envs';
 import { type ChainId } from '../../config';
-export type GetCalculatedCashout = {
+export type GetCalculatedCashoutResult = {
     calculationId: string;
     account: string;
     environment: Environment;
@@ -12,10 +12,35 @@ export type GetCalculatedCashout = {
     approveExpiredAt: number;
     isLive: boolean;
 } | null;
-type Props = {
+/** @deprecated use GetCalculatedCashoutResult instead */
+export type GetCalculatedCashout = GetCalculatedCashoutResult;
+export type GetCalculatedCashoutParams = {
     chainId: ChainId;
     account: Address;
     graphBetId: string;
 };
-export declare const getCalculatedCashout: (props: Props) => Promise<GetCalculatedCashout>;
-export {};
+/**
+ * Retrieves the calculated cashout information for a specific bet, including the cashout amount and odds.
+ * Returns null if no cashout calculation is available for the bet.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/cashout/getCalculatedCashout
+ *
+ * @example
+ * import { getCalculatedCashout } from '@azuro-org/toolkit'
+ *
+ * const chainId = 100
+ * const account = '0x123...'
+ * const graphBetId = '456'
+ *
+ * const cashout = await getCalculatedCashout({
+ *   chainId,
+ *   account,
+ *   graphBetId,
+ * })
+ *
+ * if (cashout) {
+ *   console.log(`Cashout amount: ${cashout.cashoutAmount}`)
+ *   console.log(`Cashout odds: ${cashout.cashoutOdds}`)
+ * }
+ * */
+export declare const getCalculatedCashout: (props: GetCalculatedCashoutParams) => Promise<GetCalculatedCashoutResult>;

package/dist/utils/cashout/getCashout.d.ts

@@ -3,9 +3,28 @@ import { type CreateCashoutResponse } from './createCashout';
 export type GetCashoutResponse = {
     txHash: string;
 } & CreateCashoutResponse;
-type Props = {
+export type GetCashoutResult = GetCashoutResponse | null;
+export type GetCashoutParams = {
     chainId: ChainId;
     orderId: string;
 };
-export declare const getCashout: ({ chainId, orderId }: Props) => Promise<GetCashoutResponse | null>;
-export {};
+/**
+ * Retrieves the status and details of a cashout order by its order ID.
+ * Returns null if the cashout order is not found.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/cashout/getCashout
+ *
+ * @example
+ * import { getCashout } from '@azuro-org/toolkit'
+ *
+ * const chainId = 100
+ * const orderId = 'abc123'
+ *
+ * const cashout = await getCashout({ chainId, orderId })
+ *
+ * if (cashout) {
+ *   console.log(`State: ${cashout.state}`)
+ *   console.log(`Transaction hash: ${cashout.txHash}`)
+ * }
+ * */
+export declare const getCashout: ({ chainId, orderId }: GetCashoutParams) => Promise<GetCashoutResult>;

package/dist/utils/cashout/getCashoutTypedData.d.ts

@@ -1,6 +1,6 @@
 import { type SignTypedDataParameters, type Address } from 'viem';
 import { type ChainId, CASHOUT_DATA_TYPES } from '../../config';
-type Props = {
+export type GetCashoutTypedDataParams = {
     chainId: ChainId;
     account: Address;
     attention: string;
@@ -8,5 +8,32 @@ type Props = {
     cashoutOdds: string | bigint;
     expiredAt: number;
 };
-export declare const getCashoutTypedData: (props: Props) => SignTypedDataParameters<typeof CASHOUT_DATA_TYPES>;
-export {};
+/**
+ * Generates EIP-712 typed data for signing a cashout order.
+ * This typed data must be signed by the user before submitting the cashout.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/cashout/getCashoutTypedData
+ *
+ * @example
+ * import { getCashoutTypedData } from '@azuro-org/toolkit'
+ * import { signTypedData } from 'viem/accounts'
+ *
+ * const chainId = 100
+ * const account = '0x123...'
+ * const tokenId = '456'
+ * const cashoutOdds = '1.85'
+ * const expiredAt = Math.floor(Date.now() / 1000) + 3600
+ * const attention = 'By signing this transaction, I agree to cash out on Azuro'
+ *
+ * const typedData = getCashoutTypedData({
+ *   chainId,
+ *   account,
+ *   attention,
+ *   tokenId,
+ *   cashoutOdds,
+ *   expiredAt,
+ * })
+ *
+ * const signature = await signTypedData(typedData)
+ * */
+export declare const getCashoutTypedData: (props: GetCashoutTypedDataParams) => SignTypedDataParameters<typeof CASHOUT_DATA_TYPES>;

package/dist/utils/cashout/getPrecalculatedCashouts.d.ts

@@ -11,10 +11,38 @@ type GetPrecalculatedCashoutsResponse = {
         }[];
     }[];
 };
-export type GetPrecalculatedCashouts = GetPrecalculatedCashoutsResponse | null;
-type Props = {
+export type GetPrecalculatedCashoutsResult = GetPrecalculatedCashoutsResponse | null;
+/** @deprecated use GetPrecalculatedCashoutsResult instead */
+export type GetPrecalculatedCashouts = GetPrecalculatedCashoutsResult;
+export type GetPrecalculatedCashoutsParams = {
     chainId: ChainId;
     conditionIds: string[];
 };
-export declare const getPrecalculatedCashouts: (props: Props) => Promise<GetPrecalculatedCashouts>;
+/**
+ * Retrieves precalculated cashout availability and prices for specified conditions.
+ * Returns margin information and outcome prices for each available condition.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/cashout/getPrecalculatedCashouts
+ *
+ * @example
+ * import { getPrecalculatedCashouts } from '@azuro-org/toolkit'
+ *
+ * const chainId = 100
+ * const conditionIds = ['123', '456', '789']
+ *
+ * const cashouts = await getPrecalculatedCashouts({
+ *   chainId,
+ *   conditionIds,
+ * })
+ *
+ * if (cashouts) {
+ *   cashouts.availables.forEach(({ conditionId, available, outcomes }) => {
+ *     console.log(`Condition ${conditionId} available: ${available}`)
+ *     outcomes.forEach(({ outcomeId, price }) => {
+ *       console.log(`  Outcome ${outcomeId}: ${price}`)
+ *     })
+ *   })
+ * }
+ * */
+export declare const getPrecalculatedCashouts: (props: GetPrecalculatedCashoutsParams) => Promise<GetPrecalculatedCashoutsResult>;
 export {};

package/dist/utils/feed/getConditionsByGameIds.d.ts

@@ -0,0 +1,52 @@
+import type { ConditionState } from '../../global';
+import type { ChainId } from '../../config';
+export type GetConditionsByGameIdsParams = {
+    chainId: ChainId;
+    gameIds?: string | string[];
+    states?: ConditionState | ConditionState[];
+    outcomeIds?: string | string[];
+    maxMargin?: number | string;
+    orderBy?: string;
+    orderDir?: 'asc' | 'desc';
+};
+export type ConditionDetailedData = {
+    id: string;
+    conditionId: string;
+    state: ConditionState;
+    title: string | null;
+    isExpressForbidden: boolean;
+    isPrematchEnabled: boolean;
+    isLiveEnabled: boolean;
+    margin: string;
+    outcomes: {
+        title: string | null;
+        outcomeId: string;
+        odds: string;
+    }[];
+    game: {
+        gameId: string;
+        sport: {
+            sportId: string;
+        };
+    };
+    wonOutcomeIds: string[];
+};
+export type GetConditionsByGameIdsResponse = {
+    conditions: ConditionDetailedData[];
+};
+export type GetConditionsByGameIdsResponseResult = GetConditionsByGameIdsResponse['conditions'];
+/**
+ * Fetches detailed conditions data for a given list of game IDs.
+ * Returns comprehensive condition information including outcomes, odds, and game relationships.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getConditionsByGameIds
+ *
+ * @example
+ * import { getConditionsByGameIds } from '@azuro-org/toolkit'
+ *
+ * const conditions = await getConditionsByGameIds({
+ *   chainId: 137,
+ *   gameIds: ['1006000000000077484167'],
+ * })
+ * */
+export declare const getConditionsByGameIds: (props: GetConditionsByGameIdsParams) => Promise<GetConditionsByGameIdsResponseResult>;

package/dist/utils/feed/getConditionsState.d.ts

@@ -0,0 +1,34 @@
+import type { ConditionState } from '../../global';
+import type { ChainId } from '../../config';
+export type GetConditionsStateParams = {
+    chainId: ChainId;
+    conditionIds: string[];
+};
+export type ConditionStateData = {
+    conditionId: string;
+    state: ConditionState;
+    outcomes: {
+        id: string;
+        outcomeId: string;
+        odds: string;
+    }[];
+};
+type ConditionsStateResponse = {
+    conditions: ConditionStateData[];
+};
+export type GetConditionsStateResult = ConditionsStateResponse['conditions'];
+/**
+ * Fetches up-to-date condition states and outcome odds for a list of conditions.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getConditionsState
+ *
+ * @example
+ * import { getConditionsState } from '@azuro-org/toolkit'
+ *
+ * const conditions = await getConditionsState({
+ *   chainId: 137,
+ *   conditionIds: ['300610060000000000635055340000000000000000387193'],
+ * })
+ * */
+export declare const getConditionsState: (props: GetConditionsStateParams) => Promise<GetConditionsStateResult>;
+export {};

package/dist/utils/feed/getGamesByFilters.d.ts

@@ -0,0 +1,35 @@
+import type { GameState, ConditionState } from '../../global';
+import type { ChainId } from '../../config';
+import type { SportHubSlug, GameOrderBy, PaginatedGamesResponse } from './types';
+export type GetGamesByFiltersParams = {
+    chainId: ChainId;
+    state?: GameState.Live | GameState.Prematch;
+    sportIds?: string | number | (string | number)[];
+    leagueSlugs?: string | string[];
+    sportHub?: SportHubSlug;
+    conditionsState?: ConditionState | ConditionState[];
+    orderBy?: GameOrderBy;
+    orderDir?: 'asc' | 'desc';
+    /** 1-based, default: 1 */
+    page?: number;
+    /** 1-based, default: 10 */
+    perPage?: number;
+};
+export type GetGamesByFiltersResult = PaginatedGamesResponse;
+/**
+ * Fetches games by applying various filters such as sport, league, or game state.
+ * Returns paginated results ideal for building sport/country/league listing pages.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getGamesByFilters
+ *
+ * @example
+ * import { GameState, getGamesByFilters } from '@azuro-org/toolkit'
+ *
+ * const games = await getGamesByFilters({
+ *   chainId: 137,
+ *   state: GameState.Prematch,
+ *   page: 2,
+ *   perPage: 50,
+ * })
+ * */
+export declare const getGamesByFilters: (props: GetGamesByFiltersParams) => Promise<GetGamesByFiltersResult>;

package/dist/utils/feed/getGamesByIds.d.ts

@@ -0,0 +1,26 @@
+import type { ChainId } from '../../config';
+import type { GameData } from './types';
+export type GetGamesByIdsParams = {
+    chainId: ChainId;
+    gameIds: string[];
+};
+type GetGamesByIdsResponse = GameData[];
+export type GetGamesByIdsResult = GetGamesByIdsResponse;
+/**
+ * Fetches game data for a specific list of game IDs.
+ * Returns detailed information for each requested game including participants, timing, and league data.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getGamesByIds
+ *
+ * @example
+ * import { getGamesByIds } from '@azuro-org/toolkit'
+ *
+ * const games = await getGamesByIds({
+ *   chainId: 137,
+ *   gameIds: ['1006000000000080373237'],
+ * })
+ *
+ * const gameData = games[0]
+ * */
+export declare const getGamesByIds: (props: GetGamesByIdsParams) => Promise<GetGamesByIdsResult>;
+export {};

package/dist/utils/feed/getNavigation.d.ts

@@ -0,0 +1,58 @@
+import type { ChainId } from '../../config';
+import type { SportHubSlug } from './types';
+export type GetNavigationParams = {
+    chainId: ChainId;
+    sportHub?: SportHubSlug;
+    sportIds?: string | number | (string | number)[];
+};
+export type NavigationSportData = {
+    id: number;
+    slug: string;
+    name: string;
+    sportId: string;
+    sporthub: {
+        id: SportHubSlug;
+        slug: SportHubSlug;
+    };
+    activeGamesCount: number;
+    activeLiveGamesCount: number;
+    activePrematchGamesCount: number;
+    countries: {
+        id: string;
+        slug: string;
+        name: string;
+        turnover: string;
+        activeGamesCount: number;
+        activeLiveGamesCount: number;
+        activePrematchGamesCount: number;
+        leagues: {
+            id: string;
+            slug: string;
+            name: string;
+            turnover: string;
+            activeGamesCount: number;
+            activeLiveGamesCount: number;
+            activePrematchGamesCount: number;
+        }[];
+    }[];
+};
+type GetNavigationResponse = {
+    sports: NavigationSportData[];
+};
+export type GetNavigationResult = GetNavigationResponse['sports'];
+/**
+ * Fetches navigation structure with sports, countries, and leagues hierarchy.
+ * Returns active game counts at each level for building navigation menus.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getNavigation
+ *
+ * @example
+ * import { getNavigation } from '@azuro-org/toolkit'
+ *
+ * const sports = await getNavigation({
+ *   chainId: 137,
+ *   sportHub: 'sports',
+ * })
+ * */
+export declare const getNavigation: (props: GetNavigationParams) => Promise<GetNavigationResult>;
+export {};

package/dist/utils/feed/getSports.d.ts

@@ -0,0 +1,57 @@
+import type { GameState } from '../../global';
+import type { ChainId } from '../../config';
+import type { GameData, SportHubSlug } from './types';
+export type GetSportsParams = {
+    chainId: ChainId;
+    states?: GameState[];
+    /** 1-based, default: 1 */
+    page?: number;
+    /** default: 100 */
+    perPage?: number;
+    sportIds?: (string | number)[];
+    sportHub?: SportHubSlug;
+    countrySlug?: string;
+    leagueSlug?: string;
+    orderBy?: 'turnover' | 'startsAt';
+    orderDir?: 'asc' | 'desc';
+};
+export type SportData = {
+    id: number;
+    slug: string;
+    name: string;
+    sportId: string;
+    turnover: string;
+    countries: {
+        slug: string;
+        name: string;
+        turnover: string;
+        leagues: {
+            slug: string;
+            name: string;
+            turnover: string;
+            games: GameData[];
+        }[];
+    }[];
+};
+type GetSportsResponse = {
+    sports: SportData[];
+};
+export type GetSportsResult = GetSportsResponse['sports'];
+/**
+ * Fetches a complete sports hierarchy including countries, leagues, and games.
+ * Returns nested structure with all games organized by sport, country, and league.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/getSports
+ *
+ * @example
+ * import { GameState, getSports } from '@azuro-org/toolkit'
+ *
+ * const sports = await getSports({
+ *   chainId: 137,
+ *   states: [GameState.Prematch, GameState.Live],
+ *   page: 1,
+ *   perPage: 50,
+ * })
+ * */
+export declare const getSports: (props: GetSportsParams) => Promise<GetSportsResult>;
+export {};

package/dist/utils/feed/searchGames.d.ts

@@ -0,0 +1,29 @@
+import type { ChainId } from '../../config';
+import type { PaginatedGamesResponse } from './types';
+export type SearchGamesParams = {
+    chainId: ChainId;
+    /** minimum 3 characters long */
+    query: string;
+    /** 1-based, default: 1 */
+    page?: number;
+    /** 1-based, default: 10 */
+    perPage?: number;
+};
+export type SearchGamesResult = PaginatedGamesResponse;
+/**
+ * Searches for games by text query across game titles, leagues, and countries.
+ * Minimum query length is 3 characters. Returns paginated results.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/feed/searchGames
+ *
+ * @example
+ * import { searchGames } from '@azuro-org/toolkit'
+ *
+ * const { games } = await searchGames({
+ *   chainId: 137,
+ *   query: 'Manchester',
+ *   page: 1,
+ *   perPage: 10,
+ * })
+ * */
+export declare const searchGames: (props: SearchGamesParams) => Promise<SearchGamesResult>;

package/dist/utils/feed/types.d.ts

@@ -0,0 +1,46 @@
+import type { GameState } from '../../global';
+export declare enum GameOrderBy {
+    StartsAt = "startsAt",
+    Turnover = "turnover"
+}
+export type GameParticipant = {
+    image: string | null | undefined;
+    name: string;
+};
+export type SportHubSlug = string;
+export type GameData = {
+    id: string;
+    gameId: string;
+    slug: string;
+    title: string;
+    startsAt: string;
+    state: GameState;
+    turnover: string;
+    sport: {
+        sportId: string;
+        slug: string;
+        name: string;
+        sporthub: {
+            id: SportHubSlug;
+            slug: SportHubSlug;
+        };
+    };
+    league: {
+        id?: string;
+        slug: string;
+        name: string;
+    };
+    country: {
+        id?: string;
+        slug: string;
+        name: string;
+    };
+    participants: GameParticipant[];
+};
+export type PaginatedGamesResponse = {
+    games: GameData[];
+    page: number;
+    perPage: number;
+    total: number;
+    totalPages: number;
+};

package/dist/utils/getEndpoints.d.ts

@@ -1,4 +1,5 @@
 import { type ChainId } from '../config';
+/** @deprecated Use REST API instead */
 export declare const getFeedGraphqlEndpoint: (chainId: ChainId) => string;
 export declare const getBetsGraphqlEndpoint: (chainId: ChainId) => string;
 /**

package/dist/utils/getIsPendingResolution.d.ts

@@ -1,7 +1,20 @@
-import { GameState } from '../docs/feed/types';
-type Props = {
+import { GameState } from '../global';
+export type GetIsPendingResolutionParams = {
     state: GameState;
     startsAt: string;
 };
-export declare const getIsPendingResolution: ({ state, startsAt }: Props) => boolean;
-export {};
+/**
+ * Determines if a game is pending resolution after completion.
+ * Returns true if the game is in Live state but has exceeded the expected resolution window (100 minutes after start).
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/getIsPendingResolution
+ *
+ * @example
+ * import { getIsPendingResolution, GameState } from '@azuro-org/toolkit'
+ *
+ * const isPending = getIsPendingResolution({
+ *   state: GameState.Live,
+ *   startsAt: '1640000000'
+ * })
+ * */
+export declare const getIsPendingResolution: ({ state, startsAt }: GetIsPendingResolutionParams) => boolean;

package/dist/utils/getProviderFromId.d.ts

@@ -1 +1,13 @@
+/**
+ * Extracts the provider ID from a condition ID string.
+ * The provider ID is encoded in characters 2-4 of the condition ID.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/getProviderFromId
+ *
+ * @example
+ * import { getProviderFromId } from '@azuro-org/toolkit'
+ *
+ * const providerId = getProviderFromId('C001234567890')
+ * console.log(providerId) // 001
+ * */
 export declare const getProviderFromId: (id: string) => number;

package/dist/utils/groupConditionsByMarket.d.ts

@@ -1,6 +1,5 @@
-import { type ConditionsQuery } from '../docs/feed/conditions';
-import { ConditionState } from '../docs/feed/types';
-import type { Selection } from '../global';
+import type { ConditionDetailedData } from './feed/getConditionsByGameIds';
+import { ConditionState, type Selection } from '../global';
 export type MarketOutcome = {
     selectionName: string;
     odds: number;
@@ -23,5 +22,24 @@ type Condition = {
 };
 export type Market = TMarket<Condition[]>;
 export type GameMarkets = Market[];
-export declare const groupConditionsByMarket: (conditions: ConditionsQuery["conditions"]) => GameMarkets;
+/**
+ * Groups game conditions by their market types and sorts them according to sport-specific ordering.
+ * It processes outcomes to include selection names, handles duplicate conditions, and organizes data for display.
+ *
+ * - Docs: https://gem.azuro.org/hub/apps/toolkit/utils/groupConditionsByMarket
+ *
+ * @example
+ * import { groupConditionsByMarket } from '@azuro-org/toolkit'
+ *
+ * const conditions = await getConditionsByGameIds({ gameIds: ['123'] })
+ * const markets = groupConditionsByMarket(conditions)
+ *
+ * markets.forEach(market => {
+ *   console.log(market.name) // e.g., "Match Winner", "Total Goals"
+ *   market.conditions.forEach(condition => {
+ *     console.log(condition.outcomes) // outcomes with odds and selection names
+ *   })
+ * })
+ * */
+export declare const groupConditionsByMarket: (conditions: ConditionDetailedData[]) => GameMarkets;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azuro-org/toolkit",
-  "version": "5.2.0-beta.1",
+  "version": "6.0.0-beta.0",
   "description": "This framework-agnostic package provides essential utilities for building applications on the Azuro Protocol.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/docs/bets/bets.d.ts

@@ -1,67 +0,0 @@
-import * as Types from './types';
-export type BetsQueryVariables = Types.Exact<{
-    first?: Types.InputMaybe<Types.Scalars['Int']['input']>;
-    skip?: Types.InputMaybe<Types.Scalars['Int']['input']>;
-    where: Types.V3_Bet_Filter;
-    orderBy?: Types.InputMaybe<Types.V3_Bet_OrderBy>;
-    orderDirection?: Types.InputMaybe<Types.OrderDirection>;
-}>;
-export type BetsQuery = {
-    __typename?: 'Query';
-    v3Bets: Array<{
-        __typename?: 'V3_Bet';
-        id: string;
-        actor: string;
-        amount: string;
-        status: Types.BetStatus;
-        potentialPayout: string;
-        payout?: string | null;
-        result?: Types.BetResult | null;
-        odds: string;
-        settledOdds?: string | null;
-        redeemedTxHash?: string | null;
-        affiliate: string;
-        isRedeemed: boolean;
-        isRedeemable: boolean;
-        isCashedOut: boolean;
-        freebetId?: string | null;
-        isFreebetAmountReturnable?: boolean | null;
-        paymasterContractAddress?: string | null;
-        tokenId: string;
-        createdAt: string;
-        resolvedAt?: string | null;
-        txHash: string;
-        core: {
-            __typename?: 'CoreContract';
-            address: string;
-            liquidityPool: {
-                __typename?: 'LiquidityPoolContract';
-                address: string;
-            };
-        };
-        selections: Array<{
-            __typename?: 'V3_Selection';
-            odds: string;
-            result?: Types.SelectionResult | null;
-            conditionKind: Types.V3_SelectionConditionKind;
-            outcome: {
-                __typename?: 'V3_Outcome';
-                outcomeId: string;
-                title?: string | null;
-                condition: {
-                    __typename?: 'V3_Condition';
-                    conditionId: string;
-                    title?: string | null;
-                    status: Types.ConditionStatus;
-                    gameId: string;
-                    wonOutcomeIds?: Array<string> | null;
-                };
-            };
-        }>;
-        cashout?: {
-            __typename?: 'Cashout';
-            payout: string;
-        } | null;
-    }>;
-};
-export declare const BetsDocument: import("graphql/language/ast").DocumentNode;