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

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

@@ -2,12 +2,24 @@ import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { grantRole, StakingRole } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { createController } from "../../../../common/controller.js";
-import { AddressSchema, HexStringSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { PlatformContractAddress } from "../../../../common/models/platform.js";
-import { createTag } from "../../../../common/tag.js";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, HexStringSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { PlatformContractAddress } from "../../common/models/platform.js";
+import { createTag } from "../../common/tag.js";
 const tag = createTag("Roles");
-export const GrantRoleV0 = createController({
+export const GrantRoleRequest = z
+    .object({
+    platform: PlatformContractAddress,
+    addresses: z.array(AddressSchema).openapi({
+        description: "List of address you want assign role to",
+    }),
+    role: z.union([z.enum(StakingRole), HexStringSchema]).openapi({
+        description: "Id of a role assign to",
+        example: StakingRole.Staker,
+    }),
+})
+    .openapi("GrantRoleRequest");
+export const GrantRole = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Grant role",
         description: "Generates transaction for granting specified role to user addreses within the platform",
@@ -22,22 +34,13 @@ export const GrantRoleV0 = createController({
                 },
             },
         },
-    }), validator("json", z.object({
-        platform: PlatformContractAddress,
-        addresses: z.array(AddressSchema).openapi({
-            description: "List of address you want assign role to",
-        }),
-        role: z.union([z.nativeEnum(StakingRole), HexStringSchema]).openapi({
-            description: "Id of a role assign to",
-            example: StakingRole.Staker,
-        }),
-    })), async (c) => {
+    }), validator("json", GrantRoleRequest), async (c) => {
         const { platform, role, addresses } = c.req.valid("json");
         const deployed = grantRole({
             platform: platform,
             role: role,
             addresses: addresses,
         });
-        return c.json(toTransaction(deployed), 200);
+        return c.json(toTransaction(deployed));
     }),
 });

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

@@ -1,4 +1,4 @@
-export declare const RolesController: 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 RolesController: 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,7 +19,7 @@ export declare const RolesController: import("../../common/controller.js").ICont
             status: 200;
         };
     };
-}, "/v0">, "/getRoles"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/getRoles"> | import("hono/types").MergeSchemaPath<{
     "/": {
         $post: {
             input: {
@@ -40,24 +40,20 @@ export declare const RolesController: import("../../common/controller.js").ICont
                 };
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/v0">, "/grantRole"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/grantRole"> | import("hono/types").MergeSchemaPath<{
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
-                    page: {
-                        skip: number;
-                        limit: number;
-                    };
-                    filter: {
-                        chainId?: "31337" | "11155111" | "84532" | undefined;
-                        owner?: string | undefined;
-                        platform?: string | undefined;
-                        poolId?: string | undefined;
-                    };
+                query: {
+                    skip: string | string[];
+                    limit: string | string[];
+                    chainId?: string | string[] | undefined;
+                    owner?: string | string[] | undefined;
+                    platform?: string | string[] | undefined;
+                    poolId?: string | string[] | undefined;
                 };
             };
             output: {
@@ -73,21 +69,17 @@ export declare const RolesController: import("../../common/controller.js").ICont
             status: 200;
         };
     };
-}, "/v0">, "/searchRoles"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/searchRoles"> | import("hono/types").MergeSchemaPath<{
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
-                    page: {
-                        skip: number;
-                        limit: number;
-                    };
-                    filter: {
-                        chainId?: "31337" | "11155111" | "84532" | undefined;
-                        owner?: string | undefined;
-                        platform?: string | undefined;
-                        poolId?: string | undefined;
-                    };
+                query: {
+                    skip: string | string[];
+                    limit: string | string[];
+                    chainId?: string | string[] | undefined;
+                    owner?: string | string[] | undefined;
+                    platform?: string | string[] | undefined;
+                    poolId?: string | string[] | undefined;
                 };
             };
             output: {
@@ -101,8 +93,8 @@ export declare const RolesController: import("../../common/controller.js").ICont
                 poolId?: (string & import("zod").$brand<"Int256">) | undefined;
             }[];
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/v0">, "/searchRoleEvents">, "/", "/">>;
+}, "/searchRoleEvents">, "/", "/">>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/roles/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAQ1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/roles/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAQ1B,CAAC"}

package/dist/staking/roles/index.js

@@ -1,13 +1,13 @@
-import { GetRolesController } from "./getRoles/index.js";
-import { GrantRoleController } from "./grantRole/index.js";
-import { SearchRoleEventsController } from "./searchRoleEvents/index.js";
-import { SearchRolesController } from "./searchRoles/index.js";
+import { GetRoles } from "./getRoles.js";
+import { GrantRole } from "./grantRole.js";
+import { SearchRoleEvents } from "./searchRoleEvents.js";
+import { SearchRoles } from "./searchRoles.js";
 import { createController } from "../../common/controller.js";
 export const RolesController = createController({
     build: (factory) => factory
         .createApp()
-        .route("/getRoles", GetRolesController.build(factory))
-        .route("/grantRole", GrantRoleController.build(factory))
-        .route("/searchRoles", SearchRolesController.build(factory))
-        .route("/searchRoleEvents", SearchRoleEventsController.build(factory)),
+        .route("/getRoles", GetRoles.build(factory))
+        .route("/grantRole", GrantRole.build(factory))
+        .route("/searchRoles", SearchRoles.build(factory))
+        .route("/searchRoleEvents", SearchRoleEvents.build(factory)),
 });

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

@@ -0,0 +1,48 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const SearchRoleEventsResponse: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    roleId: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    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}`>>;
+    txHash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    owner: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    poolId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Int256", "out">>;
+    isRevoked: z.ZodBoolean;
+}, z.core.$strip>>;
+export declare const SearchRoleEventsQuery: 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}`>>>;
+    platform: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+    poolId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Int256", "out">>;
+}, z.core.$strip>;
+export declare const SearchRoleEvents: 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;
+                    platform?: string | string[] | undefined;
+                    poolId?: string | string[] | undefined;
+                };
+            };
+            output: {
+                id: string;
+                roleId: `0x${string}`;
+                chainId: "31337" | "11155111" | "84532";
+                platform: `0x${string}`;
+                txHash: `0x${string}`;
+                owner: `0x${string}`;
+                isRevoked: boolean;
+                poolId?: (string & z.core.$brand<"Int256">) | undefined;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=searchRoleEvents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"searchRoleEvents.d.ts","sourceRoot":"","sources":["../../../src/staking/roles/searchRoleEvents.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAWxD,eAAO,MAAM,wBAAwB;;;;;;;;;kBAA+D,CAAC;AAErG,eAAO,MAAM,qBAAqB;;;;;;;iBASC,CAAC;AAEpC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8C3B,CAAC"}

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

@@ -2,15 +2,26 @@ 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, PlatformContractAddress, PoolIdSchema, 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 { RoleAssignmentSchema } from "../../../../staking/roles/common/roleAssignment.js";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, PlatformContractAddress, PoolIdSchema, 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 { RoleEventSchema } from "../../staking/roles/common/roleEvent.js";
 const tag = createTag("Roles");
-export const SearchRoleEventsV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+export const SearchRoleEventsResponse = z.array(RoleEventSchema).openapi("SearchRoleEventsResponse");
+export const SearchRoleEventsQuery = 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" } }),
+    platform: PlatformContractAddress.optional().openapi({ param: { name: "platform", in: "query" } }),
+    poolId: PoolIdSchema.optional().openapi({ param: { name: "poolId", in: "query" } }),
+})
+    .openapi("SearchRoleEventsQuery");
+export const SearchRoleEvents = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Search role events",
         description: "Search role events by platform, user and kind",
         tags: [tag.tag],
@@ -19,21 +30,15 @@ export const SearchRoleEventsV0 = createController({
                 description: "Returns list of role events by some filter",
                 content: {
                     "application/json": {
-                        schema: resolver(z.array(RoleAssignmentSchema)),
+                        schema: resolver(SearchRoleEventsResponse),
                     },
                 },
             },
         },
-    }), validator("json", z.object({
-        page: PageSchema,
-        filter: z.object({
-            chainId: StakingChainId.optional(),
-            owner: AddressSchema.optional(),
-            platform: PlatformContractAddress.optional(),
-            poolId: PoolIdSchema.optional(),
-        }),
-    })), async (c) => {
-        const { page, filter } = c.req.valid("json");
+    }), validator("query", SearchRoleEventsQuery), async (c) => {
+        const { skip, limit, chainId, owner, platform, poolId } = c.req.valid("query");
+        const page = { skip, limit };
+        const filter = { chainId, owner, platform, poolId };
         const result = await c
             .get("indexerClient")
             .db.select()
@@ -44,7 +49,7 @@ export const SearchRoleEventsV0 = createController({
             .where(and(filter.chainId ? eq(indexerSchemas.roleEvents.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.roleEvents.walletAddress, filter.owner) : undefined, filter.platform ? eq(indexerSchemas.roleEvents.diamondAddress, filter.platform) : undefined, typeof filter.poolId === "number"
             ? eq(indexerSchemas.roleEvents.campaignId, BigInt(filter.poolId))
             : undefined));
-        return c.json(result.map((x) => toRoleEvent(x)), 200);
+        return c.json(result.map((x) => toRoleEvent(x)));
     }),
 });
 function toRoleEvent(raw) {

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

@@ -0,0 +1,46 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const SearchRolesResponse: 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}`>>;
+    roleId: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    poolId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Int256", "out">>;
+    owner: 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">;
+    updatedAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+}, z.core.$strip>>;
+export declare const SearchRolesQuery: 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}`>>>;
+    platform: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+    poolId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Int256", "out">>;
+}, z.core.$strip>;
+export declare const SearchRoles: 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;
+                    platform?: string | string[] | undefined;
+                    poolId?: string | string[] | undefined;
+                };
+            };
+            output: {
+                chainId: "31337" | "11155111" | "84532";
+                platform: `0x${string}`;
+                roleId: `0x${string}`;
+                owner: `0x${string}`;
+                createdAt: string & z.core.$brand<"IsoDateString">;
+                updatedAt: string & z.core.$brand<"IsoDateString">;
+                poolId?: (string & z.core.$brand<"Int256">) | undefined;
+            }[];
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=searchRoles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"searchRoles.d.ts","sourceRoot":"","sources":["../../../src/staking/roles/searchRoles.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAYxD,eAAO,MAAM,mBAAmB;;;;;;;;kBAA+D,CAAC;AAEhG,eAAO,MAAM,gBAAgB;;;;;;;iBASC,CAAC;AAE/B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;aA6CtB,CAAC"}

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

@@ -4,15 +4,26 @@ import { resolver, validator } from "hono-openapi";
 import { unixToDate } from "@evergonlabs/tmi-protocol-utils/date";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { toISOJson } from "@evergonlabs/tmi-protocol-utils/zod";
-import { createController } from "../../../../common/controller.js";
-import { AddressSchema, PlatformContractAddress, PoolIdSchema, 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 { RoleAssignmentSchema } from "../../../../staking/roles/common/roleAssignment.js";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, PlatformContractAddress, PoolIdSchema, 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 { RoleAssignmentSchema } from "../../staking/roles/common/roleAssignment.js";
 const tag = createTag("Roles");
-export const SearchRolesV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+export const SearchRolesResponse = z.array(RoleAssignmentSchema).openapi("SearchRolesResponse");
+export const SearchRolesQuery = 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" } }),
+    platform: PlatformContractAddress.optional().openapi({ param: { name: "platform", in: "query" } }),
+    poolId: PoolIdSchema.optional().openapi({ param: { name: "poolId", in: "query" } }),
+})
+    .openapi("SearchRolesQuery");
+export const SearchRoles = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Search roles",
         description: "Search roles by users, platforms and pools",
         tags: [tag.tag],
@@ -21,21 +32,15 @@ export const SearchRolesV0 = createController({
                 description: "Returns list of assignments within specified platforms and pools",
                 content: {
                     "application/json": {
-                        schema: resolver(z.array(RoleAssignmentSchema)),
+                        schema: resolver(SearchRolesResponse),
                     },
                 },
             },
         },
-    }), validator("json", z.object({
-        page: PageSchema,
-        filter: z.object({
-            chainId: StakingChainId.optional(),
-            owner: AddressSchema.optional(),
-            platform: PlatformContractAddress.optional(),
-            poolId: PoolIdSchema.optional(),
-        }),
-    })), async (c) => {
-        const { page, filter } = c.req.valid("json");
+    }), validator("query", SearchRolesQuery), async (c) => {
+        const { skip, limit, chainId, owner, platform, poolId } = c.req.valid("query");
+        const page = { skip, limit };
+        const filter = { chainId, owner, platform, poolId };
         const result = await c
             .get("indexerClient")
             .db.select()

package/dist/staking/stakes/getStake.d.ts

@@ -0,0 +1,50 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetStakeQuery: 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}`>>;
+    stakeId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
+export declare const GetStakeResponse: 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}`>>;
+    poolId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Int256", "out">>;
+    owner: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    stakeId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    activePackets: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    rewardsClaimed: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    isActive: z.ZodBoolean;
+    unlockTimestamp: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+    startTimestamp: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+    createdAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+    updatedAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+}, z.core.$strip>;
+export declare const GetStake: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: "31337" | "11155111" | "84532";
+                    platform: string;
+                    stakeId: string;
+                };
+            };
+            output: {
+                chainId: "31337" | "11155111" | "84532";
+                platform: string;
+                owner: string;
+                stakeId: string;
+                activePackets: string;
+                rewardsClaimed: string;
+                isActive: boolean;
+                unlockTimestamp: string;
+                startTimestamp: string;
+                createdAt: string;
+                updatedAt: string;
+                poolId?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=getStake.d.ts.map

package/dist/staking/stakes/getStake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStake.d.ts","sourceRoot":"","sources":["../../../src/staking/stakes/getStake.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAWxD,eAAO,MAAM,aAAa;;;;iBAqBC,CAAC;AAE5B,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;iBAAc,CAAC;AAE5C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAyDnB,CAAC"}

package/dist/staking/stakes/{getStake/v0/getStake.js → getStake.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, StakeIdSchema, StakingChainId } from "../../../../common/index.js";
-import { indexerSchemas } from "../../../../common/indexer/schemas.js";
-import { createTag } from "../../../../common/tag.js";
-import { mapToStake, StakeSchema } from "../../../../staking/stakes/common/stake.js";
+import { createController } from "../../common/controller.js";
+import { HttpError } from "../../common/http-error.js";
+import { ErrorSchema, PlatformContractAddress, StakeIdSchema, StakingChainId } from "../../common/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { createTag } from "../../common/tag.js";
+import { mapToStake, StakeSchema } from "../../staking/stakes/common/stake.js";
 const tag = createTag("Stakes");
-export const GetStakeV0 = createController({
+export const GetStakeQuery = z
+    .object({
+    chainId: StakingChainId.openapi({
+        param: {
+            name: "chainId",
+            in: "query",
+        },
+    }),
+    platform: PlatformContractAddress.openapi({
+        param: {
+            name: "platform",
+            in: "query",
+        },
+    }),
+    stakeId: StakeIdSchema.openapi({
+        param: {
+            name: "stakeId",
+            in: "query",
+        },
+    }),
+})
+    .openapi("GetStakeQuery");
+export const GetStakeResponse = StakeSchema;
+export const GetStake = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get stake",
         description: "Retrieve details of a specified stake",
@@ -19,7 +42,7 @@ export const GetStakeV0 = createController({
                 description: "Stake details",
                 content: {
                     "application/json": {
-                        schema: resolver(StakeSchema),
+                        schema: resolver(GetStakeResponse),
                     },
                 },
             },
@@ -32,26 +55,7 @@ export const GetStakeV0 = createController({
                 },
             },
         },
-    }), validator("query", z.object({
-        chainId: StakingChainId.openapi({
-            param: {
-                name: "chainId",
-                in: "query",
-            },
-        }),
-        platform: PlatformContractAddress.openapi({
-            param: {
-                name: "platform",
-                in: "query",
-            },
-        }),
-        stakeId: StakeIdSchema.openapi({
-            param: {
-                name: "stakeId",
-                in: "query",
-            },
-        }),
-    })), async (c) => {
+    }), validator("query", GetStakeQuery), async (c) => {
         const { chainId, platform, stakeId } = c.req.valid("query");
         const [stake] = await c
             .get("indexerClient")

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

@@ -1,18 +1,14 @@
-export declare const StakesController: 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 StakesController: 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;
-                        owner?: string | undefined;
-                        platform?: string | undefined;
-                        poolId?: string | undefined;
-                    };
+                query: {
+                    skip: string | string[];
+                    limit: string | string[];
+                    chainId?: string | string[] | undefined;
+                    owner?: string | string[] | undefined;
+                    platform?: string | string[] | undefined;
+                    poolId?: string | string[] | undefined;
                 };
             };
             output: {
@@ -33,21 +29,17 @@ export declare const StakesController: import("../../common/controller.js").ICon
             status: 200;
         };
     };
-}, "/v0">, "/searchStakes"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/searchStakes"> | import("hono/types").MergeSchemaPath<{
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
-                    page: {
-                        skip: number;
-                        limit: number;
-                    };
-                    filter: {
-                        chainId?: "31337" | "11155111" | "84532" | undefined;
-                        owner?: string | undefined;
-                        platform?: string | undefined;
-                        poolId?: string | undefined;
-                    };
+                query: {
+                    skip: string | string[];
+                    limit: string | string[];
+                    chainId?: string | string[] | undefined;
+                    owner?: string | string[] | undefined;
+                    platform?: string | string[] | undefined;
+                    poolId?: string | string[] | undefined;
                 };
             };
             output: {
@@ -61,10 +53,10 @@ export declare const StakesController: import("../../common/controller.js").ICon
                 poolId?: (string & import("zod").$brand<"Int256">) | undefined;
             }[];
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/v0">, "/searchStakeEvents"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/searchStakeEvents"> | import("hono/types").MergeSchemaPath<{
     "/": {
         $get: {
             input: {
@@ -92,5 +84,5 @@ export declare const StakesController: import("../../common/controller.js").ICon
             status: 200;
         };
     };
-}, "/v0">, "/getStake">, "/", "/">>;
+}, "/getStake">, "/", "/">>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/stakes/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAO3B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/stakes/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAO3B,CAAC"}