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

package/dist/stakingTemplates/templates/rwa/createPool.d.ts

@@ -0,0 +1,56 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const CreateRwaPoolRequest: z.ZodObject<{
+    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    startDate: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">, z.ZodTransform<Date, string & z.core.$brand<"IsoDateString">>>;
+    hardcapAmount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    distribution: z.ZodObject<{
+        duration: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        distributor: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    }, z.core.$strip>;
+    erc20Input: z.ZodObject<{
+        contract: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        amountOfTokensPerPacket: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    }, z.core.$strip>;
+    erc20Reward: z.ZodObject<{
+        contract: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        amountOfTokensPerPacket: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CreateRwaPool: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    startDate: string;
+                    hardcapAmount: string;
+                    distribution: {
+                        duration: string;
+                        distributor: string;
+                    };
+                    erc20Input: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    erc20Reward: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=createPool.d.ts.map

package/dist/stakingTemplates/templates/rwa/createPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPool.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/rwa/createPool.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAYxD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;iBASC,CAAC;AAEnC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAiExB,CAAC"}

package/dist/stakingTemplates/templates/rwa/{v0/createPool.js → createPool.js}

@@ -2,16 +2,26 @@ import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { createPool, FacetOptionEnum, FacetSlot } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { rwa } from "../common.js";
-import { createController } from "../../../../common/controller.js";
-import { toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { PlatformContractAddress } from "../../../../common/models/platform.js";
-import { AmountHardCapSchema } from "../../../../stakingTemplates/templates/common/amount.js";
-import { Erc20InputSchema } from "../../../../stakingTemplates/templates/common/erc20Input.js";
-import { Erc20RewardSchema } from "../../../../stakingTemplates/templates/common/erc20Reward.js";
-import { RewardDistributionComplexSchema } from "../../../../stakingTemplates/templates/common/rewardDistribution.js";
-import { StartTimeSchema } from "../../../../stakingTemplates/templates/common/time.js";
-export const CreateRwaPoolV0 = createController({
+import { rwa } from "./common.js";
+import { createController } from "../../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../../common/index.js";
+import { PlatformContractAddress } from "../../../common/models/platform.js";
+import { AmountHardCapSchema } from "../../../stakingTemplates/templates/common/amount.js";
+import { Erc20InputSchema } from "../../../stakingTemplates/templates/common/erc20Input.js";
+import { Erc20RewardSchema } from "../../../stakingTemplates/templates/common/erc20Reward.js";
+import { RewardDistributionComplexSchema } from "../../../stakingTemplates/templates/common/rewardDistribution.js";
+import { StartTimeSchema } from "../../../stakingTemplates/templates/common/time.js";
+export const CreateRwaPoolRequest = z
+    .object({
+    platform: PlatformContractAddress,
+    startDate: StartTimeSchema,
+    hardcapAmount: AmountHardCapSchema,
+    distribution: RewardDistributionComplexSchema,
+    erc20Input: Erc20InputSchema,
+    erc20Reward: Erc20RewardSchema,
+})
+    .openapi("CreateRwaPoolRequest");
+export const CreateRwaPool = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Create pool",
         description: "Generates a transaction for a new staking pool within the platform",
@@ -26,14 +36,7 @@ export const CreateRwaPoolV0 = createController({
                 },
             },
         },
-    }), validator("json", z.object({
-        platform: PlatformContractAddress,
-        startDate: StartTimeSchema,
-        hardcapAmount: AmountHardCapSchema,
-        distribution: RewardDistributionComplexSchema,
-        erc20Input: Erc20InputSchema,
-        erc20Reward: Erc20RewardSchema,
-    })), async (c) => {
+    }), validator("json", CreateRwaPoolRequest), async (c) => {
         const { platform, startDate, hardcapAmount, distribution, erc20Input, erc20Reward } = c.req.valid("json");
         const deployed = createPool(rwa.template, {
             platform: platform,

package/dist/stakingTemplates/templates/{reputation/v0/stake.d.ts → rwa/distributeRewards.d.ts}

@@ -1,4 +1,10 @@
-export declare const StakeReputationV0: import("../../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../../common/context.js").AppContext, {
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const DistributeRewardsRwaRequest: z.ZodObject<{
+    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    poolId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    amount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
+export declare const DistributeRewardsRwa: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
@@ -23,4 +29,4 @@ export declare const StakeReputationV0: import("../../../../common/controller.js
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=stake.d.ts.map
+//# sourceMappingURL=distributeRewards.d.ts.map

package/dist/stakingTemplates/templates/rwa/distributeRewards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distributeRewards.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/rwa/distributeRewards.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,2BAA2B;;;;iBAQC,CAAC;AAE1C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;aAiC/B,CAAC"}

package/dist/stakingTemplates/templates/rwa/{v0/distributeRewards.js → distributeRewards.js}

@@ -3,11 +3,20 @@ import { resolver, validator } from "hono-openapi";
 import { distributeRewards } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Int256Json } from "@evergonlabs/tmi-utils/models";
-import { rwa } from "../common.js";
-import { createController } from "../../../../common/controller.js";
-import { toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { PlatformContractAddress, PoolIdSchema } from "../../../../common/models/platform.js";
-export const DistributeRewardsRwaV0 = createController({
+import { rwa } from "./common.js";
+import { createController } from "../../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../../common/index.js";
+import { PlatformContractAddress, PoolIdSchema } from "../../../common/models/platform.js";
+export const DistributeRewardsRwaRequest = z
+    .object({
+    platform: PlatformContractAddress,
+    poolId: PoolIdSchema,
+    amount: Int256Json.openapi({
+        description: "Number of Reward Packets to distribute to pool stakers.",
+    }),
+})
+    .openapi("DistributeRewardsRwaRequest");
+export const DistributeRewardsRwa = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Distribute rewards",
         description: "Generates a transaction for rewards allocation for certain pool.",
@@ -22,13 +31,7 @@ export const DistributeRewardsRwaV0 = createController({
                 },
             },
         },
-    }), validator("json", z.object({
-        platform: PlatformContractAddress,
-        poolId: PoolIdSchema,
-        amount: Int256Json.openapi({
-            description: "Number of Reward Packets to distribute to pool stakers.",
-        }),
-    })), async (c) => {
+    }), validator("json", DistributeRewardsRwaRequest), async (c) => {
         const { platform, poolId, amount } = c.req.valid("json");
         const transaction = distributeRewards(rwa.template, {
             platform: platform,

package/dist/stakingTemplates/templates/rwa/index.d.ts

@@ -1,4 +1,4 @@
-export declare const RwaTemplateController: 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 RwaTemplate: 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: {
@@ -12,7 +12,7 @@ export declare const RwaTemplateController: import("../../../common/controller.j
                 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 RwaTemplateController: import("../../../common/controller.j
                 };
             };
             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 RwaTemplateController: import("../../../common/controller.j
                 };
             };
             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;
@@ -262,5 +262,5 @@ export declare const RwaTemplateController: import("../../../common/controller.j
             status: 200;
         };
     };
-}, "/distributeRewards">, "/v0">, "/", "/">>;
+}, "/distributeRewards">, "/", "/">>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/rwa/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAEhC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/rwa/index.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAetB,CAAC"}

package/dist/stakingTemplates/templates/rwa/index.js

@@ -1,5 +1,28 @@
-import { RwaTemplateV0 } from "./v0/index.js";
+import { rwa } from "./common.js";
+import { CreateRwaPlatform } from "./createPlatform.js";
+import { CreateRwaPool } from "./createPool.js";
+import { DistributeRewardsRwa } from "./distributeRewards.js";
+import { RestakeRwa } from "./restake.js";
+import { StakeRwa } from "./stake.js";
 import { createController } from "../../../common/controller.js";
-export const RwaTemplateController = createController({
-    build: (factory) => factory.createApp().route("/v0", RwaTemplateV0.build(factory)),
+import { createGetCreatePoolEventController } from "../../../stakingTemplates/templates/common/getCreatePoolEvent.js";
+import { createGetPlatformDeployEventController } from "../../../stakingTemplates/templates/common/getPlatformDeployEvent.js";
+import { createGetRewardController } from "../../../stakingTemplates/templates/common/getReward.js";
+import { createGetStakeEventController } from "../../../stakingTemplates/templates/common/getStakeEvent.js";
+import { createPartialUnstakeController } from "../../../stakingTemplates/templates/common/partialUnstake.js";
+import { createUnstakeController } from "../../../stakingTemplates/templates/common/unstake.js";
+export const RwaTemplate = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/getPlatformDeployEvent", createGetPlatformDeployEventController(rwa).build(factory))
+        .route("/getStakeEvent", createGetStakeEventController(rwa).build(factory))
+        .route("/getCreatePoolEvent", createGetCreatePoolEventController(rwa).build(factory))
+        .route("/getReward", createGetRewardController(rwa).build(factory))
+        .route("/partialUnstake", createPartialUnstakeController(rwa).build(factory))
+        .route("/restake", RestakeRwa.build(factory))
+        .route("/stake", StakeRwa.build(factory))
+        .route("/unstake", createUnstakeController(rwa).build(factory))
+        .route("/createPool", CreateRwaPool.build(factory))
+        .route("/createPlatform", CreateRwaPlatform.build(factory))
+        .route("/distributeRewards", DistributeRewardsRwa.build(factory)),
 });

package/dist/stakingTemplates/templates/rwa/restake.d.ts

@@ -0,0 +1,32 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const RestakeRwaRequest: z.ZodObject<{
+    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    poolId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    amount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
+export declare const RestakeRwa: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    poolId: string;
+                    amount: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=restake.d.ts.map

package/dist/stakingTemplates/templates/rwa/restake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restake.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/rwa/restake.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,iBAAiB;;;;iBAQC,CAAC;AAEhC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;aAgCrB,CAAC"}

package/dist/stakingTemplates/templates/rwa/{v0/restake.js → restake.js}

@@ -3,10 +3,19 @@ import { resolver, validator } from "hono-openapi";
 import { stake } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Int256Json } from "@evergonlabs/tmi-utils/models";
-import { rwa } from "../common.js";
-import { createController } from "../../../../common/controller.js";
-import { PlatformContractAddress, PoolIdSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
-export const RestakeRwaV0 = createController({
+import { rwa } from "./common.js";
+import { createController } from "../../../common/controller.js";
+import { PlatformContractAddress, PoolIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+export const RestakeRwaRequest = z
+    .object({
+    platform: PlatformContractAddress,
+    poolId: PoolIdSchema,
+    amount: Int256Json.openapi({
+        description: `Number of Packets to be stacked. Each underlying asset must be approved to Staking Platform contract instance`,
+    }),
+})
+    .openapi("RestakeRwaRequest");
+export const RestakeRwa = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Restake",
         description: "Generates a transaction for updating staking position",
@@ -21,13 +30,7 @@ export const RestakeRwaV0 = createController({
                 },
             },
         },
-    }), validator("json", z.object({
-        platform: PlatformContractAddress,
-        poolId: PoolIdSchema,
-        amount: Int256Json.openapi({
-            description: `Number of Packets to be stacked. Each underlying asset must be approved to Staking Platform contract instance`,
-        }),
-    })), async (c) => {
+    }), validator("json", RestakeRwaRequest), async (c) => {
         const { platform, poolId, amount } = c.req.valid("json");
         const deployed = stake(rwa.template, {
             platform: platform,

package/dist/stakingTemplates/templates/rwa/stake.d.ts

@@ -0,0 +1,32 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const StakeRwaRequest: z.ZodObject<{
+    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    poolId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    amount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
+export declare const StakeRwa: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    poolId: string;
+                    amount: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=stake.d.ts.map

package/dist/stakingTemplates/templates/rwa/stake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stake.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/rwa/stake.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,eAAe;;;;iBAQC,CAAC;AAE9B,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;aAgCnB,CAAC"}

package/dist/stakingTemplates/templates/rwa/{v0/stake.js → stake.js}

@@ -3,11 +3,20 @@ import { resolver, validator } from "hono-openapi";
 import { stake } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Int256Json } from "@evergonlabs/tmi-utils/models";
-import { rwa } from "../common.js";
-import { createController } from "../../../../common/controller.js";
-import { PlatformContractAddress, PoolIdSchema, TransactionSchema } from "../../../../common/index.js";
-import { toTransaction } from "../../../../common/index.js";
-export const StakeRwaV0 = createController({
+import { rwa } from "./common.js";
+import { createController } from "../../../common/controller.js";
+import { PlatformContractAddress, PoolIdSchema, TransactionSchema } from "../../../common/index.js";
+import { toTransaction } from "../../../common/index.js";
+export const StakeRwaRequest = z
+    .object({
+    platform: PlatformContractAddress,
+    poolId: PoolIdSchema,
+    amount: Int256Json.openapi({
+        description: `Number of Packets to be stacked. Each underlying asset must be approved to Staking Platform contract instance`,
+    }),
+})
+    .openapi("StakeRwaRequest");
+export const StakeRwa = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Stake",
         description: "Generates a transaction for a new Stake position in specified Pool",
@@ -22,17 +31,7 @@ export const StakeRwaV0 = createController({
                 },
             },
         },
-    }), validator("json", z.object({
-        platform: PlatformContractAddress,
-        poolId: PoolIdSchema,
-        amount: Int256Json.openapi({
-            description: `Number of Packets to be stacked. Each underlying asset must be approved to Staking Platform contract instance`,
-        }),
-        // lockPeriod: z.string().pipe(z.coerce.number().int()).openapi({
-        //   example: "600",
-        //   description: "Lock period in Seconds",
-        // }),
-    })), async (c) => {
+    }), validator("json", StakeRwaRequest), async (c) => {
         const { platform, amount, poolId } = c.req.valid("json");
         const deployed = stake(rwa.template, {
             platform: platform,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evergonlabs/tmi-protocol-api",
-  "version": "0.11.0-rc.3",
+  "version": "0.11.0-rc.4",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -38,9 +38,9 @@
   ],
   "dependencies": {
     "@evergonlabs/tmi-contracts-fractions-sdk": "1.2.3",
-    "@evergonlabs/tmi-evm-contracts": "0.8.0-rc.0",
+    "@evergonlabs/tmi-evm-contracts": "0.8.0-rc.1",
     "@evergonlabs/tmi-factories-sdk": "0.3.1",
-    "@evergonlabs/tmi-utils": "0.8.0-rc.0",
+    "@evergonlabs/tmi-utils": "0.8.0-rc.1",
     "@hono/node-server": "^1.19.9",
     "@hono/standard-validator": "^0.2.2",
     "@hono/swagger-ui": "^0.5.3",
@@ -57,17 +57,17 @@
     "viem": "2.46.2",
     "zod": "^4.3.6",
     "zod-openapi": "^5.4.6",
-    "@evergonlabs/tmi-protocol-contracts": "0.11.0-rc.3",
-    "@evergonlabs/tmi-protocol-fractions-sdk": "0.11.0-rc.3",
-    "@evergonlabs/tmi-protocol-indexer": "0.11.0-rc.3",
-    "@evergonlabs/tmi-protocol-shared": "0.11.0-rc.3",
-    "@evergonlabs/tmi-protocol-staking-sdk": "0.11.0-rc.3",
-    "@evergonlabs/tmi-protocol-types": "0.11.0-rc.3",
-    "@evergonlabs/tmi-protocol-utils": "0.11.0-rc.3"
+    "@evergonlabs/tmi-protocol-contracts": "0.11.0-rc.4",
+    "@evergonlabs/tmi-protocol-fractions-sdk": "0.11.0-rc.4",
+    "@evergonlabs/tmi-protocol-indexer": "0.11.0-rc.4",
+    "@evergonlabs/tmi-protocol-shared": "0.11.0-rc.4",
+    "@evergonlabs/tmi-protocol-staking-sdk": "0.11.0-rc.4",
+    "@evergonlabs/tmi-protocol-types": "0.11.0-rc.4",
+    "@evergonlabs/tmi-protocol-utils": "0.11.0-rc.4"
   },
   "devDependencies": {
-    "@evergonlabs/tmi-eslint-config": "0.8.0-rc.0",
-    "@evergonlabs/tmi-typescript-config": "0.8.0-rc.0",
+    "@evergonlabs/tmi-eslint-config": "0.8.0-rc.1",
+    "@evergonlabs/tmi-typescript-config": "0.8.0-rc.1",
     "@topcli/prompts": "^2.1.0",
     "dotenv": "^17.2.2",
     "esbuild": "^0.25.0",

package/dist/fractions/sales/approveSale.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"approveSale.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/approveSale.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;aASxB,CAAC"}

package/dist/fractions/sales/approveWrapper.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"approveWrapper.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/approveWrapper.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}

package/dist/fractions/sales/completeSale.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"completeSale.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/completeSale.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;aAUzB,CAAC"}

package/dist/fractions/sales/createFractions.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createFractions.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/createFractions.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAiD5B,CAAC"}

package/dist/fractions/sales/getFractionSaleStatistics.route.d.ts

@@ -1,37 +0,0 @@
-import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const FractionsSaleStatisticSchema: z.ZodObject<{
-    chainId: z.ZodUnion<z.ZodLiteral<"1" | "31337" | "11155111" | "84532" | "72080">[]>;
-    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    campaignId: z.ZodCoercedString<unknown>;
-    statistics: z.ZodArray<z.ZodObject<{
-        priceId: z.ZodCoercedString<unknown>;
-        fractionsSold: z.ZodCoercedString<unknown>;
-        purchases: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const GetFractionSaleStatisticsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
-    "/": {
-        $post: {
-            input: {
-                json: {
-                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
-                    platform: string;
-                    campaignId: string;
-                };
-            };
-            output: {
-                chainId: "1" | "31337" | "11155111" | "84532" | "72080";
-                platform: `0x${string}`;
-                campaignId: string;
-                statistics: {
-                    priceId: string;
-                    fractionsSold: string;
-                    purchases: number;
-                }[];
-            };
-            outputFormat: "json";
-            status: 200;
-        };
-    };
-}, "/", "/">>;
-//# sourceMappingURL=getFractionSaleStatistics.route.d.ts.map

package/dist/fractions/sales/getFractionSaleStatistics.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getFractionSaleStatistics.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getFractionSaleStatistics.route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,4BAA4B;;;;;;;;;iBAaJ,CAAC;AAEtC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;aAkEtC,CAAC"}

package/dist/fractions/sales/purchase.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"purchase.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/purchase.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aASrB,CAAC"}

package/dist/fractions/sales/purchaseStatistics.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"purchaseStatistics.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/purchaseStatistics.route.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;aAqE/B,CAAC"}

package/dist/fractions/sales/receiveFundsAfterNonFunded.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"receiveFundsAfterNonFunded.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/receiveFundsAfterNonFunded.route.ts"],"names":[],"mappings":"AAgCA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;aASvC,CAAC;AAkBH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;aAc/C,CAAC;AAkBH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;aASpC,CAAC"}

package/dist/fractions/sales/receiveNonPurchasedWrappedAssets.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"receiveNonPurchasedWrappedAssets.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/receiveNonPurchasedWrappedAssets.route.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;aAc7C,CAAC"}

package/dist/fractions/sales/searchActivity.route.d.ts

@@ -1,71 +0,0 @@
-import { FractionSaleEventEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
-import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const SearchActivityV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
-    "/": {
-        $post: {
-            input: {
-                json: {
-                    page: {
-                        skip: number;
-                        limit: number;
-                    };
-                    filter: {
-                        chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
-                        platform?: string | undefined;
-                        campaignId?: string | undefined;
-                        operationType?: FractionSaleEventEnum | undefined;
-                    };
-                };
-            };
-            output: {
-                chainId: "1" | "31337" | "11155111" | "84532" | "72080";
-                platform: `0x${string}`;
-                campaignId: string & z.core.$brand<"Int256">;
-                transactionHash: `0x${string}`;
-                from: `0x${string}`;
-                createdAt: string & z.core.$brand<"IsoDateString">;
-                updatedAt: string & z.core.$brand<"IsoDateString">;
-                metadata: {
-                    type: FractionSaleEventEnum.CREATED;
-                } | {
-                    type: FractionSaleEventEnum.STATUS_UPDATE;
-                    status: import("@evergonlabs/tmi-protocol-indexer/schema").FractionSaleStatusEnum;
-                } | {
-                    type: FractionSaleEventEnum.PURCHASE;
-                    purchaser: `0x${string}`;
-                    priceId: string;
-                    amountOfFractions: string & z.core.$brand<"Int256">;
-                    amountPaid: string & z.core.$brand<"Int256">;
-                    amountBurnt: string & z.core.$brand<"Int256">;
-                } | {
-                    type: FractionSaleEventEnum.CLAIM;
-                    receiver: `0x${string}`;
-                    claimId: string;
-                    fractionsBurnt: string & z.core.$brand<"Int256">;
-                    received: {
-                        tokenAddress: `0x${string}`;
-                        amount: string & z.core.$brand<"Int256">;
-                        tokenId: string & z.core.$brand<"Int256">;
-                    }[];
-                } | {
-                    type: FractionSaleEventEnum.REFUND;
-                    amount: string & z.core.$brand<"Int256">;
-                } | {
-                    type: FractionSaleEventEnum.WITHDRAW;
-                    amount: string & z.core.$brand<"Int256">;
-                } | {
-                    type: FractionSaleEventEnum.WITHDRAW_NON_WRAPPED;
-                    receiver: `0x${string}`;
-                    received: {
-                        tokenAddress: `0x${string}`;
-                        amount: string & z.core.$brand<"Int256">;
-                        tokenId: string & z.core.$brand<"Int256">;
-                    }[];
-                };
-            }[];
-            outputFormat: "json";
-            status: import("hono/utils/http-status").ContentfulStatusCode;
-        };
-    };
-}, "/", "/">>;
-//# sourceMappingURL=searchActivity.route.d.ts.map

package/dist/fractions/sales/searchActivity.route.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"searchActivity.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/searchActivity.route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAmE3B,CAAC"}