@evergonlabs/tmi-protocol-api 0.2.1 → 0.4.0

package/dist/src/staking/platforms/searchPlatforms/v0/searchPlatforms.d.ts

@@ -0,0 +1,76 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../../common/tag.js";
+export declare function createSearchPlatformsV0App<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    chainId: "11155111" | "31337";
+    txHash: `0x${string}`;
+    createdAt: string;
+    contractAddress: `0x${string}`;
+    adminAddress: `0x${string}`;
+    updatedAt: string;
+}[], 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+    out: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    chainId: "11155111" | "31337";
+    txHash: `0x${string}`;
+    createdAt: string;
+    contractAddress: `0x${string}`;
+    adminAddress: `0x${string}`;
+    updatedAt: string;
+}[], 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+    out: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    chainId: "11155111" | "31337";
+    txHash: `0x${string}`;
+    createdAt: string;
+    contractAddress: `0x${string}`;
+    adminAddress: `0x${string}`;
+    updatedAt: string;
+}[], 200, "json">>>];
+//# sourceMappingURL=searchPlatforms.d.ts.map

package/dist/src/staking/platforms/searchPlatforms/v0/searchPlatforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchPlatforms.d.ts","sourceRoot":"","sources":["../../../../../../src/staking/platforms/searchPlatforms/v0/searchPlatforms.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAGjD,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgDvF"}

package/dist/src/staking/platforms/searchPlatforms/v0/searchPlatforms.js

@@ -0,0 +1,42 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { and, eq } from "@ponder/client";
+import { indexerClient } from "../../../../common/indexer/index.js";
+import { indexerSchemas } from "../../../../common/indexer/schemas.js";
+import { PageSchema } from "../../../../common/models/page.js";
+import { AddressSchema, StakingChainId } from "../../../../common/index.js";
+import { z } from "../../../../common/zod.js";
+import { PlatformSchema, mapToPlatform } from "../../common/platform.js";
+export function createSearchPlatformsV0App(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Search Platforms",
+        description: "Retrieve a list of platforms with filtering and sorting",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Returns list of platforms by specified filter",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.array(PlatformSchema)),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        page: PageSchema,
+        filter: z.object({
+            chainId: StakingChainId.optional(),
+            owner: AddressSchema.optional(),
+        }),
+    })), async (c) => {
+        const { page, filter } = c.req.valid("json");
+        const result = await indexerClient.db
+            .select()
+            .from(indexerSchemas.diamonds)
+            .limit(page.limit)
+            .offset(page.skip)
+            .orderBy(indexerSchemas.diamonds.createdAt)
+            .where(and(filter.chainId ? eq(indexerSchemas.diamonds.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.diamonds.adminAddress, filter.owner) : undefined));
+        return c.json(result.map((x) => mapToPlatform(x)), 200);
+    });
+}

package/dist/src/staking/pools/common/pool.d.ts

@@ -0,0 +1,29 @@
+import { z } from "../../../common/zod.js";
+import { indexerSchemas } from "../../../common/indexer/schemas.js";
+export declare const PoolSchema: z.ZodObject<{
+    chainId: z.ZodType<"11155111" | "31337", z.ZodTypeDef, "11155111" | "31337">;
+    platform: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    rewardsHandler: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    assetHandler: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    txHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    poolId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    chainId: "11155111" | "31337";
+    platform: `0x${string}`;
+    poolId: bigint;
+    rewardsHandler: `0x${string}`;
+    txHash: `0x${string}`;
+    createdAt: string;
+    assetHandler: `0x${string}`;
+}, {
+    chainId: "11155111" | "31337";
+    platform: `0x${string}`;
+    poolId: string | number | bigint;
+    rewardsHandler: `0x${string}`;
+    txHash: `0x${string}`;
+    createdAt: string;
+    assetHandler: `0x${string}`;
+}>;
+export declare function mapToPool(raw: typeof indexerSchemas.pools.$inferSelect): z.output<typeof PoolSchema>;
+//# sourceMappingURL=pool.d.ts.map

package/dist/src/staking/pools/common/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../../../../src/staking/pools/common/pool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAS3C,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;EAYnB,CAAC;AAEL,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,cAAc,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAUpG"}

package/dist/src/staking/pools/common/pool.js

@@ -0,0 +1,28 @@
+import { unixToDate } from "@evergonlabs/tmi-protocol-utils/date";
+import { z } from "../../../common/zod.js";
+import { ISOSchema } from "../../../common/models/date.js";
+import { AddressSchema, HashSchema, PlatformContractAddress, PoolIdSchema, StakingChainId, } from "../../../common/index.js";
+export const PoolSchema = z
+    .object({
+    chainId: StakingChainId,
+    platform: PlatformContractAddress,
+    rewardsHandler: AddressSchema,
+    assetHandler: AddressSchema,
+    txHash: HashSchema,
+    poolId: PoolIdSchema,
+    createdAt: ISOSchema,
+})
+    .openapi({
+    ref: "Pool",
+});
+export function mapToPool(raw) {
+    return {
+        chainId: StakingChainId.parse(raw.chainId),
+        platform: raw.diamondAddress,
+        rewardsHandler: raw.rewardsHandler,
+        assetHandler: raw.assetsHandler,
+        txHash: raw.txHash,
+        poolId: raw.poolId,
+        createdAt: unixToDate(raw.createdAt).toISOString(),
+    };
+}

package/dist/src/staking/pools/common/poolNotFound.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from "@evergonlabs/tmi-utils/errors";
+import { Address } from "viem";
+export declare class PoolNotFoundError extends CustomError<{
+    chainId: string;
+    platform: Address;
+    poolId: string;
+}> {
+    constructor(chainId: string, poolId: string, platform: Address);
+}
+//# sourceMappingURL=poolNotFound.d.ts.map

package/dist/src/staking/pools/common/poolNotFound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poolNotFound.d.ts","sourceRoot":"","sources":["../../../../../src/staking/pools/common/poolNotFound.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,qBAAa,iBAAkB,SAAQ,WAAW,CAAC;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;gBACY,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO;CAW/D"}

package/dist/src/staking/pools/common/poolNotFound.js

@@ -0,0 +1,14 @@
+import { CustomError } from "@evergonlabs/tmi-utils/errors";
+export class PoolNotFoundError extends CustomError {
+    constructor(chainId, poolId, platform) {
+        super({
+            name: "PoolNotFoundError",
+            message: `Pool with id ${poolId} in ${platform} platform is not found (chainId ${chainId})`,
+            data: {
+                chainId: chainId,
+                platform: platform,
+                poolId: poolId,
+            },
+        });
+    }
+}

package/dist/src/staking/pools/getPool/index.d.ts

@@ -0,0 +1,20 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../common/tag.js";
+export declare function createGetPoolApp<E extends Env>(factory: Factory<E>, tag: ITag): import("hono/hono-base").HonoBase<E, {
+    "/v0": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    platform: string | string[];
+                    poolId: string | string[];
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/staking/pools/getPool/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/staking/pools/getPool/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE9C,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;QAE7E"}

package/dist/src/staking/pools/getPool/index.js

@@ -0,0 +1,4 @@
+import { createGetPoolV0App } from "./v0/getPool.js";
+export function createGetPoolApp(factory, tag) {
+    return factory.createApp().get("/v0", ...createGetPoolV0App(factory, tag));
+}

package/dist/src/staking/pools/getPool/v0/getPool.d.ts

@@ -0,0 +1,35 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { ITag } from "../../../../common/tag.js";
+export declare function createGetPoolV0App<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        query: {
+            chainId: string | string[];
+            platform: string | string[];
+            poolId: string | string[];
+        };
+    };
+    out: {
+        query: {
+            chainId: "11155111" | "31337";
+            platform: `0x${string}`;
+            poolId: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        query: {
+            chainId: string | string[];
+            platform: string | string[];
+            poolId: string | string[];
+        };
+    };
+    out: {
+        query: {
+            chainId: "11155111" | "31337";
+            platform: `0x${string}`;
+            poolId: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
+//# sourceMappingURL=getPool.d.ts.map

package/dist/src/staking/pools/getPool/v0/getPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPool.d.ts","sourceRoot":"","sources":["../../../../../../src/staking/pools/getPool/v0/getPool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAK3B,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAIjD,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAqE/E"}

package/dist/src/staking/pools/getPool/v0/getPool.js

@@ -0,0 +1,64 @@
+import { and, eq } from "@ponder/client";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { indexerClient } from "../../../../common/indexer/index.js";
+import { z } from "../../../../common/zod.js";
+import { indexerSchemas } from "../../../../common/indexer/schemas.js";
+import { ErrorSchema, PlatformContractAddress, PoolIdSchema, StakingChainId } from "../../../../common/index.js";
+import { mapToPool, PoolSchema } from "../../common/pool.js";
+import { PoolNotFoundError } from "../../common/poolNotFound.js";
+export function createGetPoolV0App(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get Pool",
+        description: "Retrieve details of a specified pool",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "List platforms",
+                content: {
+                    "application/json": {
+                        schema: resolver(PoolSchema),
+                    },
+                },
+            },
+            404: {
+                description: "No pool found",
+                content: {
+                    "application/json": {
+                        schema: resolver(ErrorSchema),
+                    },
+                },
+            },
+        },
+    }), validator("query", z.object({
+        chainId: StakingChainId.openapi({
+            param: {
+                name: "chainId",
+                in: "query",
+            },
+        }),
+        poolId: PoolIdSchema.openapi({
+            param: {
+                name: "poolId",
+                in: "query",
+            },
+        }),
+        platform: PlatformContractAddress.openapi({
+            param: {
+                name: "platform",
+                in: "query",
+            },
+        }),
+    })), async (c) => {
+        const { chainId, platform, poolId } = c.req.valid("query");
+        const [pool] = await indexerClient.db
+            .select()
+            .from(indexerSchemas.pools)
+            .limit(1)
+            .where(and(eq(indexerSchemas.pools.chainId, Number(chainId)), eq(indexerSchemas.pools.diamondAddress, platform), eq(indexerSchemas.pools.poolId, poolId)));
+        if (!pool) {
+            throw new PoolNotFoundError(chainId, poolId.toString(), platform);
+        }
+        return c.json(mapToPool(pool), 200);
+    });
+}

package/dist/src/staking/pools/index.d.ts

@@ -0,0 +1,39 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createPoolsApp<E extends Env>(factory: Factory<E>): import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/v0": {
+        $post: {
+            input: {
+                json: {
+                    filter: {
+                        chainId?: "11155111" | "31337" | undefined;
+                        platform?: `0x${string}` | undefined;
+                    };
+                    page: {
+                        skip: number;
+                        limit: number;
+                    };
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/searchPools"> | import("hono/types").MergeSchemaPath<{
+    "/v0": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    platform: string | string[];
+                    poolId: string | string[];
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/getPool">, "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/staking/pools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/staking/pools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,wBAAgB,cAAc,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAMhE"}

package/dist/src/staking/pools/index.js

@@ -0,0 +1,10 @@
+import { createTag } from "../../common/tag.js";
+import { createSearchPoolsApp } from "./searchPools/index.js";
+import { createGetPoolApp } from "./getPool/index.js";
+export function createPoolsApp(factory) {
+    const tag = createTag("Pools");
+    return factory
+        .createApp()
+        .route("/searchPools", createSearchPoolsApp(factory, tag))
+        .route("/getPool", createGetPoolApp(factory, tag));
+}

package/dist/src/staking/pools/searchPools/index.d.ts

@@ -0,0 +1,25 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../common/tag.js";
+export declare function createSearchPoolsApp<E extends Env>(factory: Factory<E>, tag: ITag): import("hono/hono-base").HonoBase<E, {
+    "/v0": {
+        $post: {
+            input: {
+                json: {
+                    filter: {
+                        chainId?: "11155111" | "31337" | undefined;
+                        platform?: `0x${string}` | undefined;
+                    };
+                    page: {
+                        skip: number;
+                        limit: number;
+                    };
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/staking/pools/searchPools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/staking/pools/searchPools/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE9C,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;QAEjF"}

package/dist/src/staking/pools/searchPools/index.js

@@ -0,0 +1,4 @@
+import { createSearchPoolsV0App } from "./v0/searchPools.js";
+export function createSearchPoolsApp(factory, tag) {
+    return factory.createApp().post("/v0", ...createSearchPoolsV0App(factory, tag));
+}

package/dist/src/staking/pools/searchPools/v0/searchPools.d.ts

@@ -0,0 +1,55 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../../../../common/tag.js";
+export declare function createSearchPoolsV0App<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+    out: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+    out: {
+        json: {
+            filter: {
+                chainId?: "11155111" | "31337" | undefined;
+                platform?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
+//# sourceMappingURL=searchPools.d.ts.map

package/dist/src/staking/pools/searchPools/v0/searchPools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchPools.d.ts","sourceRoot":"","sources":["../../../../../../src/staking/pools/searchPools/v0/searchPools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAGjD,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAgDnF"}

package/dist/src/staking/pools/searchPools/v0/searchPools.js

@@ -0,0 +1,42 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { and, eq } from "@ponder/client";
+import { indexerClient } from "../../../../common/indexer/index.js";
+import { indexerSchemas } from "../../../../common/indexer/schemas.js";
+import { PageSchema } from "../../../../common/models/page.js";
+import { PlatformContractAddress, StakingChainId } from "../../../../common/index.js";
+import { z } from "../../../../common/zod.js";
+import { mapToPool, PoolSchema } from "../../common/pool.js";
+export function createSearchPoolsV0App(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Search Pools",
+        description: "Retrieve a list of pools with filtering and sorting",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Returns list of pools by specified filter",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.array(PoolSchema)),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        page: PageSchema,
+        filter: z.object({
+            chainId: StakingChainId.optional(),
+            platform: PlatformContractAddress.optional(),
+        }),
+    })), async (c) => {
+        const { page, filter } = c.req.valid("json");
+        const result = await indexerClient.db
+            .select()
+            .from(indexerSchemas.pools)
+            .limit(page.limit)
+            .offset(page.skip)
+            .orderBy(indexerSchemas.pools.createdAt)
+            .where(and(filter.chainId ? eq(indexerSchemas.pools.chainId, Number(filter.chainId)) : undefined, filter.platform ? eq(indexerSchemas.pools.diamondAddress, filter.platform) : undefined));
+        return c.json(result.map((x) => mapToPool(x)), 200);
+    });
+}

package/dist/src/staking/roles/common/role.d.ts

@@ -0,0 +1,13 @@
+import { z } from "../../../common/zod.js";
+export declare const RoleIdSchema: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+export declare const RoleSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    value: `0x${string}`;
+    name: string;
+}, {
+    value: `0x${string}`;
+    name: string;
+}>;
+//# sourceMappingURL=role.d.ts.map

package/dist/src/staking/roles/common/role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role.d.ts","sourceRoot":"","sources":["../../../../../src/staking/roles/common/role.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAE3C,eAAO,MAAM,YAAY,uDAGvB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;EAUnB,CAAC"}

package/dist/src/staking/roles/common/role.js

@@ -0,0 +1,18 @@
+import { getStakingRole, StakingRole } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { HexStringSchema } from "../../../common/index.js";
+import { z } from "../../../common/zod.js";
+export const RoleIdSchema = HexStringSchema.openapi({
+    description: "Hexademical identifier of role",
+    example: getStakingRole(StakingRole.Staker),
+});
+export const RoleSchema = z
+    .object({
+    name: z.string().openapi({
+        description: "User-friendly display name of a role",
+        example: "Admin",
+    }),
+    value: RoleIdSchema,
+})
+    .openapi({
+    ref: "Role",
+});

package/dist/src/staking/roles/common/roleAssignment.d.ts

@@ -0,0 +1,27 @@
+import { z } from "../../../common/zod.js";
+export declare const RoleAssignmentSchema: z.ZodObject<{
+    chainId: z.ZodType<"11155111" | "31337", z.ZodTypeDef, "11155111" | "31337">;
+    platform: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    roleId: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    poolId: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>>;
+    owner: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    chainId: "11155111" | "31337";
+    platform: `0x${string}`;
+    createdAt: string;
+    updatedAt: string;
+    roleId: `0x${string}`;
+    owner: `0x${string}`;
+    poolId?: bigint | undefined;
+}, {
+    chainId: "11155111" | "31337";
+    platform: `0x${string}`;
+    createdAt: string;
+    updatedAt: string;
+    roleId: `0x${string}`;
+    owner: `0x${string}`;
+    poolId?: string | number | bigint | undefined;
+}>;
+//# sourceMappingURL=roleAssignment.d.ts.map

package/dist/src/staking/roles/common/roleAssignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roleAssignment.d.ts","sourceRoot":"","sources":["../../../../../src/staking/roles/common/roleAssignment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAI3C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EAgB7B,CAAC"}

package/dist/src/staking/roles/common/roleAssignment.js

@@ -0,0 +1,21 @@
+import { ISOSchema } from "../../../common/models/date.js";
+import { z } from "../../../common/zod.js";
+import { AddressSchema, PlatformContractAddress, PoolIdSchema, StakingChainId } from "../../../common/index.js";
+import { RoleIdSchema } from "./role.js";
+export const RoleAssignmentSchema = z
+    .object({
+    chainId: StakingChainId,
+    platform: PlatformContractAddress,
+    roleId: RoleIdSchema,
+    poolId: PoolIdSchema.optional().openapi({
+        description: "If empty or 0 then it's platform-wide",
+    }),
+    owner: AddressSchema.openapi({
+        description: "Address role assigned to",
+    }),
+    createdAt: ISOSchema,
+    updatedAt: ISOSchema,
+})
+    .openapi({
+    ref: "RoleAssignment",
+});