@eyettea/zeta-backend 0.0.1-rc.10

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

@@ -0,0 +1,124 @@
+import { Elysia } from 'elysia';
+import type { SwapComputeResult } from '../services/computeService';
+export interface SwapComputeError {
+    id: string;
+    success: false;
+    msg: string;
+    data: undefined;
+}
+export interface SwapComputeSuccess {
+    id: string;
+    success: true;
+    msg?: undefined;
+    data: SwapComputeResult;
+}
+export type SwapComputeResponse = SwapComputeSuccess | SwapComputeError;
+export declare const computeRouter: Elysia<"/compute", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    compute: {
+        "swap-base-in": {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    slippageBps?: string | undefined;
+                    poolType: "standard" | "concentrated";
+                    inputMint: string;
+                    outputMint: string;
+                    amount: string;
+                };
+                headers: unknown;
+                response: {
+                    400: {
+                        message: string;
+                        error: "Bad request";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    404: {
+                        message: string;
+                        error: "Resource not found";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    422: {
+                        message: string;
+                        error: "Validation error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    500: {
+                        message: string;
+                        error: "Internal server error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    200: SwapComputeResult;
+                };
+            };
+        };
+    };
+} & {
+    compute: {
+        "swap-base-out": {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    slippageBps?: string | undefined;
+                    poolType: "standard" | "concentrated";
+                    inputMint: string;
+                    outputMint: string;
+                    amount: string;
+                };
+                headers: unknown;
+                response: {
+                    400: {
+                        message: string;
+                        error: "Bad request";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    404: {
+                        message: string;
+                        error: "Resource not found";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    422: {
+                        message: string;
+                        error: "Validation error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    500: {
+                        message: string;
+                        error: "Internal server error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    200: SwapComputeResult;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+//# sourceMappingURL=compute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compute.d.ts","sourceRoot":"","sources":["../../../src/routes/compute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAK,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAMlE,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,KAAK,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,IAAI,CAAC;IACd,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,iBAAiB,CAAC;CACzB;AAED,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,GAAG,gBAAgB,CAAC;AAIxE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuFvB,CAAC"}

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

@@ -0,0 +1,74 @@
+import { Elysia } from 'elysia';
+import type { OHLVCResult } from '../services/poolStatsService';
+export declare const ohlcvRouter: Elysia<"/api/v1/ohlcv", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    api: {
+        v1: {
+            ohlcv: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        type?: "1m" | "5m" | "15m" | "1h" | "4h" | "1d" | "1w" | undefined;
+                        token0?: string | undefined;
+                        token1?: string | undefined;
+                        poolId?: string | undefined;
+                        time_from?: number | undefined;
+                        time_to?: number | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        400: {
+                            message: string;
+                            error: "Bad request";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        404: {
+                            message: string;
+                            error: "Resource not found";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        422: {
+                            message: string;
+                            error: "Validation error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        500: {
+                            message: string;
+                            error: "Internal server error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        200: OHLVCResult;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+//# sourceMappingURL=ohlcv.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ohlcv.d.ts","sourceRoot":"","sources":["../../../src/routes/ohlcv.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAK,MAAM,QAAQ,CAAC;AAInC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAI/D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGvB,CAAC"}

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

@@ -0,0 +1,413 @@
+import { Elysia } from 'elysia';
+import { PaginatedApiResponse } from './response';
+import type { LiquidityLineData } from '../services/poolStatsService';
+import type { TokenPrice } from '../services/priceService';
+import type { TokenInfo } from '@alephium/token-list';
+import type { PoolWithStats, ClmmLiquidityRow } from '../services/poolService';
+import type { ClmmPosition } from '../api/types';
+import type { PoolEvent } from '../database/types';
+export type ClmmLiquidityRowPayload = ClmmLiquidityRow;
+export interface ClmmLiquidityLinePayload {
+    count: number;
+    line: ClmmLiquidityRowPayload[];
+}
+export interface PoolListResponse {
+    count: number;
+    totalPools: number;
+    data: PoolWithStats[];
+}
+export interface PoolListFromIdsResponse {
+    count: number;
+    data: PoolWithStats[];
+    meta: {
+        requestedIds: string[];
+        foundIds: string[];
+        missingIds: string[];
+    };
+}
+export interface Events {
+    data: PoolEvent[];
+}
+export interface TokenListResponse {
+    count: number;
+    tokens: TokenInfo[];
+}
+export interface TokenPricesResponse {
+    count: number;
+    prices: TokenPrice[];
+}
+export declare const poolsRouter: Elysia<"/pools", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    pools: {
+        tokens: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: {
+                        message: string;
+                        error: "Bad request";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    404: {
+                        message: string;
+                        error: "Resource not found";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    422: {
+                        message: string;
+                        error: "Validation error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    500: {
+                        message: string;
+                        error: "Internal server error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    200: TokenListResponse;
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        line: {
+            position: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        id: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        400: {
+                            message: string;
+                            error: "Bad request";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        404: {
+                            message: string;
+                            error: "Resource not found";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        422: {
+                            message: string;
+                            error: "Validation error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        500: {
+                            message: string;
+                            error: "Internal server error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        200: ClmmLiquidityLinePayload;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        prices: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    symbols?: string | undefined;
+                    ids?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    400: {
+                        message: string;
+                        error: "Bad request";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    404: {
+                        message: string;
+                        error: "Resource not found";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    422: {
+                        message: string;
+                        error: "Validation error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    500: {
+                        message: string;
+                        error: "Internal server error";
+                        details?: Record<string, unknown> | undefined;
+                    };
+                    200: TokenPricesResponse;
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        info: {
+            mint: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        poolType?: "standard" | "concentrated" | "all" | undefined;
+                        page?: number | undefined;
+                        pageSize?: number | undefined;
+                        mint2?: string | undefined;
+                        mint1: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        400: {
+                            message: string;
+                            error: "Bad request";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        404: {
+                            message: string;
+                            error: "Resource not found";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        422: {
+                            message: string;
+                            error: "Validation error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        500: {
+                            message: string;
+                            error: "Internal server error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        200: PaginatedApiResponse<PoolListResponse>;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        info: {
+            ids: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        ids: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        400: {
+                            message: string;
+                            error: "Bad request";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        404: {
+                            message: string;
+                            error: "Resource not found";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        422: {
+                            message: string;
+                            error: "Validation error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        500: {
+                            message: string;
+                            error: "Internal server error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        200: PoolListFromIdsResponse;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        info: {
+            events: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        id: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        400: {
+                            message: string;
+                            error: "Bad request";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        404: {
+                            message: string;
+                            error: "Resource not found";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        422: {
+                            message: string;
+                            error: "Validation error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        500: {
+                            message: string;
+                            error: "Internal server error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        200: Events;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        info: {
+            "clmm-positions": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        address: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        400: {
+                            message: string;
+                            error: "Bad request";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        404: {
+                            message: string;
+                            error: "Resource not found";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        422: {
+                            message: string;
+                            error: "Validation error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        500: {
+                            message: string;
+                            error: "Internal server error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        200: ClmmPosition[];
+                    };
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        info: {
+            list: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        poolType?: "standard" | "concentrated" | "all" | undefined;
+                        page?: number | undefined;
+                        pageSize?: number | undefined;
+                        sortType?: "asc" | "desc" | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        400: {
+                            message: string;
+                            error: "Bad request";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        404: {
+                            message: string;
+                            error: "Resource not found";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        422: {
+                            message: string;
+                            error: "Validation error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        500: {
+                            message: string;
+                            error: "Internal server error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        200: PaginatedApiResponse<PoolListResponse>;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    pools: {
+        line: {
+            liquidity: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        startTime?: number | undefined;
+                        endTime?: number | undefined;
+                        id: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        400: {
+                            message: string;
+                            error: "Bad request";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        404: {
+                            message: string;
+                            error: "Resource not found";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        422: {
+                            message: string;
+                            error: "Validation error";
+                            details?: Record<string, unknown> | undefined;
+                        };
+                        500: {
+                            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,EAA+B,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAGV,aAAa,EACb,gBAAgB,EACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,CAAC;AAEvD,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,uBAAuB,EAAE,CAAC;CACjC;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,aAAa,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,aAAa,EAAE,CAAC;IACtB,IAAI,EAAE;QACJ,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,UAAU,EAAE,MAAM,EAAE,CAAC;KACtB,CAAC;CACH;AAED,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,SAAS,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4arB,CAAC"}

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

@@ -0,0 +1,73 @@
+export interface PaginatedApiResponse<T> extends Response {
+    data: T & {
+        meta: {
+            page: number;
+            pageSize: number;
+            totalPages: number;
+        };
+    };
+}
+export declare function handlePaginatedSuccess<T>(data: T, page: number, pageSize: number, totalPages: number): PaginatedApiResponse<T>;
+export declare function handleSuccess<T>(data: T): T;
+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">;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+        error: "Bad request";
+        details?: Record<string, unknown> | undefined;
+    }, {
+        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">;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+        error: "Resource not found";
+        details?: Record<string, unknown> | undefined;
+    }, {
+        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">;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+        error: "Validation error";
+        details?: Record<string, unknown> | undefined;
+    }, {
+        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">;
+    }, "strip", import("zod").ZodTypeAny, {
+        message: string;
+        error: "Internal server error";
+        details?: Record<string, unknown> | undefined;
+    }, {
+        message: string;
+        error: "Internal server error";
+        details?: Record<string, unknown> | undefined;
+    }>;
+};
+//# sourceMappingURL=response.d.ts.map