@alephium/powfi-backend 0.0.1-rc.2

package/dist/types/routes/pools.d.ts

@@ -0,0 +1,290 @@
+import { Elysia } from 'elysia';
+import type { PaginatedApiResponse } from './response';
+import type { LiquidityLineData } from '../services/stat/poolStatsServiceTypes';
+import type { ApiPoolListResponse, ApiPoolEventsResponse, ApiPoolListFromIdsResponse, ApiPoolWithStats, ClmmLiquidityLinePayload } from '../api/types';
+export declare const poolsRouter: Elysia<"/pools", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    pools: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                token1?: string | undefined;
+                poolType?: "standard" | "concentrated" | "all" | undefined;
+                page?: number | undefined;
+                pageSize?: number | undefined;
+                token2?: string | undefined;
+                sortType?: "asc" | "desc" | undefined;
+            };
+            headers: unknown;
+            response: {
+                400: {
+                    code: "BAD_REQUEST" | "INVALID_FILE_TYPE" | "PARSE" | "INVALID_COOKIE_SIGNATURE";
+                    message: string;
+                    error: "Bad request";
+                    details?: Record<string, unknown> | undefined;
+                };
+                404: {
+                    code: "RESOURCE_NOT_FOUND";
+                    message: string;
+                    error: "Resource not found";
+                    details?: Record<string, unknown> | undefined;
+                };
+                422: {
+                    code: "VALIDATION";
+                    message: string;
+                    error: "Validation error";
+                    details?: Record<string, unknown> | undefined;
+                };
+                500: {
+                    code: "INTERNAL_SERVER_ERROR";
+                    message: string;
+                    error: "Internal server error";
+                    details?: Record<string, unknown> | undefined;
+                };
+                200: PaginatedApiResponse<ApiPoolListResponse>;
+            };
+        };
+    };
+} & {
+    pools: {
+        post: {
+            body: {
+                ids: string[];
+            };
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                400: {
+                    code: "BAD_REQUEST" | "INVALID_FILE_TYPE" | "PARSE" | "INVALID_COOKIE_SIGNATURE";
+                    message: string;
+                    error: "Bad request";
+                    details?: Record<string, unknown> | undefined;
+                };
+                404: {
+                    code: "RESOURCE_NOT_FOUND";
+                    message: string;
+                    error: "Resource not found";
+                    details?: Record<string, unknown> | undefined;
+                };
+                422: {
+                    code: "VALIDATION";
+                    message: string;
+                    error: "Validation error";
+                    details?: Record<string, unknown> | undefined;
+                };
+                500: {
+                    code: "INTERNAL_SERVER_ERROR";
+                    message: string;
+                    error: "Internal server error";
+                    details?: Record<string, unknown> | undefined;
+                };
+                200: ApiPoolListFromIdsResponse;
+            };
+        };
+    };
+} & {
+    pools: {
+        ":id": {
+            get: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: {
+                        code: "BAD_REQUEST" | "INVALID_FILE_TYPE" | "PARSE" | "INVALID_COOKIE_SIGNATURE";
+                        message: string;
+                        error: "Bad request";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    404: {
+                        code: "RESOURCE_NOT_FOUND";
+                        message: string;
+                        error: "Resource not found";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    422: {
+                        code: "VALIDATION";
+                        message: string;
+                        error: "Validation error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    500: {
+                        code: "INTERNAL_SERVER_ERROR";
+                        message: string;
+                        error: "Internal server error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    200: ApiPoolWithStats;
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        ":id": {
+            events: {
+                get: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    };
+                    query: {
+                        page?: number | undefined;
+                        pageSize?: number | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        400: {
+                            code: "BAD_REQUEST" | "INVALID_FILE_TYPE" | "PARSE" | "INVALID_COOKIE_SIGNATURE";
+                            message: string;
+                            error: "Bad request";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        404: {
+                            code: "RESOURCE_NOT_FOUND";
+                            message: string;
+                            error: "Resource not found";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        422: {
+                            code: "VALIDATION";
+                            message: string;
+                            error: "Validation error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        500: {
+                            code: "INTERNAL_SERVER_ERROR";
+                            message: string;
+                            error: "Internal server error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        200: PaginatedApiResponse<ApiPoolEventsResponse>;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        ":id": {
+            line: {
+                position: {
+                    get: {
+                        body: unknown;
+                        params: {
+                            id: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            400: {
+                                code: "BAD_REQUEST" | "INVALID_FILE_TYPE" | "PARSE" | "INVALID_COOKIE_SIGNATURE";
+                                message: string;
+                                error: "Bad request";
+                                details?: Record<string, unknown> | undefined;
+                            };
+                            404: {
+                                code: "RESOURCE_NOT_FOUND";
+                                message: string;
+                                error: "Resource not found";
+                                details?: Record<string, unknown> | undefined;
+                            };
+                            422: {
+                                code: "VALIDATION";
+                                message: string;
+                                error: "Validation error";
+                                details?: Record<string, unknown> | undefined;
+                            };
+                            500: {
+                                code: "INTERNAL_SERVER_ERROR";
+                                message: string;
+                                error: "Internal server error";
+                                details?: Record<string, unknown> | undefined;
+                            };
+                            200: ClmmLiquidityLinePayload;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        ":id": {
+            line: {
+                liquidity: {
+                    get: {
+                        body: unknown;
+                        params: {
+                            id: string;
+                        };
+                        query: {
+                            startTime?: number | undefined;
+                            endTime?: number | undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            400: {
+                                code: "BAD_REQUEST" | "INVALID_FILE_TYPE" | "PARSE" | "INVALID_COOKIE_SIGNATURE";
+                                message: string;
+                                error: "Bad request";
+                                details?: Record<string, unknown> | undefined;
+                            };
+                            404: {
+                                code: "RESOURCE_NOT_FOUND";
+                                message: string;
+                                error: "Resource not found";
+                                details?: Record<string, unknown> | undefined;
+                            };
+                            422: {
+                                code: "VALIDATION";
+                                message: string;
+                                error: "Validation error";
+                                details?: Record<string, unknown> | undefined;
+                            };
+                            500: {
+                                code: "INTERNAL_SERVER_ERROR";
+                                message: string;
+                                error: "Internal server error";
+                                details?: Record<string, unknown> | undefined;
+                            };
+                            200: LiquidityLineData;
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+//# sourceMappingURL=pools.d.ts.map

package/dist/types/routes/pools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pools.d.ts","sourceRoot":"","sources":["../../../src/routes/pools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAK,MAAM,QAAQ,CAAC;AAGnC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAG/E,OAAO,KAAK,EACV,mBAAmB,EACnB,qBAAqB,EACrB,0BAA0B,EAC1B,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,aAAa,CAAC;AAkBrB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkTrB,CAAC"}

package/dist/types/routes/response.d.ts

@@ -0,0 +1,83 @@
+export type PaginatedApiResponse<T> = {
+    data: T & {
+        meta: {
+            page: number;
+            pageSize: number;
+            totalPages: number;
+        };
+    };
+};
+export declare function badRequest(message: string): never;
+export declare function notFound(subject: string): never;
+export declare function internalServerError(error: unknown): never;
+export declare const DefaultErrorResponseSchemas: {
+    400: import("zod").ZodObject<{
+        message: import("zod").ZodString;
+        details: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    } & {
+        error: import("zod").ZodLiteral<"Bad request">;
+        code: import("zod").ZodEnum<["BAD_REQUEST", "INVALID_FILE_TYPE", "PARSE", "INVALID_COOKIE_SIGNATURE"]>;
+    }, "strip", import("zod").ZodTypeAny, {
+        code: "BAD_REQUEST" | "INVALID_FILE_TYPE" | "PARSE" | "INVALID_COOKIE_SIGNATURE";
+        message: string;
+        error: "Bad request";
+        details?: Record<string, unknown> | undefined;
+    }, {
+        code: "BAD_REQUEST" | "INVALID_FILE_TYPE" | "PARSE" | "INVALID_COOKIE_SIGNATURE";
+        message: string;
+        error: "Bad request";
+        details?: Record<string, unknown> | undefined;
+    }>;
+    404: import("zod").ZodObject<{
+        message: import("zod").ZodString;
+        details: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    } & {
+        error: import("zod").ZodLiteral<"Resource not found">;
+        code: import("zod").ZodEnum<["RESOURCE_NOT_FOUND"]>;
+    }, "strip", import("zod").ZodTypeAny, {
+        code: "RESOURCE_NOT_FOUND";
+        message: string;
+        error: "Resource not found";
+        details?: Record<string, unknown> | undefined;
+    }, {
+        code: "RESOURCE_NOT_FOUND";
+        message: string;
+        error: "Resource not found";
+        details?: Record<string, unknown> | undefined;
+    }>;
+    422: import("zod").ZodObject<{
+        message: import("zod").ZodString;
+        details: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    } & {
+        error: import("zod").ZodLiteral<"Validation error">;
+        code: import("zod").ZodEnum<["VALIDATION"]>;
+    }, "strip", import("zod").ZodTypeAny, {
+        code: "VALIDATION";
+        message: string;
+        error: "Validation error";
+        details?: Record<string, unknown> | undefined;
+    }, {
+        code: "VALIDATION";
+        message: string;
+        error: "Validation error";
+        details?: Record<string, unknown> | undefined;
+    }>;
+    500: import("zod").ZodObject<{
+        message: import("zod").ZodString;
+        details: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    } & {
+        error: import("zod").ZodLiteral<"Internal server error">;
+        code: import("zod").ZodEnum<["INTERNAL_SERVER_ERROR"]>;
+    }, "strip", import("zod").ZodTypeAny, {
+        code: "INTERNAL_SERVER_ERROR";
+        message: string;
+        error: "Internal server error";
+        details?: Record<string, unknown> | undefined;
+    }, {
+        code: "INTERNAL_SERVER_ERROR";
+        message: string;
+        error: "Internal server error";
+        details?: Record<string, unknown> | undefined;
+    }>;
+};
+//# sourceMappingURL=response.d.ts.map

package/dist/types/routes/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../src/routes/response.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI;IACpC,IAAI,EAAE,CAAC,GAAG;QACR,IAAI,EAAE;YACJ,IAAI,EAAE,MAAM,CAAC;YACb,QAAQ,EAAE,MAAM,CAAC;YACjB,UAAU,EAAE,MAAM,CAAC;SACpB,CAAC;KACH,CAAC;CACH,CAAC;AAEF,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAEjD;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAE/C;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAwBzD;AAGD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKvC,CAAC"}

package/dist/types/routes/stats.d.ts

@@ -0,0 +1,69 @@
+import { Elysia } from 'elysia';
+import type { ApiGlobalStats } from '../api/types';
+export declare const statsRouter: Elysia<"/stats", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    stats: {
+        global: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: {
+                        code: "BAD_REQUEST" | "INVALID_FILE_TYPE" | "PARSE" | "INVALID_COOKIE_SIGNATURE";
+                        message: string;
+                        error: "Bad request";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    404: {
+                        code: "RESOURCE_NOT_FOUND";
+                        message: string;
+                        error: "Resource not found";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    422: {
+                        code: "VALIDATION";
+                        message: string;
+                        error: "Validation error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    500: {
+                        code: "INTERNAL_SERVER_ERROR";
+                        message: string;
+                        error: "Internal server error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    200: ApiGlobalStats;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+//# sourceMappingURL=stats.d.ts.map

package/dist/types/routes/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../src/routes/stats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKlD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBvB,CAAC"}

package/dist/types/routes/tokens.d.ts

@@ -0,0 +1,71 @@
+import { Elysia } from 'elysia';
+import type { TokenInfo } from '@alephium/token-list';
+export interface TokenListResponse {
+    count: number;
+    tokens: TokenInfo[];
+}
+export declare const tokensRouter: Elysia<"/tokens", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    tokens: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                400: {
+                    code: "BAD_REQUEST" | "INVALID_FILE_TYPE" | "PARSE" | "INVALID_COOKIE_SIGNATURE";
+                    message: string;
+                    error: "Bad request";
+                    details?: Record<string, unknown> | undefined;
+                };
+                404: {
+                    code: "RESOURCE_NOT_FOUND";
+                    message: string;
+                    error: "Resource not found";
+                    details?: Record<string, unknown> | undefined;
+                };
+                422: {
+                    code: "VALIDATION";
+                    message: string;
+                    error: "Validation error";
+                    details?: Record<string, unknown> | undefined;
+                };
+                500: {
+                    code: "INTERNAL_SERVER_ERROR";
+                    message: string;
+                    error: "Internal server error";
+                    details?: Record<string, unknown> | undefined;
+                };
+                200: TokenListResponse;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/types/routes/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/routes/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKhC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAItD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBxB,CAAC"}

package/dist/types/routes/websocket.d.ts

@@ -0,0 +1,42 @@
+import { Elysia } from 'elysia';
+export declare const websocketRouter: Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    ws: {
+        "pool-state": {
+            subscribe: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {};
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+//# sourceMappingURL=websocket.d.ts.map

package/dist/types/routes/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../../src/routes/websocket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAiBhC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmD1B,CAAC"}

package/dist/types/services/Services.d.ts

@@ -0,0 +1,23 @@
+import { Zeta } from '@h0ngcha0/typescript-sdk';
+import { PriceService } from './price/priceService';
+import { PoolService } from './pool/poolService';
+import { PoolStateService } from './pool/poolStateService';
+import { PoolStatsService } from './stat/poolStatsService';
+import { PoolEventsSubscriptionService } from './pool/poolEventsSubscriptionService';
+import { StandardPoolEventsHandler, ClmmPoolEventsHandler } from './pool/poolEventsHandler';
+import { ComputeService } from './compute/computeService';
+export declare class Services {
+    private static instance;
+    readonly zeta: Zeta;
+    readonly priceService: PriceService;
+    readonly poolService: PoolService;
+    readonly poolStatsService: PoolStatsService;
+    readonly poolStateService: PoolStateService;
+    readonly poolEventsSubscriptionService: PoolEventsSubscriptionService;
+    readonly standardPoolEventsHandler: StandardPoolEventsHandler;
+    readonly clmmPoolEventsHandler: ClmmPoolEventsHandler;
+    readonly computeService: ComputeService;
+    private constructor();
+    static getInstance(): Services;
+}
+//# sourceMappingURL=Services.d.ts.map

package/dist/types/services/Services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Services.d.ts","sourceRoot":"","sources":["../../../src/services/Services.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAEhD,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,6BAA6B,EAAE,MAAM,8CAA8C,CAAC;AAC7F,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACpG,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAElE,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAW;IAElC,SAAgB,IAAI,EAAE,IAAI,CAAC;IAC3B,SAAgB,YAAY,EAAE,YAAY,CAAC;IAC3C,SAAgB,WAAW,EAAE,WAAW,CAAC;IACzC,SAAgB,gBAAgB,EAAE,gBAAgB,CAAC;IACnD,SAAgB,gBAAgB,EAAE,gBAAgB,CAAC;IACnD,SAAgB,6BAA6B,EAAE,6BAA6B,CAAC;IAC7E,SAAgB,yBAAyB,EAAE,yBAAyB,CAAC;IACrE,SAAgB,qBAAqB,EAAE,qBAAqB,CAAC;IAC7D,SAAgB,cAAc,EAAE,cAAc,CAAC;IAE/C,OAAO;IAgCP,MAAM,CAAC,WAAW,IAAI,QAAQ;CAM/B"}

package/dist/types/services/compute/computeService.d.ts

@@ -0,0 +1,80 @@
+import type { Zeta, SwapDetails } from '@h0ngcha0/typescript-sdk';
+import type { PriceService } from '../price/priceService';
+import type { PoolStateService } from '../pool/poolStateService';
+import type { TokenInfo } from '@alephium/token-list';
+import type { SwapComputeResult } from '../../services/compute/computeServiceTypes';
+import { PoolType } from '../../common/types';
+export interface SwapBaseInParams {
+    inputMint: string;
+    outputMint: string;
+    amount: string;
+    slippageBps?: string;
+    poolType?: PoolType;
+}
+export interface SwapBaseOutParams {
+    inputMint: string;
+    outputMint: string;
+    amount: string;
+    slippageBps?: string;
+    poolType?: PoolType;
+}
+export declare class ComputeServiceError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export declare class ComputeService {
+    private zeta;
+    private priceService;
+    private poolStateService;
+    constructor(zeta: Zeta, priceService: PriceService, poolStateService: PoolStateService);
+    computeSwapBaseIn(params: SwapBaseInParams): Promise<SwapComputeResult>;
+    computeSwapBaseOut(params: SwapBaseOutParams): Promise<SwapComputeResult>;
+    parseSlippageBps(slippageBps?: string): number;
+    getTokenInfo(id: string): Promise<TokenInfo>;
+    getPoolState(inputTokenId: string, outputTokenId: string): Promise<import("@h0ngcha0/typescript-sdk").CpmmPoolContractState>;
+    convertSwapDetailsToResponse(swapDetails: SwapDetails, slippage: number): Promise<SwapComputeResult>;
+    computeClmmSwapBaseIn(params: {
+        inputMint: string;
+        outputMint: string;
+        amount: bigint;
+        slippage: number;
+    }): Promise<SwapComputeResult>;
+    computeClmmSwapBaseOut(params: {
+        inputMint: string;
+        outputMint: string;
+        amount: bigint;
+        slippage: number;
+    }): Promise<SwapComputeResult>;
+    applySlippage(value: bigint, slippageBps: number, direction: 'min' | 'max'): bigint;
+    getClmmSwapContext(inputMint: string, outputMint: string): Promise<{
+        inputToken: TokenInfo;
+        outputToken: TokenInfo;
+        token0Info: TokenInfo;
+        token1Info: TokenInfo;
+        zeroForOne: boolean;
+        configIndex: bigint;
+    }>;
+    calculateClmmPriceImpact(distribution: {
+        baseSqrtPriceX96: bigint;
+        sqrtPriceX96: bigint;
+    }, context: {
+        token0Info: TokenInfo;
+        token1Info: TokenInfo;
+        inputToken: TokenInfo;
+        outputToken: TokenInfo;
+        zeroForOne: boolean;
+    }, tokenInAmount: bigint, tokenOutAmount: bigint): number;
+    buildSwapComputeResult(params: {
+        swapType: 'BaseIn' | 'BaseOut';
+        tokenInInfo: TokenInfo;
+        tokenOutInfo: TokenInfo;
+        tokenInAmount: bigint;
+        tokenOutAmount: bigint;
+        otherAmountThreshold: bigint;
+        slippage: number;
+        priceImpactPct: number;
+        tradingFee?: bigint;
+        routePlan: Array<bigint>;
+    }): Promise<SwapComputeResult>;
+}
+//# sourceMappingURL=computeService.d.ts.map