@evergonlabs/tmi-protocol-api 0.4.1 → 0.7.0

package/dist/staking/roles/searchRoles/v0/searchRoles.js

@@ -1,15 +1,18 @@
+import { and, eq } from "@ponder/client";
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
 import { unixToDate } from "@evergonlabs/tmi-protocol-utils/date";
-import { and, eq } from "@ponder/client";
-import { z } from "../../../../common/zod.js";
-import { indexerClient } from "../../../../common/indexer/index.js";
+import { createController } from "../../../../common/controller.js";
+import { AddressSchema, PlatformContractAddress, PoolIdSchema, StakingChainId } from "../../../../common/index.js";
 import { indexerSchemas } from "../../../../common/indexer/schemas.js";
+import { toISOJson } from "../../../../common/models/date.js";
 import { PageSchema } from "../../../../common/models/page.js";
-import { AddressSchema, PlatformContractAddress, PoolIdSchema, StakingChainId } from "../../../../common/index.js";
+import { createTag } from "../../../../common/tag.js";
 import { RoleAssignmentSchema } from "../../common/roleAssignment.js";
-export function createSearchRolesV0App(factory, tag) {
-    return factory.createHandlers(describeRoute({
+const tag = createTag("Roles");
+export const SearchRolesV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Search roles",
         description: "Search roles by users, platforms and pools",
         tags: [tag.tag],
@@ -33,16 +36,19 @@ export function createSearchRolesV0App(factory, tag) {
         }),
     })), async (c) => {
         const { page, filter } = c.req.valid("json");
-        const result = await indexerClient.db
-            .select()
+        const result = await c
+            .get("indexerClient")
+            .db.select()
             .from(indexerSchemas.roles)
             .limit(page.limit)
             .offset(page.skip)
             .orderBy(indexerSchemas.roles.createdAt)
-            .where(and(filter.chainId ? eq(indexerSchemas.roles.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.roles.walletAddress, filter.owner) : undefined, filter.platform ? eq(indexerSchemas.roles.diamondAddress, filter.platform) : undefined, typeof filter.poolId === "number" ? eq(indexerSchemas.roles.campaignId, BigInt(filter.poolId)) : undefined));
+            .where(and(filter.chainId ? eq(indexerSchemas.roles.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.roles.walletAddress, filter.owner) : undefined, filter.platform ? eq(indexerSchemas.roles.diamondAddress, filter.platform) : undefined, typeof filter.poolId === "number"
+            ? eq(indexerSchemas.roles.campaignId, BigInt(filter.poolId))
+            : undefined));
         return c.json(result.map((x) => toRoleAssignment(x)), 200);
-    });
-}
+    }),
+});
 function toRoleAssignment(raw) {
     return {
         chainId: StakingChainId.parse(raw.chainId),
@@ -50,7 +56,7 @@ function toRoleAssignment(raw) {
         owner: raw.walletAddress,
         roleId: raw.roleId,
         poolId: raw.campaignId ? PoolIdSchema.parse(raw.campaignId) : undefined,
-        createdAt: unixToDate(raw.createdAt).toISOString(),
-        updatedAt: unixToDate(raw.updatedAt).toISOString(),
+        createdAt: toISOJson(unixToDate(raw.createdAt)),
+        updatedAt: toISOJson(unixToDate(raw.updatedAt)),
     };
 }

package/dist/staking/stakes/common/stake.d.ts

@@ -1,44 +1,18 @@
+import { z } from "zod";
 import { indexerSchemas } from "../../../common/indexer/schemas.js";
-import { z } from "../../../common/zod.js";
 export declare const StakeSchema: z.ZodObject<{
-    chainId: z.ZodType<"11155111" | "31337", z.ZodTypeDef, "11155111" | "31337">;
-    platform: 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}`>;
-    stakeId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
-    activePackets: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
-    rewardsClaimed: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337>, z.ZodLiteral<11155111 | 31337>, ...z.ZodLiteral<11155111 | 31337>[]]>>;
+    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.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    owner: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    stakeId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    activePackets: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    rewardsClaimed: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     isActive: z.ZodBoolean;
-    unlockTimestamp: z.ZodString;
-    startTimestamp: z.ZodString;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    chainId: "11155111" | "31337";
-    platform: `0x${string}`;
-    createdAt: string;
-    updatedAt: string;
-    stakeId: bigint;
-    activePackets: bigint;
-    rewardsClaimed: bigint;
-    isActive: boolean;
-    unlockTimestamp: string;
-    startTimestamp: string;
-    owner: `0x${string}`;
-    poolId?: bigint | undefined;
-}, {
-    chainId: "11155111" | "31337";
-    platform: `0x${string}`;
-    createdAt: string;
-    updatedAt: string;
-    stakeId: string | number | bigint;
-    activePackets: string | number | bigint;
-    rewardsClaimed: string | number | bigint;
-    isActive: boolean;
-    unlockTimestamp: string;
-    startTimestamp: string;
-    owner: `0x${string}`;
-    poolId?: string | number | bigint | undefined;
-}>;
-export declare function mapToStake(raw: typeof indexerSchemas.stakes.$inferSelect): z.output<typeof StakeSchema>;
+    unlockTimestamp: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+    startTimestamp: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+    createdAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+    updatedAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+}, z.core.$strip>;
+export declare function mapToStake(raw: typeof indexerSchemas.stakes.$inferSelect): z.input<typeof StakeSchema>;
 //# sourceMappingURL=stake.d.ts.map

package/dist/staking/stakes/common/stake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stake.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/common/stake.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAE3C,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBpB,CAAC;AAEL,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,cAAc,CAAC,MAAM,CAAC,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,WAAW,CAAC,CAevG"}
+{"version":3,"file":"stake.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/common/stake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAGpE,eAAO,MAAM,WAAW;;;;;;;;;;;;;iBAqBL,CAAC;AAEpB,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,cAAc,CAAC,MAAM,CAAC,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAetG"}

package/dist/staking/stakes/common/stake.js

@@ -1,8 +1,8 @@
+import { z } from "zod";
 import { unixToDate } from "@evergonlabs/tmi-protocol-utils/date";
-import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { AddressSchema, PlatformContractAddress, PoolIdSchema, StakeIdSchema, StakingChainId, } from "../../../common/index.js";
-import { ISOSchema } from "../../../common/models/date.js";
-import { z } from "../../../common/zod.js";
+import { ISOJson, toISOJson } from "../../../common/models/date.js";
 export const StakeSchema = z
     .object({
     chainId: StakingChainId,
@@ -14,32 +14,30 @@ export const StakeSchema = z
         description: "Address role assigned to",
     }),
     stakeId: StakeIdSchema,
-    activePackets: Int256Positive,
-    rewardsClaimed: Int256Positive,
+    activePackets: Int256Json,
+    rewardsClaimed: Int256Json,
     isActive: z.boolean().openapi({
         description: "Whether stake is active or withdrawn and closed",
     }),
-    unlockTimestamp: ISOSchema,
-    startTimestamp: ISOSchema,
-    createdAt: ISOSchema,
-    updatedAt: ISOSchema,
+    unlockTimestamp: ISOJson,
+    startTimestamp: ISOJson,
+    createdAt: ISOJson,
+    updatedAt: ISOJson,
 })
-    .openapi({
-    ref: "Stake",
-});
+    .openapi("Stake");
 export function mapToStake(raw) {
     return {
         chainId: StakingChainId.parse(raw.chainId),
         platform: raw.diamondAddress,
         owner: raw.walletAddress,
-        poolId: raw.poolId ? PoolIdSchema.parse(raw.poolId) : undefined,
-        stakeId: raw.stakeId,
-        startTimestamp: unixToDate(raw.startTimestamp).toISOString(),
-        unlockTimestamp: unixToDate(raw.unlockTimestamp).toISOString(),
-        rewardsClaimed: raw.rewardsClaimed,
-        activePackets: raw.activePackets,
+        poolId: toInt256Json(raw.poolId),
+        stakeId: toInt256Json(raw.stakeId),
+        startTimestamp: toISOJson(unixToDate(raw.startTimestamp)),
+        unlockTimestamp: toISOJson(unixToDate(raw.unlockTimestamp)),
+        rewardsClaimed: toInt256Json(raw.rewardsClaimed),
+        activePackets: toInt256Json(raw.activePackets),
         isActive: raw.isActive,
-        createdAt: unixToDate(raw.createdAt).toISOString(),
-        updatedAt: unixToDate(raw.updatedAt).toISOString(),
+        createdAt: toISOJson(unixToDate(raw.createdAt)),
+        updatedAt: toISOJson(unixToDate(raw.updatedAt)),
     };
 }

package/dist/staking/stakes/common/stakeEvent.d.ts

@@ -1,30 +1,12 @@
-import { z } from "../../../common/zod.js";
+import { z } from "zod";
 export declare const StakeEventSchema: z.ZodObject<{
     id: z.ZodString;
-    chainId: z.ZodType<"11155111" | "31337", z.ZodTypeDef, "11155111" | "31337">;
-    platform: 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}`>;
-    stakeId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
-    createdAt: z.ZodString;
-    txHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    chainId: "11155111" | "31337";
-    platform: `0x${string}`;
-    id: string;
-    txHash: `0x${string}`;
-    createdAt: string;
-    stakeId: bigint;
-    owner: `0x${string}`;
-    poolId?: bigint | undefined;
-}, {
-    chainId: "11155111" | "31337";
-    platform: `0x${string}`;
-    id: string;
-    txHash: `0x${string}`;
-    createdAt: string;
-    stakeId: string | number | bigint;
-    owner: `0x${string}`;
-    poolId?: string | number | bigint | undefined;
-}>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337>, z.ZodLiteral<11155111 | 31337>, ...z.ZodLiteral<11155111 | 31337>[]]>>;
+    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.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    owner: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    stakeId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    createdAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+    txHash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
 //# sourceMappingURL=stakeEvent.d.ts.map

package/dist/staking/stakes/common/stakeEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stakeEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/common/stakeEvent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAY3C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBzB,CAAC"}
+{"version":3,"file":"stakeEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/common/stakeEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,eAAO,MAAM,gBAAgB;;;;;;;;;iBAiBL,CAAC"}

package/dist/staking/stakes/common/stakeEvent.js

@@ -1,6 +1,6 @@
-import { ISOSchema } from "../../../common/models/date.js";
-import { z } from "../../../common/zod.js";
+import { z } from "zod";
 import { AddressSchema, HashSchema, PlatformContractAddress, PoolIdSchema, StakeIdSchema, StakingChainId, } from "../../../common/index.js";
+import { ISOJson } from "../../../common/models/date.js";
 // @todo add data field
 export const StakeEventSchema = z
     .object({
@@ -16,9 +16,7 @@ export const StakeEventSchema = z
         description: "Address role assigned to",
     }),
     stakeId: StakeIdSchema,
-    createdAt: ISOSchema,
+    createdAt: ISOJson,
     txHash: HashSchema,
 })
-    .openapi({
-    ref: "StakeEvent",
-});
+    .openapi("StakeEvent");

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

@@ -1,8 +1,5 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { ITag } from "../../../common/tag.js";
-export declare function createGetStakesApp<E extends Env>(factory: Factory<E>, tag: ITag): import("hono/hono-base").HonoBase<E, {
-    "/v0": {
+export declare const GetStakeController: 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: {
                 query: {
@@ -16,5 +13,5 @@ export declare function createGetStakesApp<E extends Env>(factory: Factory<E>, t
             status: 200;
         };
     };
-}, "/">;
+}, "/v0">, "/">>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/getStake/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE9C,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;QAE/E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/getStake/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;gBAE7B,CAAC"}

package/dist/staking/stakes/getStake/index.js

@@ -1,4 +1,5 @@
-import { createGetStakeV0App } from "./v0/getStake.js";
-export function createGetStakesApp(factory, tag) {
-    return factory.createApp().get("/v0", ...createGetStakeV0App(factory, tag));
-}
+import { createController } from "../../../common/controller.js";
+import { GetStakeV0 } from "./v0/getStake.js";
+export const GetStakeController = createController({
+    build: (factory) => factory.createApp().route("/v0", GetStakeV0.build(factory)),
+});

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

@@ -1,35 +1,17 @@
-import { Factory } from "hono/factory";
-import { Env } from "hono";
-import { ITag } from "../../../../common/tag.js";
-export declare function createGetStakeV0App<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[];
-            stakeId: string | string[];
+export declare const GetStakeV0: import("../../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    platform: string | string[];
+                    stakeId: string | string[];
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
         };
     };
-    out: {
-        query: {
-            chainId: "11155111" | "31337";
-            platform: `0x${string}`;
-            stakeId: 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[];
-            stakeId: string | string[];
-        };
-    };
-    out: {
-        query: {
-            chainId: "11155111" | "31337";
-            platform: `0x${string}`;
-            stakeId: bigint;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
+}, "/">>;
 //# sourceMappingURL=getStake.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getStake.d.ts","sourceRoot":"","sources":["../../../../../src/staking/stakes/getStake/v0/getStake.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,mBAAmB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAqEhF"}
+{"version":3,"file":"getStake.d.ts","sourceRoot":"","sources":["../../../../../src/staking/stakes/getStake/v0/getStake.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;QA+ErB,CAAC"}

package/dist/staking/stakes/getStake/v0/getStake.js

@@ -1,14 +1,16 @@
 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 { resolver, validator } from "hono-openapi";
+import { z } from "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 "../../common/stake.js";
-import { StakeNotFoundError } from "../../common/stakeNotFound.js";
-export function createGetStakeV0App(factory, tag) {
-    return factory.createHandlers(describeRoute({
+const tag = createTag("Stakes");
+export const GetStakeV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get Stake",
         description: "Retrieve details of a specified stake",
         tags: [tag.tag],
@@ -51,14 +53,22 @@ export function createGetStakeV0App(factory, tag) {
         }),
     })), async (c) => {
         const { chainId, platform, stakeId } = c.req.valid("query");
-        const [stake] = await indexerClient.db
-            .select()
+        const [stake] = await c
+            .get("indexerClient")
+            .db.select()
             .from(indexerSchemas.stakes)
             .limit(1)
             .where(and(eq(indexerSchemas.stakes.chainId, Number(chainId)), eq(indexerSchemas.stakes.diamondAddress, platform), eq(indexerSchemas.stakes.stakeId, stakeId)));
         if (!stake) {
-            throw new StakeNotFoundError(chainId, platform, stakeId.toString());
+            throw new HttpError(400, {
+                name: "StakeNotFoundError",
+                message: `Stake with id ${stakeId} within ${platform} platform in ${chainId} network is not found`,
+                data: {
+                    chainId: chainId,
+                    contract: platform,
+                },
+            });
         }
         return c.json(mapToStake(stake), 200);
-    });
-}
+    }),
+});

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

@@ -1,20 +1,18 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare function createStakesApp<E extends Env>(factory: Factory<E>): import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
-    "/v0": {
+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<{
+    "/": {
         $post: {
             input: {
                 json: {
-                    filter: {
-                        chainId?: "11155111" | "31337" | undefined;
-                        platform?: `0x${string}` | undefined;
-                        poolId?: string | number | bigint | undefined;
-                        owner?: `0x${string}` | undefined;
-                    };
                     page: {
                         skip: number;
                         limit: number;
                     };
+                    filter: {
+                        chainId?: unknown;
+                        owner?: string | undefined;
+                        platform?: string | undefined;
+                        poolId?: string | undefined;
+                    };
                 };
             };
             output: never;
@@ -22,21 +20,21 @@ export declare function createStakesApp<E extends Env>(factory: Factory<E>): imp
             status: 200;
         };
     };
-}, "/searchStakes"> | import("hono/types").MergeSchemaPath<{
-    "/v0": {
+}, "/v0">, "/searchStakes"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
         $post: {
             input: {
                 json: {
-                    filter: {
-                        chainId?: "11155111" | "31337" | undefined;
-                        platform?: `0x${string}` | undefined;
-                        poolId?: string | number | bigint | undefined;
-                        owner?: `0x${string}` | undefined;
-                    };
                     page: {
                         skip: number;
                         limit: number;
                     };
+                    filter: {
+                        chainId?: unknown;
+                        owner?: string | undefined;
+                        platform?: string | undefined;
+                        poolId?: string | undefined;
+                    };
                 };
             };
             output: never;
@@ -44,8 +42,8 @@ export declare function createStakesApp<E extends Env>(factory: Factory<E>): imp
             status: 200;
         };
     };
-}, "/searchStakeEvents"> | import("hono/types").MergeSchemaPath<{
-    "/v0": {
+}, "/v0">, "/searchStakeEvents"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
         $get: {
             input: {
                 query: {
@@ -59,5 +57,5 @@ export declare function createStakesApp<E extends Env>(factory: Factory<E>): imp
             status: 200;
         };
     };
-}, "/getStake">, "/">;
+}, "/v0">, "/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":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAMvC,wBAAgB,eAAe,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAOjE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/staking/stakes/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAO3B,CAAC"}

package/dist/staking/stakes/index.js

@@ -1,12 +1,11 @@
-import { createSearchStakesApp } from "./searchStakes/index.js";
-import { createSearchStakeEventsApp } from "./searchStakeEvents/index.js";
-import { createGetStakesApp } from "./getStake/index.js";
-import { createTag } from "../../common/tag.js";
-export function createStakesApp(factory) {
-    const tag = createTag("Stakes");
-    return factory
+import { createController } from "../../common/controller.js";
+import { GetStakeController } from "./getStake/index.js";
+import { SearchStakeEventsController } from "./searchStakeEvents/index.js";
+import { SearchStakesController } from "./searchStakes/index.js";
+export const StakesController = createController({
+    build: (factory) => factory
         .createApp()
-        .route("/searchStakes", createSearchStakesApp(factory, tag))
-        .route("/searchStakeEvents", createSearchStakeEventsApp(factory, tag))
-        .route("/getStake", createGetStakesApp(factory, tag));
-}
+        .route("/searchStakes", SearchStakesController.build(factory))
+        .route("/searchStakeEvents", SearchStakeEventsController.build(factory))
+        .route("/getStake", GetStakeController.build(factory)),
+});

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

@@ -1,21 +1,18 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { ITag } from "../../../common/tag.js";
-export declare function createSearchStakeEventsApp<E extends Env>(factory: Factory<E>, tag: ITag): import("hono/hono-base").HonoBase<E, {
-    "/v0": {
+export declare const SearchStakeEventsController: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
         $post: {
             input: {
                 json: {
-                    filter: {
-                        chainId?: "11155111" | "31337" | undefined;
-                        platform?: `0x${string}` | undefined;
-                        poolId?: string | number | bigint | undefined;
-                        owner?: `0x${string}` | undefined;
-                    };
                     page: {
                         skip: number;
                         limit: number;
                     };
+                    filter: {
+                        chainId?: unknown;
+                        owner?: string | undefined;
+                        platform?: string | undefined;
+                        poolId?: string | undefined;
+                    };
                 };
             };
             output: never;
@@ -23,5 +20,5 @@ export declare function createSearchStakeEventsApp<E extends Env>(factory: Facto
             status: 200;
         };
     };
-}, "/">;
+}, "/v0">, "/">>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/searchStakeEvents/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAE3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE9C,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;QAEvF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/staking/stakes/searchStakeEvents/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;gBAEtC,CAAC"}

package/dist/staking/stakes/searchStakeEvents/index.js

@@ -1,4 +1,5 @@
-import { createSearchStakeEventsV0App } from "./v0/searchStakeEvents.js";
-export function createSearchStakeEventsApp(factory, tag) {
-    return factory.createApp().post("/v0", ...createSearchStakeEventsV0App(factory, tag));
-}
+import { createController } from "../../../common/controller.js";
+import { SearchStakeEventsV0 } from "./v0/searchStakeEvents.js";
+export const SearchStakeEventsController = createController({
+    build: (factory) => factory.createApp().route("/v0", SearchStakeEventsV0.build(factory)),
+});