@evergonlabs/tmi-protocol-api 0.11.0-rc.3 → 0.11.0

package/dist/staking/platforms/{getPlatform/v0/getPlatform.js → getPlatform.js}

@@ -2,14 +2,31 @@ import { and, eq } from "@ponder/client";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { createController } from "../../../../common/controller.js";
-import { HttpError } from "../../../../common/http-error.js";
-import { ErrorSchema, PlatformContractAddress, StakingChainId } from "../../../../common/index.js";
-import { indexerSchemas } from "../../../../common/indexer/schemas.js";
-import { createTag } from "../../../../common/tag.js";
-import { mapToPlatform, PlatformSchema } from "../../../../staking/platforms/common/platform.js";
+import { createController } from "../../common/controller.js";
+import { HttpError } from "../../common/http-error.js";
+import { ErrorSchema, PlatformContractAddress, StakingChainId } from "../../common/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { createTag } from "../../common/tag.js";
+import { mapToPlatform, PlatformSchema } from "../../staking/platforms/common/platform.js";
 const tag = createTag("Markets");
-export const GetPlatformV0 = createController({
+export const GetPlatformQuery = z
+    .object({
+    chainId: StakingChainId.openapi({
+        param: {
+            name: "chainId",
+            in: "query",
+        },
+    }),
+    address: PlatformContractAddress.openapi({
+        param: {
+            name: "address",
+            in: "query",
+        },
+    }),
+})
+    .openapi("GetPlatformQuery");
+export const GetPlatformResponse = PlatformSchema;
+export const GetPlatform = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get platform",
         description: "Retrieve details of a specified platform",
@@ -19,7 +36,7 @@ export const GetPlatformV0 = createController({
                 description: "Platform details",
                 content: {
                     "application/json": {
-                        schema: resolver(PlatformSchema),
+                        schema: resolver(GetPlatformResponse),
                     },
                 },
             },
@@ -32,20 +49,7 @@ export const GetPlatformV0 = createController({
                 },
             },
         },
-    }), validator("query", z.object({
-        chainId: StakingChainId.openapi({
-            param: {
-                name: "chainId",
-                in: "query",
-            },
-        }),
-        address: PlatformContractAddress.openapi({
-            param: {
-                name: "address",
-                in: "query",
-            },
-        }),
-    })), async (c) => {
+    }), validator("query", GetPlatformQuery), async (c) => {
         const { chainId, address } = c.req.valid("query");
         const [platform] = await c
             .get("indexerClient")

package/dist/staking/platforms/index.d.ts

@@ -1,4 +1,4 @@
-export declare const PlatformsController: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+export declare const PlatformsController: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
     "/": {
         $get: {
             input: {
@@ -19,19 +19,15 @@ export declare const PlatformsController: import("../../common/controller.js").I
             status: 200;
         };
     };
-}, "/v0">, "/get"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/get"> | import("hono/types").MergeSchemaPath<{
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
-                    page: {
-                        skip: number;
-                        limit: number;
-                    };
-                    filter: {
-                        chainId?: "31337" | "11155111" | "84532" | undefined;
-                        owner?: string | undefined;
-                    };
+                query: {
+                    skip: string | string[];
+                    limit: string | string[];
+                    chainId?: string | string[] | undefined;
+                    owner?: string | string[] | undefined;
                 };
             };
             output: {
@@ -43,8 +39,8 @@ export declare const PlatformsController: import("../../common/controller.js").I
                 updatedAt: string & import("zod").$brand<"IsoDateString">;
             }[];
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/v0">, "/search">, "/", "/">>;
+}, "/search">, "/", "/">>;
 //# sourceMappingURL=index.d.ts.map

package/dist/staking/platforms/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/platforms/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAM9B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/platforms/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAG9B,CAAC"}

package/dist/staking/platforms/index.js

@@ -1,9 +1,6 @@
-import { GetPlatformController } from "./getPlatform/index.js";
-import { SearchPlatformsController } from "./searchPlatforms/index.js";
+import { GetPlatform } from "./getPlatform.js";
+import { SearchPlatforms } from "./searchPlatforms.js";
 import { createController } from "../../common/controller.js";
 export const PlatformsController = createController({
-    build: (factory) => factory
-        .createApp()
-        .route("/get", GetPlatformController.build(factory))
-        .route("/search", SearchPlatformsController.build(factory)),
+    build: (factory) => factory.createApp().route("/get", GetPlatform.build(factory)).route("/search", SearchPlatforms.build(factory)),
 });

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

@@ -0,0 +1,40 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const SearchPlatformsResponse: z.ZodArray<z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532">[]>;
+    transactionHash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    createdAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+    contractAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    adminAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    updatedAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+}, z.core.$strip>>;
+export declare const SearchPlatformsQuery: z.ZodObject<{
+    skip: z.ZodNumber;
+    limit: z.ZodNumber;
+    chainId: z.ZodOptional<z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532">[]>>;
+    owner: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+}, z.core.$strip>;
+export declare const SearchPlatforms: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    skip: string | string[];
+                    limit: string | string[];
+                    chainId?: string | string[] | undefined;
+                    owner?: string | string[] | undefined;
+                };
+            };
+            output: {
+                chainId: "31337" | "11155111" | "84532";
+                transactionHash: `0x${string}`;
+                createdAt: string & z.core.$brand<"IsoDateString">;
+                contractAddress: `0x${string}`;
+                adminAddress: `0x${string}`;
+                updatedAt: string & z.core.$brand<"IsoDateString">;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=searchPlatforms.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"searchPlatforms.d.ts","sourceRoot":"","sources":["../../../src/staking/platforms/searchPlatforms.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAWxD,eAAO,MAAM,uBAAuB;;;;;;;kBAA6D,CAAC;AAElG,eAAO,MAAM,oBAAoB;;;;;iBAOC,CAAC;AAEnC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;aA0C1B,CAAC"}

package/dist/staking/platforms/searchPlatforms.js

@@ -0,0 +1,50 @@
+import { and, eq } from "@ponder/client";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, StakingChainId } from "../../common/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { PageSchema } from "../../common/models/page.js";
+import { createTag } from "../../common/tag.js";
+import { mapToPlatform, PlatformSchema } from "../../staking/platforms/common/platform.js";
+const tag = createTag("Markets");
+export const SearchPlatformsResponse = z.array(PlatformSchema).openapi("SearchPlatformsResponse");
+export const SearchPlatformsQuery = z
+    .object({
+    skip: PageSchema.shape.skip.openapi({ param: { name: "skip", in: "query" } }),
+    limit: PageSchema.shape.limit.openapi({ param: { name: "limit", in: "query" } }),
+    chainId: StakingChainId.optional().openapi({ param: { name: "chainId", in: "query" } }),
+    owner: AddressSchema.optional().openapi({ param: { name: "owner", in: "query" } }),
+})
+    .openapi("SearchPlatformsQuery");
+export const SearchPlatforms = createController({
+    build: (factory) => factory.createApp().get("/", 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(SearchPlatformsResponse),
+                    },
+                },
+            },
+        },
+    }), validator("query", SearchPlatformsQuery), async (c) => {
+        const { skip, limit, chainId, owner } = c.req.valid("query");
+        const page = { skip, limit };
+        const filter = { chainId, owner };
+        const result = await c
+            .get("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)));
+    }),
+});

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

@@ -0,0 +1,40 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetPoolQuery: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532">[]>;
+    poolId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
+export declare const GetPoolResponse: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532">[]>;
+    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    rewardsHandler: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    assetHandler: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    txHash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    poolId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    createdAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+}, z.core.$strip>;
+export declare const GetPool: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: "31337" | "11155111" | "84532";
+                    poolId: string;
+                    platform: string;
+                };
+            };
+            output: {
+                chainId: "31337" | "11155111" | "84532";
+                platform: `0x${string}`;
+                rewardsHandler: `0x${string}`;
+                assetHandler: `0x${string}`;
+                txHash: `0x${string}`;
+                poolId: string & z.core.$brand<"Int256">;
+                createdAt: string & z.core.$brand<"IsoDateString">;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=getPool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getPool.d.ts","sourceRoot":"","sources":["../../../src/staking/pools/getPool.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAWxD,eAAO,MAAM,YAAY;;;;iBAqBC,CAAC;AAE3B,eAAO,MAAM,eAAe;;;;;;;;iBAAa,CAAC;AAE1C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;aA0DlB,CAAC"}

package/dist/staking/pools/{getPool/v0/getPool.js → getPool.js}

@@ -2,14 +2,37 @@ import { and, eq } from "@ponder/client";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { createController } from "../../../../common/controller.js";
-import { HttpError } from "../../../../common/http-error.js";
-import { ErrorSchema, PlatformContractAddress, PoolIdSchema, StakingChainId } from "../../../../common/index.js";
-import { indexerSchemas } from "../../../../common/indexer/schemas.js";
-import { createTag } from "../../../../common/tag.js";
-import { mapToPool, PoolSchema } from "../../../../staking/pools/common/pool.js";
+import { createController } from "../../common/controller.js";
+import { HttpError } from "../../common/http-error.js";
+import { ErrorSchema, PlatformContractAddress, PoolIdSchema, StakingChainId } from "../../common/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { createTag } from "../../common/tag.js";
+import { mapToPool, PoolSchema } from "../../staking/pools/common/pool.js";
 const tag = createTag("Pools");
-export const GetPoolV0 = createController({
+export const GetPoolQuery = 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",
+        },
+    }),
+})
+    .openapi("GetPoolQuery");
+export const GetPoolResponse = PoolSchema;
+export const GetPool = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get pool",
         description: "Retrieve details of a specified pool",
@@ -19,7 +42,7 @@ export const GetPoolV0 = createController({
                 description: "List platforms",
                 content: {
                     "application/json": {
-                        schema: resolver(PoolSchema),
+                        schema: resolver(GetPoolResponse),
                     },
                 },
             },
@@ -32,26 +55,7 @@ export const GetPoolV0 = createController({
                 },
             },
         },
-    }), 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) => {
+    }), validator("query", GetPoolQuery), async (c) => {
         const { chainId, platform, poolId } = c.req.valid("query");
         const [pool] = await c
             .get("indexerClient")

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

@@ -1,16 +1,12 @@
-export declare const PoolsController: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+export declare const PoolsController: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
-                    page: {
-                        skip: number;
-                        limit: number;
-                    };
-                    filter: {
-                        chainId?: "31337" | "11155111" | "84532" | undefined;
-                        platform?: string | undefined;
-                    };
+                query: {
+                    skip: string | string[];
+                    limit: string | string[];
+                    chainId?: string | string[] | undefined;
+                    platform?: string | string[] | undefined;
                 };
             };
             output: {
@@ -26,7 +22,7 @@ export declare const PoolsController: import("../../common/controller.js").ICont
             status: 200;
         };
     };
-}, "/v0">, "/searchPools"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/searchPools"> | import("hono/types").MergeSchemaPath<{
     "/": {
         $get: {
             input: {
@@ -49,5 +45,5 @@ export declare const PoolsController: import("../../common/controller.js").ICont
             status: 200;
         };
     };
-}, "/v0">, "/getPool">, "/", "/">>;
+}, "/getPool">, "/", "/">>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/pools/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAM1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/pools/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAG1B,CAAC"}

package/dist/staking/pools/index.js

@@ -1,9 +1,6 @@
-import { GetPoolController } from "./getPool/index.js";
-import { SearchPoolsController } from "./searchPools/index.js";
+import { GetPool } from "./getPool.js";
+import { SearchPools } from "./searchPools.js";
 import { createController } from "../../common/controller.js";
 export const PoolsController = createController({
-    build: (factory) => factory
-        .createApp()
-        .route("/searchPools", SearchPoolsController.build(factory))
-        .route("/getPool", GetPoolController.build(factory)),
+    build: (factory) => factory.createApp().route("/searchPools", SearchPools.build(factory)).route("/getPool", GetPool.build(factory)),
 });

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

@@ -0,0 +1,42 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const SearchPoolsResponse: z.ZodArray<z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532">[]>;
+    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    rewardsHandler: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    assetHandler: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    txHash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    poolId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    createdAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+}, z.core.$strip>>;
+export declare const SearchPoolsQuery: z.ZodObject<{
+    skip: z.ZodNumber;
+    limit: z.ZodNumber;
+    chainId: z.ZodOptional<z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532">[]>>;
+    platform: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+}, z.core.$strip>;
+export declare const SearchPools: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    skip: string | string[];
+                    limit: string | string[];
+                    chainId?: string | string[] | undefined;
+                    platform?: string | string[] | undefined;
+                };
+            };
+            output: {
+                chainId: "31337" | "11155111" | "84532";
+                platform: `0x${string}`;
+                rewardsHandler: `0x${string}`;
+                assetHandler: `0x${string}`;
+                txHash: `0x${string}`;
+                poolId: string & z.core.$brand<"Int256">;
+                createdAt: string & z.core.$brand<"IsoDateString">;
+            }[];
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=searchPools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"searchPools.d.ts","sourceRoot":"","sources":["../../../src/staking/pools/searchPools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAWxD,eAAO,MAAM,mBAAmB;;;;;;;;kBAAqD,CAAC;AAEtF,eAAO,MAAM,gBAAgB;;;;;iBAOC,CAAC;AAE/B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;aAyCtB,CAAC"}

package/dist/staking/pools/searchPools.js

@@ -0,0 +1,50 @@
+import { and, eq } from "@ponder/client";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { createController } from "../../common/controller.js";
+import { PlatformContractAddress, StakingChainId } from "../../common/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { PageSchema } from "../../common/models/page.js";
+import { createTag } from "../../common/tag.js";
+import { mapToPool, PoolSchema } from "../../staking/pools/common/pool.js";
+const tag = createTag("Pools");
+export const SearchPoolsResponse = z.array(PoolSchema).openapi("SearchPoolsResponse");
+export const SearchPoolsQuery = z
+    .object({
+    skip: PageSchema.shape.skip.openapi({ param: { name: "skip", in: "query" } }),
+    limit: PageSchema.shape.limit.openapi({ param: { name: "limit", in: "query" } }),
+    chainId: StakingChainId.optional().openapi({ param: { name: "chainId", in: "query" } }),
+    platform: PlatformContractAddress.optional().openapi({ param: { name: "platform", in: "query" } }),
+})
+    .openapi("SearchPoolsQuery");
+export const SearchPools = createController({
+    build: (factory) => factory.createApp().get("/", 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(SearchPoolsResponse),
+                    },
+                },
+            },
+        },
+    }), validator("query", SearchPoolsQuery), async (c) => {
+        const { skip, limit, chainId, platform } = c.req.valid("query");
+        const page = { skip, limit };
+        const filter = { chainId, platform };
+        const result = await c
+            .get("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/staking/roles/getRoles.d.ts

@@ -0,0 +1,28 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetRolesResponse: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>>;
+export declare const GetRoles: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
+    "/": {
+        $get: {
+            input: {};
+            output: ({
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            })[];
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=getRoles.d.ts.map

package/dist/staking/roles/getRoles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRoles.d.ts","sourceRoot":"","sources":["../../../src/staking/roles/getRoles.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,gBAAgB;;;kBAAkD,CAAC;AAEhF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;aAqBnB,CAAC"}

package/dist/staking/roles/{getRoles/v0/getRoles.js → getRoles.js}

@@ -2,11 +2,12 @@ import { describeRoute } from "hono-openapi";
 import { resolver } from "hono-openapi";
 import { getStakingRole, StakingRole } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { createController } from "../../../../common/controller.js";
-import { createTag } from "../../../../common/tag.js";
-import { RoleSchema } from "../../../../staking/roles/common/role.js";
+import { createController } from "../../common/controller.js";
+import { createTag } from "../../common/tag.js";
+import { RoleSchema } from "../../staking/roles/common/role.js";
 const tag = createTag("Roles");
-export const GetRolesV0 = createController({
+export const GetRolesResponse = z.array(RoleSchema).openapi("GetRolesResponse");
+export const GetRoles = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get roles",
         description: "Retrieve all available (pre-defined) roles",
@@ -16,7 +17,7 @@ export const GetRolesV0 = createController({
                 description: "List of available roles",
                 content: {
                     "application/json": {
-                        schema: resolver(z.array(RoleSchema)),
+                        schema: resolver(GetRolesResponse),
                     },
                 },
             },

package/dist/staking/roles/grantRole.d.ts

@@ -0,0 +1,33 @@
+import { StakingRole } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GrantRoleRequest: z.ZodObject<{
+    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+    role: z.ZodUnion<readonly [z.ZodEnum<typeof StakingRole>, z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>]>;
+}, z.core.$strip>;
+export declare const GrantRole: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    addresses: string[];
+                    role: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=grantRole.d.ts.map

package/dist/staking/roles/grantRole.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/staking/roles/grantRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,WAAW,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,gBAAgB;;;;iBAWC,CAAC;AAE/B,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;aA8BpB,CAAC"}