@azuro-org/toolkit 2.0.0 → 4.0.0

package/dist/utils/calcMindOdds.d.ts

@@ -0,0 +1,6 @@
+type Props = {
+    odds: number | number[];
+    slippage: number;
+};
+export declare const calcMindOdds: (props: Props) => string;
+export {};

package/dist/utils/calcOdds.d.ts

@@ -0,0 +1,28 @@
+import { type Config } from '@wagmi/core';
+import { type ChainId } from '../config';
+import { type Selection } from '../global';
+type OddsData = {
+    conditionId: string;
+    margin: number;
+    reinforcement: number;
+    winningOutcomesCount: number;
+    outcomes: Record<string, {
+        odds: number;
+        clearOdds: number;
+    }>;
+};
+type CalcLiveOddsProps = {
+    selection: Selection;
+    oddsData: OddsData;
+    betAmount?: string;
+};
+export declare const calcLiveOdds: ({ selection, betAmount, oddsData }: CalcLiveOddsProps) => number;
+type CalcPrematchOddsProps = {
+    config: Config;
+    selections: Selection[];
+    chainId: ChainId;
+    betAmount?: string;
+    batchBetAmounts?: Record<string, string>;
+};
+export declare const calcPrematchOdds: (props: CalcPrematchOddsProps) => Promise<Record<string, number>>;
+export {};

package/dist/utils/deBridge/createDeBridgeBet.d.ts

@@ -0,0 +1,65 @@
+import { type Address, type Hex } from 'viem';
+import { type Selection } from '../../global';
+import { type ChainId } from '../../config';
+export type DeBridgeCreateTxResponse = {
+    orderId: Hex;
+    estimation: {
+        srcChainTokenIn: {
+            address: Address;
+            name: string;
+            symbol: string;
+            decimals: number;
+            amount: string;
+            approximateOperatingExpense: string;
+            mutatedWithOperatingExpense: boolean;
+        };
+        srcChainTokenOut: {
+            address: Address;
+            name: string;
+            symbol: string;
+            decimals: number;
+            amount: string;
+            maxRefundAmount: string;
+        };
+        dstChainTokenOut: {
+            address: Address;
+            name: string;
+            symbol: string;
+            decimals: number;
+            amount: string;
+            recommendedAmount: string;
+            withoutAdditionalTakerRewardsAmount: string;
+            maxTheoreticalAmount: string;
+        };
+        recommendedSlippage: number;
+        costsDetails: [string];
+    };
+    tx: {
+        to: Address;
+        data: Hex;
+        value: bigint;
+    };
+    order: {
+        approximateFulfillmentDelay: number;
+    };
+    prependedOperatingExpenseCost: string;
+    fixFee: string;
+    userPoints: number;
+    integratorPoints: number;
+};
+type Props = {
+    account: Address;
+    betAmount: string;
+    dstChainId: ChainId;
+    srcChainId: number;
+    srcChainTokenIn: string;
+    selections: Selection[];
+    totalOdds: number;
+    slippage: number;
+    affiliate: Address;
+    referralCode: number;
+    deadline?: number;
+};
+export declare const DE_BRIDGE_DEFAULT_DEADLINE = 300;
+export declare const createDeBridgeBet: (props: Props) => Promise<DeBridgeCreateTxResponse | null>;
+export {};

package/dist/utils/deBridge/getDeBridgeOrder.d.ts

@@ -0,0 +1,39 @@
+import { type Hex } from 'viem';
+export declare enum DeBridgeOrderStatus {
+    None = "None",
+    Created = "Created",
+    Fulfilled = "Fulfilled",
+    SentUnlock = "SentUnlock",
+    OrderCancelled = "OrderCancelled",
+    SentOrderCancel = "SentOrderCancel",
+    ClaimedUnlock = "ClaimedUnlock",
+    ClaimedOrderCancel = "ClaimedOrderCancel"
+}
+export declare enum DeBridgeExternalCallStatus {
+    NoExtCall = "NoExtCall",
+    AwaitingOrderFulfillment = "AwaitingOrderFulfillment",
+    AwaitingExecution = "AwaitingExecution",
+    Executing = "Executing",
+    Completed = "Completed",
+    Failed = "Failed",
+    Cancelled = "Cancelled"
+}
+type OrderStatusResponse = {
+    orderId: {
+        stringValue: Hex;
+    };
+    fulfilledDstEventMetadata: {
+        transactionHash: {
+            stringValue: Hex;
+        };
+    } | null;
+    state: DeBridgeOrderStatus;
+    externalCallState: DeBridgeExternalCallStatus;
+    takeOfferWithMetadata: {
+        chainId: {
+            bigIntegerValue: number;
+        };
+    };
+};
+export declare const getDeBridgeOrder: (orderId: Hex) => Promise<OrderStatusResponse | null>;
+export {};

package/dist/utils/deBridge/getDeBridgeSupportedChains.d.ts

@@ -0,0 +1,4 @@
+export declare const getDeBridgeSupportedChains: () => Promise<{
+    chainId: number;
+    chainName: string;
+}[] | null>;

package/dist/utils/deBridge/getDeBridgeSupportedTokens.d.ts

@@ -0,0 +1,8 @@
+export declare const getDeBridgeSupportedTokens: (chainId: number) => Promise<Record<string, {
+    address: string;
+    symbol: string;
+    decimals: number;
+    name: string;
+    logoURI: string;
+    tags: Array<string>;
+}> | null>;

package/dist/utils/getBetStatus.d.ts

@@ -0,0 +1,17 @@
+import { BetStatus as GraphBetStatus } from '../docs/prematch/types';
+import { type GameQuery } from '../docs/prematch/game';
+export declare enum BetStatus {
+    Accepted = 0,
+    Live = 1,
+    PendingResolution = 2,
+    Resolved = 3,
+    Canceled = 4
+}
+type Game = Pick<GameQuery['games'][0], 'status' | 'startsAt'>;
+type Props = {
+    games: Game[];
+    graphStatus: GraphBetStatus;
+    isLiveBet: boolean;
+};
+export declare const getBetStatus: (props: Props) => BetStatus;
+export {};

package/dist/utils/getEndpoints.d.ts

@@ -0,0 +1,5 @@
+import { type ChainId } from '../config';
+export declare const getPrematchGraphqlEndpoint: (chainId: ChainId) => string;
+export declare const getLiveGraphqlEndpoint: (chainId: ChainId) => "https://thegraph.azuro.org/subgraphs/name/azuro-protocol/azuro-api-live-data-feed-preprod" | "https://thegraph.azuro.org/subgraphs/name/azuro-protocol/azuro-api-live-data-feed-dev" | "https://thegraph.azuro.org/subgraphs/name/azuro-protocol/azuro-api-live-data-feed";
+export declare const getSocketEndpoint: (chainId: ChainId) => "wss://preprod-streams.azuro.org/v1/streams/conditions" | "wss://dev-streams.azuro.org/v1/streams/conditions" | "wss://streams.azuro.org/v1/streams/conditions";
+export declare const getApiEndpoint: (chainId: ChainId) => "https://preprod-api.azuro.org/api/v1/public" | "https://dev-api.azuro.org/api/v1/public" | "https://api.azuro.org/api/v1/public";

package/dist/utils/getFreebets.d.ts

@@ -0,0 +1,35 @@
+import { type Hex, type Address } from 'viem';
+import { type ChainId } from '../config';
+export declare enum FreeBetStatus {
+    New = "New",
+    Claimed = "Claimed",
+    Redeemed = "Redeemed",
+    Canceled = "Canceled",
+    Reissued = "Reissued",
+    Withdrawn = "Withdrawn"
+}
+export type FreeBet = {
+    id: number;
+    owner: Address;
+    amount: string;
+    minOdds: string;
+    contractId: number;
+    signature: Hex;
+    expiresAt: number;
+    campaign: string;
+    status: FreeBetStatus;
+    contract: {
+        id: number;
+        affiliate: Address;
+        chainId: string;
+        freebetContractAddress: Address;
+        decimals: number;
+    };
+};
+type Props = {
+    chainId: ChainId;
+    account: Address;
+    affiliate: Address;
+};
+export declare const getFreeBets: ({ chainId, account, affiliate }: Props) => Promise<FreeBet[] | null>;
+export {};

package/dist/utils/getGameStatus.d.ts

@@ -0,0 +1,16 @@
+import { GameStatus as GraphGameStatus } from '../docs/live/types';
+export declare enum GameStatus {
+    Created = 0,
+    Live = 1,
+    Resolved = 2,
+    Canceled = 3,
+    Paused = 4,
+    PendingResolution = 5
+}
+type Props = {
+    graphStatus: GraphGameStatus;
+    startsAt: number;
+    isGameInLive: boolean;
+};
+export declare const getGameStatus: (props: Props) => GameStatus;
+export {};

package/dist/utils/getLiveBetFee.d.ts

@@ -0,0 +1,14 @@
+import { type ChainId } from '../config';
+export type LiveBetFeeResponse = {
+    gasLimit: number;
+    gasPrice: number;
+    betTokenRate: number;
+    gasPriceInBetToken: number;
+    slippage: number;
+    gasAmount: number;
+    relayerFeeAmount: string;
+    beautyRelayerFeeAmount: string;
+    symbol: string;
+    decimals: number;
+};
+export declare const getLiveBetFee: (chainId: ChainId) => Promise<LiveBetFeeResponse>;

package/dist/utils/getPrematchBetDataBytes.d.ts

@@ -0,0 +1,3 @@
+import { type Hex } from 'viem';
+import { type Selection } from '../global';
+export declare const getPrematchBetDataBytes: (selections: Selection[]) => Hex;

package/dist/utils/groupByConditionId.d.ts

@@ -0,0 +1,5 @@
+type Condition = {
+    conditionId: string;
+};
+export declare const groupByConditionId: <T extends Condition>(data: T[]) => Record<string, T[]>;
+export {};

package/dist/utils/groupConditionsByMarket.d.ts

@@ -0,0 +1,23 @@
+import type { ConditionStatus } from '../docs/prematch/types';
+import { type PrematchConditionsQuery } from '../docs/prematch/conditions';
+import { type LiveConditionsQuery } from '../docs/live/conditions';
+import type { Selection } from '../global';
+export type ConditionsQuery = PrematchConditionsQuery | LiveConditionsQuery;
+export type MarketOutcome = {
+    selectionName: string;
+    odds?: number;
+    lpAddress: string;
+    coreAddress: string;
+    status: ConditionStatus;
+    gameId: string;
+    isExpressForbidden: boolean;
+    isWon?: boolean;
+} & Selection;
+export type Market = {
+    marketKey: string;
+    name: string;
+    description: string;
+    outcomeRows: MarketOutcome[][];
+};
+export type GameMarkets = Market[];
+export declare const groupConditionsByMarket: (conditions: ConditionsQuery["conditions"]) => GameMarkets;

package/dist/utils/setupContracts.d.ts

@@ -0,0 +1,37 @@
+import { type Address } from 'viem';
+import { liveCoreAbi, lpAbi, prematchComboCoreAbi, prematchCoreAbi, proxyFrontAbi } from '../abis';
+export type Contracts = {
+    lp: {
+        address: Address;
+        abi: typeof lpAbi;
+    };
+    prematchCore: {
+        address: Address;
+        abi: typeof prematchCoreAbi;
+    };
+    prematchComboCore: {
+        address: Address;
+        abi: typeof prematchComboCoreAbi;
+    };
+    proxyFront: {
+        address: Address;
+        abi: typeof proxyFrontAbi;
+    };
+    liveRelayer?: {
+        address: Address;
+    };
+    liveCore?: {
+        address: Address;
+        abi: typeof liveCoreAbi;
+    };
+};
+type Props = {
+    lp: Address;
+    prematchCore: Address;
+    prematchComboCore: Address;
+    proxyFront: Address;
+    liveRelayer?: Address;
+    liveCore?: Address;
+};
+export declare const setupContracts: ({ lp, prematchCore, prematchComboCore, proxyFront, liveRelayer, liveCore }: Props) => Contracts;
+export {};

package/dist/utils/wave/activateWave.d.ts

@@ -0,0 +1,10 @@
+import { type Address } from 'viem';
+import { type ChainId } from '../../config';
+import { type WaveId } from '../../global';
+type Props = {
+    account: Address;
+    waveId?: WaveId;
+    chainId?: ChainId;
+};
+export declare const activateWave: ({ account, waveId, chainId }: Props) => Promise<void>;
+export {};

package/dist/utils/wave/getWaveLeaderBoard.d.ts

@@ -0,0 +1,22 @@
+import { type Address } from 'viem';
+import { type ChainId } from '../../config';
+import { type WaveId } from '../../global';
+import { type WaveLevelData } from './getWaveLevels';
+export type WaveLeaderBoardItem = {
+    position: number;
+    address: Address;
+    points: string;
+    bonusPoints: string | null;
+    totalMultipliedPoints: string;
+    bonusMultiplier: number | null;
+    level: number | null;
+    levelDescription: WaveLevelData | null;
+};
+type Props = {
+    waveId?: WaveId;
+    account?: Address;
+    startsAt?: number;
+    chainId?: ChainId;
+};
+export declare const getWaveLeaderBoard: (props?: Props) => Promise<WaveLeaderBoardItem[] | null>;
+export {};

package/dist/utils/wave/getWaveLevels.d.ts

@@ -0,0 +1,26 @@
+import { type ChainId } from '../../config';
+import { type WaveId } from '../../global';
+export declare enum WaveLevelName {
+    Grey = "Grey",
+    Mist = "Mist",
+    Sky = "Sky",
+    Blue = "Blue",
+    Ultramarine = "Ultramarine",
+    Bright = "Bright",
+    Brilliant = "Brilliant",
+    Royal = "Royal"
+}
+export type WaveLevelData = {
+    level: number;
+    name: WaveLevelName;
+    boost: string;
+    pointsNeeded: string;
+    comment: string;
+};
+export type WaveLevelsResponse = WaveLevelData[];
+type Props = {
+    waveId?: WaveId;
+    chainId?: ChainId;
+};
+export declare const getWaveLevels: ({ waveId, chainId }?: Props) => Promise<WaveLevelData[] | null>;
+export {};

package/dist/utils/wave/getWavePeriods.d.ts

@@ -0,0 +1,18 @@
+import { type ChainId } from '../../config';
+import { type WaveId } from '../../global';
+type Period = {
+    id: number;
+    /** ISO String "2024-05-13T00:00:00.000Z" */
+    startsAt: string;
+    /** ISO String "2024-05-20T00:00:00.000Z". It's a startsAt of next period */
+    endsAt: string;
+    totalPoints: string;
+    waveId: number;
+};
+export type WavePeriodsResponse = Period[];
+type Props = {
+    waveId?: WaveId;
+    chainId?: ChainId;
+};
+export declare const getWavePeriods: ({ waveId, chainId }?: Props) => Promise<WavePeriodsResponse | null>;
+export {};

package/dist/utils/wave/getWaveStats.d.ts

@@ -0,0 +1,30 @@
+import { type Address } from 'viem';
+import { type ChainId } from '../../config';
+import { type WaveId } from '../../global';
+import { type WaveLevelData } from './getWaveLevels';
+export type WaveStatsResponse = {
+    address: Address;
+    waveId: number;
+    levelActivated: boolean;
+    initialLevel: number;
+    level: number;
+    betPoints: string;
+    dexPoints: string;
+    liqudityPoints: string;
+    stakingPoints: string;
+    leaderboardPoints: string;
+    manualPoints: string;
+    /** "2.100000", final points without level multiplier */
+    points: string;
+    /** "2.100000", final points with level multiplier ('boost') */
+    multipliedPoints: string;
+    sharePercent: string;
+    levelDescription: WaveLevelData;
+};
+type Props = {
+    account: Address;
+    waveId?: WaveId;
+    chainId?: ChainId;
+};
+export declare const getWaveStats: ({ account, waveId, chainId }: Props) => Promise<WaveStatsResponse | null>;
+export {};

package/graphql.config.yml

@@ -0,0 +1,21 @@
+projects:
+  protocol-dev:
+    schema: protocol.schema.graphql
+    include: src/docs/prematch/**/*.graphql
+    extensions:
+      endpoints:
+        Protocol:
+          url: https://thegraph.azuro.org/subgraphs/name/azuro-protocol/azuro-api-mumbai-dev-v3
+          headers:
+            user-agent: JS GraphQL
+          introspect: false
+  live-dev:
+    schema: live.schema.graphql
+    include: src/docs/live/**/*.graphql
+    extensions:
+      endpoints:
+        Protocol:
+          url: https://thegraph.azuro.org/subgraphs/name/azuro-protocol/azuro-api-live-data-feed-preprod
+          headers:
+            user-agent: JS GraphQL
+          introspect: false

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "@azuro-org/toolkit",
-  "version": "2.0.0",
+  "version": "4.0.0",
   "description": "Set of helpers to work with Azuro protocol",
-  "module": "dist/index.es.js",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
+    "gql:cleanup": "rimraf src/docs/**/*.ts src/docs/**/**/*.ts",
+    "gql": "npm run gql:cleanup & graphql-codegen",
     "dev": "rollup -cw",
-    "build": "rimraf ./dist && rimraf ./lib && rollup -c --compact",
-    "prepublishOnly": "npm run build"
+    "build": "rimraf ./dist && npm run gql && rollup -c --compact",
+    "prepublishOnly": "npm run build",
+    "------------------  Lint --------------------------------------------------------------------------------": "",
+    "lint": "next lint && tsc --noEmit",
+    "lint-fix": "eslint ./src -c .eslintrc --fix --ext js,ts,tsx",
+    "lint-ts": "tsc --noEmit"
   },
   "keywords": [
     "azuro",
@@ -27,9 +32,20 @@
   },
   "homepage": "https://github.com/Azuro-protocol/toolkit#readme",
   "peerDependencies": {
-    "@azuro-org/dictionaries": "^2.0.2"
+    "@apollo/client": "^3.10.8",
+    "@azuro-org/dictionaries": "^3.0.12",
+    "viem": "^2.17.3",
+    "@wagmi/core": "^2.11.7"
   },
   "devDependencies": {
+    "@graphql-codegen/cli": "^4.0.1",
+    "@graphql-codegen/client-preset": "^4.0.0",
+    "@graphql-codegen/near-operation-file-preset": "^2.5.0",
+    "@graphql-codegen/typescript-react-apollo": "^3.3.7",
+    "@typescript-eslint/eslint-plugin": "^6.19.1",
+    "eslint": "^8.56.0",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.1",
     "@babel/core": "^7.17.0",
     "@rollup/plugin-babel": "^6.0.3",
     "@rollup/plugin-commonjs": "^23.0.3",
@@ -42,6 +58,6 @@
     "rollup-plugin-babel": "^4.4.0",
     "rollup-plugin-typescript2": "^0.34.1",
     "tslib": "^2.4.1",
-    "typescript": "^4.6.2"
+    "typescript": "^5.1.6"
   }
 }

package/tsconfig.json

@@ -1,19 +1,34 @@
 {
   "compilerOptions": {
-    "target": "es5",
+    "baseUrl": ".",
+    "allowJs": true,
+    "downlevelIteration": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "lib": ["es2021", "dom"],
     "module": "esnext",
     "moduleResolution": "node",
-    "lib": [ "es2017", "es7", "es6", "dom" ],
-    "outDir": "lib",
-    "jsx": "react",
-    "strict": true,
     "declaration": true,
-    "declarationDir": ".",
-    "esModuleInterop": true
+    "declarationDir": "dist",
+    "noEmit": true,
+    "noImplicitAny": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedParameters": false,
+    "noImplicitReturns": false,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "target": "es2021",
+    "types": ["node"]
   },
   "exclude": [
-    "node_modules",
-    "dist",
-    "lib"
+    "**/node_modules/**",
+    "**/dist/**"
+  ],
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx"
   ]
 }

package/dist/aggregateOutcomesByMarkets.d.ts

@@ -1,27 +0,0 @@
-import { type Dictionaries } from '@azuro-org/dictionaries';
-type Outcome<T> = T & {
-    conditionId: string;
-    outcomeId: string;
-    selectionName: string;
-    lpAddress: string;
-    coreAddress: string;
-};
-type FinalMarket<T> = {
-    marketName: string;
-    outcomes: Outcome<T>[][];
-};
-type Props = {
-    lpAddress: string;
-    conditions: {
-        [key: string]: any;
-        conditionId: string;
-        coreAddress: string;
-        outcomes: {
-            [key: string]: any;
-            outcomeId: string;
-        }[];
-    }[];
-    dictionaries: Dictionaries;
-};
-export default function aggregateOutcomesByMarkets<T extends {}>(props: Props): FinalMarket<T>[];
-export {};