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

package/dist/staking/stakes/index.js

@@ -1,11 +1,11 @@
-import { GetStakeController } from "./getStake/index.js";
-import { SearchStakeEventsController } from "./searchStakeEvents/index.js";
-import { SearchStakesController } from "./searchStakes/index.js";
+import { GetStake } from "./getStake.js";
+import { SearchStakeEvents } from "./searchStakeEvents.js";
+import { SearchStakes } from "./searchStakes.js";
 import { createController } from "../../common/controller.js";
 export const StakesController = createController({
     build: (factory) => factory
         .createApp()
-        .route("/searchStakes", SearchStakesController.build(factory))
-        .route("/searchStakeEvents", SearchStakeEventsController.build(factory))
-        .route("/getStake", GetStakeController.build(factory)),
+        .route("/searchStakes", SearchStakes.build(factory))
+        .route("/searchStakeEvents", SearchStakeEvents.build(factory))
+        .route("/getStake", GetStake.build(factory)),
 });

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

@@ -0,0 +1,48 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const SearchStakeEventsResponse: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    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">;
+    createdAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "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>>;
+export declare const SearchStakeEventsQuery: 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 SearchStakeEvents: 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;
+                chainId: "31337" | "11155111" | "84532";
+                platform: `0x${string}`;
+                owner: `0x${string}`;
+                stakeId: string & z.core.$brand<"Int256">;
+                createdAt: string & z.core.$brand<"IsoDateString">;
+                txHash: `0x${string}`;
+                poolId?: (string & z.core.$brand<"Int256">) | undefined;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=searchStakeEvents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"searchStakeEvents.d.ts","sourceRoot":"","sources":["../../../src/staking/stakes/searchStakeEvents.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAaxD,eAAO,MAAM,yBAAyB;;;;;;;;;kBAAiE,CAAC;AAExG,eAAO,MAAM,sBAAsB;;;;;;;iBASC,CAAC;AAErC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8C5B,CAAC"}

package/dist/staking/stakes/{searchStakeEvents/v0/searchStakeEvents.js → searchStakeEvents.js}

@@ -5,15 +5,26 @@ 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 { toInt256Json } from "@evergonlabs/tmi-utils/models";
-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 { StakeEventSchema } from "../../../../staking/stakes/common/stakeEvent.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 { StakeEventSchema } from "../../staking/stakes/common/stakeEvent.js";
 const tag = createTag("Stakes");
-export const SearchStakeEventsV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+export const SearchStakeEventsResponse = z.array(StakeEventSchema).openapi("SearchStakeEventsResponse");
+export const SearchStakeEventsQuery = 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("SearchStakeEventsQuery");
+export const SearchStakeEvents = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Search stake events",
         description: "Search stake events by users, platforms and pools",
         tags: [tag.tag],
@@ -22,21 +33,15 @@ export const SearchStakeEventsV0 = createController({
                 description: "Returns list of stakes events within specified platforms and pools",
                 content: {
                     "application/json": {
-                        schema: resolver(z.array(StakeEventSchema)),
+                        schema: resolver(SearchStakeEventsResponse),
                     },
                 },
             },
         },
-    }), 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", SearchStakeEventsQuery), 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()
@@ -47,7 +52,7 @@ export const SearchStakeEventsV0 = createController({
             .where(and(filter.chainId ? eq(indexerSchemas.stakeEvents.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.stakeEvents.walletAddress, filter.owner) : undefined, filter.platform ? eq(indexerSchemas.stakeEvents.diamondAddress, filter.platform) : undefined, typeof filter.poolId === "number"
             ? eq(indexerSchemas.stakeEvents.poolId, BigInt(filter.poolId))
             : undefined));
-        return c.json(result.map((x) => toStakeEvent(x)), 200);
+        return c.json(result.map((x) => toStakeEvent(x)));
     }),
 });
 function toStakeEvent(raw) {

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

@@ -0,0 +1,56 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const SearchStakesResponse: 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}`>>;
+    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 SearchStakesQuery: 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 SearchStakes: 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: 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=searchStakes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"searchStakes.d.ts","sourceRoot":"","sources":["../../../src/staking/stakes/searchStakes.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAWxD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;kBAAuD,CAAC;AAEzF,eAAO,MAAM,iBAAiB;;;;;;;iBASC,CAAC;AAEhC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA2CvB,CAAC"}

package/dist/staking/stakes/searchStakes.js

@@ -0,0 +1,52 @@
+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 { mapToStake, StakeSchema } from "../../staking/stakes/common/stake.js";
+const tag = createTag("Stakes");
+export const SearchStakesResponse = z.array(StakeSchema).openapi("SearchStakesResponse");
+export const SearchStakesQuery = 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("SearchStakesQuery");
+export const SearchStakes = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Search stakes",
+        description: "Search stakes by users, platforms and pools",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Returns list of stakes within specified platforms and pools",
+                content: {
+                    "application/json": {
+                        schema: resolver(SearchStakesResponse),
+                    },
+                },
+            },
+        },
+    }), validator("query", SearchStakesQuery), 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()
+            .from(indexerSchemas.stakes)
+            .limit(page.limit)
+            .offset(page.skip)
+            .orderBy(indexerSchemas.stakes.createdAt)
+            .where(and(filter.chainId ? eq(indexerSchemas.stakes.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.stakes.walletAddress, filter.owner) : undefined, filter.platform ? eq(indexerSchemas.stakes.diamondAddress, filter.platform) : undefined, typeof filter.poolId === "number" ? eq(indexerSchemas.stakes.poolId, BigInt(filter.poolId)) : undefined));
+        return c.json(result.map((x) => mapToStake(x)), 200);
+    }),
+});

package/dist/stakingTemplates/index.d.ts

@@ -1,4 +1,4 @@
-export declare const StakingTemplatesApi: import("../common/controller.js").IApi<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<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+export declare const StakingTemplatesApi: import("../common/controller.js").IApi<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<{
     "/": {
         $get: {
             input: {
@@ -12,7 +12,7 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
                 admin: `0x${string}`;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
 }, "/getPlatformDeployEvent"> | import("hono/types").MergeSchemaPath<{
@@ -25,13 +25,13 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
                 };
             };
             output: {
-                poolId: never;
-                stakeId: never;
+                poolId: string;
+                stakeId: string;
                 operator: `0x${string}`;
                 owner: `0x${string}`;
-                inputPacketsStaked: never;
-                stakeStartActiveTimestamp: never;
-                unlockTimestamp: never;
+                inputPacketsStaked: string;
+                stakeStartActiveTimestamp: string;
+                unlockTimestamp: string;
             };
             outputFormat: "json";
             status: 200;
@@ -47,9 +47,9 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
                 };
             };
             output: {
-                poolId: never;
-                inputAssetKeeper: `0x${string}`;
+                poolId: string & import("zod").$brand<"Int256">;
                 rewardAssetHandler: `0x${string}`;
+                inputAssetKeeper: `0x${string}`;
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;
@@ -239,7 +239,7 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
             status: 200;
         };
     };
-}, "/createPlatform">, "/v0">, "/reputation"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/createPlatform">, "/reputation"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
     "/": {
         $get: {
             input: {
@@ -253,7 +253,7 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
                 admin: `0x${string}`;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
 }, "/getPlatformDeployEvent"> | import("hono/types").MergeSchemaPath<{
@@ -266,13 +266,13 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
                 };
             };
             output: {
-                poolId: never;
-                stakeId: never;
+                poolId: string;
+                stakeId: string;
                 operator: `0x${string}`;
                 owner: `0x${string}`;
-                inputPacketsStaked: never;
-                stakeStartActiveTimestamp: never;
-                unlockTimestamp: never;
+                inputPacketsStaked: string;
+                stakeStartActiveTimestamp: string;
+                unlockTimestamp: string;
             };
             outputFormat: "json";
             status: 200;
@@ -288,9 +288,9 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
                 };
             };
             output: {
-                poolId: never;
-                inputAssetKeeper: `0x${string}`;
+                poolId: string & import("zod").$brand<"Int256">;
                 rewardAssetHandler: `0x${string}`;
+                inputAssetKeeper: `0x${string}`;
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;
@@ -491,7 +491,7 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
             status: 200;
         };
     };
-}, "/createPlatform">, "/v0">, "/reputationLock"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/createPlatform">, "/reputationLock"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
     "/": {
         $get: {
             input: {
@@ -505,7 +505,7 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
                 admin: `0x${string}`;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
 }, "/getPlatformDeployEvent"> | import("hono/types").MergeSchemaPath<{
@@ -518,13 +518,13 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
                 };
             };
             output: {
-                poolId: never;
-                stakeId: never;
+                poolId: string;
+                stakeId: string;
                 operator: `0x${string}`;
                 owner: `0x${string}`;
-                inputPacketsStaked: never;
-                stakeStartActiveTimestamp: never;
-                unlockTimestamp: never;
+                inputPacketsStaked: string;
+                stakeStartActiveTimestamp: string;
+                unlockTimestamp: string;
             };
             outputFormat: "json";
             status: 200;
@@ -540,9 +540,9 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
                 };
             };
             output: {
-                poolId: never;
-                inputAssetKeeper: `0x${string}`;
+                poolId: string & import("zod").$brand<"Int256">;
                 rewardAssetHandler: `0x${string}`;
+                inputAssetKeeper: `0x${string}`;
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;
@@ -755,5 +755,5 @@ export declare const StakingTemplatesApi: import("../common/controller.js").IApi
             status: 200;
         };
     };
-}, "/distributeRewards">, "/v0">, "/rwa">, "/", "/">>;
+}, "/distributeRewards">, "/rwa">, "/", "/">>;
 //# sourceMappingURL=index.d.ts.map

package/dist/stakingTemplates/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/stakingTemplates/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAS9B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/stakingTemplates/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAS9B,CAAC"}

package/dist/stakingTemplates/index.js

@@ -1,13 +1,13 @@
 import { createApi } from "../common/controller.js";
-import { ReputationTemplateController } from "./templates/reputation/index.js";
-import { ReputationLockTemplateController } from "./templates/reputationLock/index.js";
-import { RwaTemplateController } from "./templates/rwa/index.js";
+import { ReputationTemplate } from "./templates/reputation/index.js";
+import { ReputationLockTemplate } from "./templates/reputationLock/index.js";
+import { RwaTemplate } from "./templates/rwa/index.js";
 export const StakingTemplatesApi = createApi({
     title: "Staking Templates API",
     description: "Staking Templates API for Decentralized finance",
     build: (factory) => factory
         .createApp()
-        .route("/reputation", ReputationTemplateController.build(factory))
-        .route("/reputationLock", ReputationLockTemplateController.build(factory))
-        .route("/rwa", RwaTemplateController.build(factory)),
+        .route("/reputation", ReputationTemplate.build(factory))
+        .route("/reputationLock", ReputationLockTemplate.build(factory))
+        .route("/rwa", RwaTemplate.build(factory)),
 });

package/dist/stakingTemplates/templates/common/getCreatePoolEvent.d.ts

@@ -1,4 +1,10 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { ITemplateHelper } from "./templates.js";
+export declare const GetCreatePoolEventResponse: z.ZodObject<{
+    poolId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    rewardAssetHandler: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    inputAssetKeeper: 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 function createGetCreatePoolEventController(template: ITemplateHelper): import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $get: {
@@ -9,9 +15,9 @@ export declare function createGetCreatePoolEventController(template: ITemplateHe
                 };
             };
             output: {
-                poolId: never;
-                inputAssetKeeper: `0x${string}`;
+                poolId: string & z.core.$brand<"Int256">;
                 rewardAssetHandler: `0x${string}`;
+                inputAssetKeeper: `0x${string}`;
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;

package/dist/stakingTemplates/templates/common/getCreatePoolEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getCreatePoolEvent.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getCreatePoolEvent.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAOjD,wBAAgB,kCAAkC,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;cAwC3E"}
+{"version":3,"file":"getCreatePoolEvent.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getCreatePoolEvent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAOjD,eAAO,MAAM,0BAA0B;;;;iBAMC,CAAC;AAEzC,wBAAgB,kCAAkC,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;cAyC3E"}

package/dist/stakingTemplates/templates/common/getCreatePoolEvent.js

@@ -3,11 +3,18 @@ import { resolver, validator } from "hono-openapi";
 import { waitForTransactionReceipt } from "viem/actions";
 import { parseAssetManagersDeployEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { getPublicClient } from "../../../common/blockchain.js";
 import { createController } from "../../../common/controller.js";
 import { HttpError } from "../../../common/http-error.js";
 import { AddressSchema, SentTransactionParamsSchema } from "../../../common/index.js";
+export const GetCreatePoolEventResponse = z
+    .object({
+    poolId: Int256Json.openapi({ description: "Id of a Pool", example: "1" }),
+    rewardAssetHandler: AddressSchema,
+    inputAssetKeeper: AddressSchema,
+})
+    .openapi("GetCreatePoolEventResponse");
 export function createGetCreatePoolEventController(template) {
     return createController({
         build: (factory) => factory.createApp().get("/", describeRoute({
@@ -19,11 +26,7 @@ export function createGetCreatePoolEventController(template) {
                     description: "Details of the created pool",
                     content: {
                         "application/json": {
-                            schema: resolver(z.object({
-                                poolId: Int256Json.openapi({ description: "Id of a Pool", example: "1" }),
-                                rewardAssetHandler: AddressSchema,
-                                inputAssetKeeper: AddressSchema,
-                            })),
+                            schema: resolver(GetCreatePoolEventResponse),
                         },
                     },
                 },
@@ -35,17 +38,16 @@ export function createGetCreatePoolEventController(template) {
             });
             const result = parseAssetManagersDeployEvent(template.template, receipt.logs);
             if (!result) {
-                throw new UnableParseCreatePoolEvent();
+                throw new HttpError(500, {
+                    message: `Can't parse pool create transaction. Make sure you're passing transaction that is generated by \`createPool\` action`,
+                    name: "UnableParseCreatePoolEvent",
+                });
             }
-            return c.json(result);
+            return c.json({
+                poolId: toInt256Json(result.poolId),
+                rewardAssetHandler: result.rewardAssetHandler,
+                inputAssetKeeper: result.inputAssetKeeper,
+            });
         }),
     });
 }
-class UnableParseCreatePoolEvent extends HttpError {
-    constructor() {
-        super(500, {
-            message: `Can't parse pool create transaction. Make sure you're passing transaction that is generated by \`createPool\` action`,
-            name: "UnableParseCreatePoolEvent",
-        });
-    }
-}

package/dist/stakingTemplates/templates/common/getPlatformDeployEvent.d.ts

@@ -1,4 +1,9 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { ITemplateHelper } from "./templates.js";
+export declare const GetPlatformDeployEventResponse: z.ZodObject<{
+    diamondAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    admin: 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 function createGetPlatformDeployEventController(template: ITemplateHelper): import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $get: {
@@ -13,7 +18,7 @@ export declare function createGetPlatformDeployEventController(template: ITempla
                 admin: `0x${string}`;
             };
             outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
+            status: 200;
         };
     };
 }, "/", "/">>;

package/dist/stakingTemplates/templates/common/getPlatformDeployEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPlatformDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getPlatformDeployEvent.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAOjD,wBAAgB,sCAAsC,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;cAuC/E"}
+{"version":3,"file":"getPlatformDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getPlatformDeployEvent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAOjD,eAAO,MAAM,8BAA8B;;;iBAKC,CAAC;AAE7C,wBAAgB,sCAAsC,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;cAkC/E"}

package/dist/stakingTemplates/templates/common/getPlatformDeployEvent.js

@@ -7,6 +7,12 @@ import { getPublicClient } from "../../../common/blockchain.js";
 import { createController } from "../../../common/controller.js";
 import { HttpError } from "../../../common/http-error.js";
 import { AddressSchema, SentTransactionParamsSchema } from "../../../common/index.js";
+export const GetPlatformDeployEventResponse = z
+    .object({
+    diamondAddress: AddressSchema,
+    admin: AddressSchema,
+})
+    .openapi("GetPlatformDeployEventResponse");
 export function createGetPlatformDeployEventController(template) {
     return createController({
         build: (factory) => factory.createApp().get("/", describeRoute({
@@ -18,10 +24,7 @@ export function createGetPlatformDeployEventController(template) {
                     description: "Returns estimated gas or estimation error",
                     content: {
                         "application/json": {
-                            schema: resolver(z.object({
-                                diamondAddress: AddressSchema,
-                                admin: AddressSchema,
-                            })),
+                            schema: resolver(GetPlatformDeployEventResponse),
                         },
                     },
                 },
@@ -35,7 +38,7 @@ export function createGetPlatformDeployEventController(template) {
             if (!result) {
                 throw new UnableParsePlatformDeployEvent();
             }
-            return c.json(result);
+            return c.json(result, 200);
         }),
     });
 }

package/dist/stakingTemplates/templates/common/getReward.d.ts

@@ -1,4 +1,9 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { ITemplateHelper } from "./templates.js";
+export declare const GetRewardRequest: z.ZodObject<{
+    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 function createGetRewardController(template: ITemplateHelper): import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $post: {

package/dist/stakingTemplates/templates/common/getReward.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getReward.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getReward.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKjD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;cAuClE"}
+{"version":3,"file":"getReward.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getReward.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKjD,eAAO,MAAM,gBAAgB;;;iBAKC,CAAC;AAE/B,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;cAiClE"}

package/dist/stakingTemplates/templates/common/getReward.js

@@ -5,6 +5,12 @@ import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { createController } from "../../../common/controller.js";
 import { PlatformContractAddress, StakeIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+export const GetRewardRequest = z
+    .object({
+    platform: PlatformContractAddress,
+    stakeId: StakeIdSchema,
+})
+    .openapi("GetRewardRequest");
 export function createGetRewardController(template) {
     return createController({
         build: (factory) => factory.createApp().post("/", describeRoute({
@@ -21,10 +27,7 @@ export function createGetRewardController(template) {
                     },
                 },
             },
-        }), validator("json", z.object({
-            platform: PlatformContractAddress,
-            stakeId: StakeIdSchema,
-        })), async (c) => {
+        }), validator("json", GetRewardRequest), async (c) => {
             const { platform, stakeId } = c.req.valid("json");
             const deployed = getReward(template.template, {
                 platform: platform,