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

package/dist/stakingTemplates/templates/reputationLock/createPlatform.d.ts

@@ -0,0 +1,42 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const CreateReputationLockPlatformRequest: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532">[]>;
+    erc721: z.ZodObject<{
+        symbol: z.ZodString;
+        name: z.ZodString;
+        baseUri: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strip>;
+    isSoulbound: z.ZodBoolean;
+    adminAddress: 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 CreateReputationLockPlatform: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: "31337" | "11155111" | "84532";
+                    erc721: {
+                        symbol: string;
+                        name: string;
+                        baseUri: string;
+                    };
+                    isSoulbound: boolean;
+                    adminAddress: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=createPlatform.d.ts.map

package/dist/stakingTemplates/templates/reputationLock/createPlatform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPlatform.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/reputationLock/createPlatform.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,mCAAmC;;;;;;;;;iBAeC,CAAC;AAElD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwCvC,CAAC"}

package/dist/stakingTemplates/templates/reputationLock/{v0/createPlatform.js → createPlatform.js}

@@ -3,11 +3,27 @@ import { resolver, validator } from "hono-openapi";
 import { FacetSlot } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { createPlatform, FacetOptionEnum } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { reputationLock } from "../common.js";
-import { createController } from "../../../../common/controller.js";
-import { AddressSchema, StakingChainId, toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { Erc721Schema } from "../../../../common/models/erc721.js";
-export const CreateReputationLockPlatformV0 = createController({
+import { reputationLock } from "./common.js";
+import { createController } from "../../../common/controller.js";
+import { AddressSchema, StakingChainId, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { Erc721Schema } from "../../../common/models/erc721.js";
+export const CreateReputationLockPlatformRequest = z
+    .object({
+    chainId: StakingChainId.openapi({
+        description: "Id of targeted chain",
+    }),
+    erc721: Erc721Schema.openapi({
+        description: "Details of the NFT that is going to be minted for user to track it's stake",
+    }),
+    isSoulbound: z.boolean().openapi({
+        description: "Whether NFT can be transferred to other wallet (secondary market the stake)",
+    }),
+    adminAddress: AddressSchema.openapi({
+        description: "Grant admin role to speficied address",
+    }),
+})
+    .openapi("CreateReputationLockPlatformRequest");
+export const CreateReputationLockPlatform = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Create platform",
         description: "Generates a transaction for a new platform",
@@ -22,20 +38,7 @@ export const CreateReputationLockPlatformV0 = createController({
                 },
             },
         },
-    }), validator("json", z.object({
-        chainId: StakingChainId.openapi({
-            description: "Id of targeted chain",
-        }),
-        erc721: Erc721Schema.openapi({
-            description: "Details of the NFT that is going to be minted for user to track it's stake",
-        }),
-        isSoulbound: z.boolean().openapi({
-            description: "Whether NFT can be transferred to other wallet (secondary market the stake)",
-        }),
-        adminAddress: AddressSchema.openapi({
-            description: "Grant admin role to speficied address",
-        }),
-    })), async (c) => {
+    }), validator("json", CreateReputationLockPlatformRequest), async (c) => {
         const { chainId, erc721, isSoulbound, adminAddress } = c.req.valid("json");
         const deployed = createPlatform(reputationLock.template, {
             chainId: chainId,

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

@@ -0,0 +1,76 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const CreateReputationLockPoolRequest: 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">>>;
+    amount: z.ZodObject<{
+        minAmount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        maxAmount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    }, z.core.$strip>;
+    amountMult: z.ZodArray<z.ZodTuple<[z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.core.$ZodBranded<z.ZodString, "Int256", "out">], null>>;
+    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>;
+    stakingErc20: 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>;
+    rewardErc20: 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>;
+    rate: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    lock: z.ZodObject<{
+        minAcceptedLockPeriod: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        maxAcceptedLockPeriod: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    }, z.core.$strip>;
+    lockMult: z.ZodArray<z.ZodTuple<[z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.core.$ZodBranded<z.ZodString, "Int256", "out">], null>>;
+}, z.core.$strip>;
+export declare const CreateReputationLockPool: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    startDate: string;
+                    amount: {
+                        minAmount: string;
+                        maxAmount: string;
+                    };
+                    amountMult: [string, string][];
+                    distribution: {
+                        duration: string;
+                        distributor: string;
+                    };
+                    stakingErc20: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    rewardErc20: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    rate: string;
+                    lock: {
+                        minAcceptedLockPeriod: string;
+                        maxAcceptedLockPeriod: string;
+                    };
+                    lockMult: [string, 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/reputationLock/createPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPool.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/reputationLock/createPool.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAkBxD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;iBAaC,CAAC;AAE9C,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA+EnC,CAAC"}

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

@@ -2,19 +2,33 @@ 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 { reputationLock } from "../common.js";
-import { createController } from "../../../../common/controller.js";
-import { toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { PlatformContractAddress } from "../../../../common/models/platform.js";
-import { AmountTwoBorderSchema } from "../../../../stakingTemplates/templates/common/amount.js";
-import { AmountMultIntervalSchema } from "../../../../stakingTemplates/templates/common/amountMult.js";
-import { Erc20InputSchema } from "../../../../stakingTemplates/templates/common/erc20Input.js";
-import { Erc20RewardSchema } from "../../../../stakingTemplates/templates/common/erc20Reward.js";
-import { LockTwoBorderSchema } from "../../../../stakingTemplates/templates/common/lock.js";
-import { LockMultIntervalSchema } from "../../../../stakingTemplates/templates/common/lockMult.js";
-import { RewardDistributionComplexSchema, RewardRateSchema, } from "../../../../stakingTemplates/templates/common/rewardDistribution.js";
-import { StartTimeSchema } from "../../../../stakingTemplates/templates/common/time.js";
-export const CreateReputationLockPoolV0 = createController({
+import { reputationLock } from "./common.js";
+import { createController } from "../../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../../common/index.js";
+import { PlatformContractAddress } from "../../../common/models/platform.js";
+import { AmountTwoBorderSchema } from "../../../stakingTemplates/templates/common/amount.js";
+import { AmountMultIntervalSchema } from "../../../stakingTemplates/templates/common/amountMult.js";
+import { Erc20InputSchema } from "../../../stakingTemplates/templates/common/erc20Input.js";
+import { Erc20RewardSchema } from "../../../stakingTemplates/templates/common/erc20Reward.js";
+import { LockTwoBorderSchema } from "../../../stakingTemplates/templates/common/lock.js";
+import { LockMultIntervalSchema } from "../../../stakingTemplates/templates/common/lockMult.js";
+import { RewardDistributionComplexSchema, RewardRateSchema, } from "../../../stakingTemplates/templates/common/rewardDistribution.js";
+import { StartTimeSchema } from "../../../stakingTemplates/templates/common/time.js";
+export const CreateReputationLockPoolRequest = z
+    .object({
+    platform: PlatformContractAddress,
+    startDate: StartTimeSchema,
+    amount: AmountTwoBorderSchema,
+    amountMult: AmountMultIntervalSchema,
+    distribution: RewardDistributionComplexSchema,
+    stakingErc20: Erc20InputSchema,
+    rewardErc20: Erc20RewardSchema,
+    rate: RewardRateSchema,
+    lock: LockTwoBorderSchema,
+    lockMult: LockMultIntervalSchema,
+})
+    .openapi("CreateReputationLockPoolRequest");
+export const CreateReputationLockPool = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Create pool",
         description: "Generates a transaction for a new staking pool within the platform",
@@ -29,18 +43,7 @@ export const CreateReputationLockPoolV0 = createController({
                 },
             },
         },
-    }), validator("json", z.object({
-        platform: PlatformContractAddress,
-        startDate: StartTimeSchema,
-        amount: AmountTwoBorderSchema,
-        amountMult: AmountMultIntervalSchema,
-        distribution: RewardDistributionComplexSchema,
-        stakingErc20: Erc20InputSchema,
-        rewardErc20: Erc20RewardSchema,
-        rate: RewardRateSchema,
-        lock: LockTwoBorderSchema,
-        lockMult: LockMultIntervalSchema,
-    })), async (c) => {
+    }), validator("json", CreateReputationLockPoolRequest), async (c) => {
         const { platform, startDate, amountMult, amount, lock, lockMult, rate, stakingErc20, rewardErc20 } = c.req.valid("json");
         const deployed = createPool(reputationLock.template, {
             platform: platform,

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

@@ -1,4 +1,4 @@
-export declare const ReputationLockTemplateController: 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 ReputationLockTemplate: 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 ReputationLockTemplateController: import("../../../common/c
                 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 ReputationLockTemplateController: import("../../../common/c
                 };
             };
             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 ReputationLockTemplateController: import("../../../common/c
                 };
             };
             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;
@@ -250,5 +250,5 @@ export declare const ReputationLockTemplateController: import("../../../common/c
             status: 200;
         };
     };
-}, "/createPlatform">, "/v0">, "/", "/">>;
+}, "/createPlatform">, "/", "/">>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/reputationLock/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAE3C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/reputationLock/index.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAcjC,CAAC"}

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

@@ -1,5 +1,26 @@
-import { ReputationLockTemplateV0 } from "./v0/index.js";
+import { reputationLock } from "./common.js";
+import { CreateReputationLockPlatform } from "./createPlatform.js";
+import { CreateReputationLockPool } from "./createPool.js";
+import { RestakeReputationLock } from "./restake.js";
+import { StakeReputationLock } from "./stake.js";
 import { createController } from "../../../common/controller.js";
-export const ReputationLockTemplateController = createController({
-    build: (factory) => factory.createApp().route("/v0", ReputationLockTemplateV0.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 ReputationLockTemplate = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/getPlatformDeployEvent", createGetPlatformDeployEventController(reputationLock).build(factory))
+        .route("/getStakeEvent", createGetStakeEventController(reputationLock).build(factory))
+        .route("/getCreatePoolEvent", createGetCreatePoolEventController(reputationLock).build(factory))
+        .route("/getReward", createGetRewardController(reputationLock).build(factory))
+        .route("/partialUnstake", createPartialUnstakeController(reputationLock).build(factory))
+        .route("/restake", RestakeReputationLock.build(factory))
+        .route("/stake", StakeReputationLock.build(factory))
+        .route("/unstake", createUnstakeController(reputationLock).build(factory))
+        .route("/createPool", CreateReputationLockPool.build(factory))
+        .route("/createPlatform", CreateReputationLockPlatform.build(factory)),
 });

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

@@ -0,0 +1,34 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const RestakeReputationLockRequest: 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">;
+    lockPeriod: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
+export declare const RestakeReputationLock: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    poolId: string;
+                    amount: string;
+                    lockPeriod: 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/reputationLock/restake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restake.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/reputationLock/restake.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,4BAA4B;;;;;iBAWC,CAAC;AAE3C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;aAiChC,CAAC"}

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

@@ -3,10 +3,22 @@ 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 { reputationLock } from "../common.js";
-import { createController } from "../../../../common/controller.js";
-import { PlatformContractAddress, PoolIdSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
-export const RestakeReputationLockV0 = createController({
+import { reputationLock } from "./common.js";
+import { createController } from "../../../common/controller.js";
+import { PlatformContractAddress, PoolIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+export const RestakeReputationLockRequest = 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: Int256Json.openapi({
+        description: "The duration, in seconds, during which the position's staked Packets will be locked.",
+    }),
+})
+    .openapi("RestakeReputationLockRequest");
+export const RestakeReputationLock = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Restake",
         description: "Generates a transaction for updating staking position",
@@ -21,16 +33,7 @@ export const RestakeReputationLockV0 = 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: Int256Json.openapi({
-            description: "The duration, in seconds, during which the position's staked Packets will be locked.",
-        }),
-    })), async (c) => {
+    }), validator("json", RestakeReputationLockRequest), async (c) => {
         const { platform, poolId, amount, lockPeriod } = c.req.valid("json");
         const deployed = stake(reputationLock.template, {
             platform: platform,

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

@@ -0,0 +1,34 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const StakeReputationLockRequest: 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">;
+    lockPeriod: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
+export declare const StakeReputationLock: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    poolId: string;
+                    amount: string;
+                    lockPeriod: 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/reputationLock/stake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stake.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/reputationLock/stake.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,0BAA0B;;;;;iBAYC,CAAC;AAEzC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;aAiC9B,CAAC"}

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

@@ -3,11 +3,24 @@ 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 { reputationLock } 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 StakeReputationLockV0 = createController({
+import { reputationLock } 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 StakeReputationLockRequest = 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: Int256Json.openapi({
+        example: "600",
+        description: "Lock period in Seconds",
+    }),
+})
+    .openapi("StakeReputationLockRequest");
+export const StakeReputationLock = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Stake",
         description: "Generates a transaction for a new Stake position in specified Pool",
@@ -22,17 +35,7 @@ export const StakeReputationLockV0 = 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: Int256Json.openapi({
-            example: "600",
-            description: "Lock period in Seconds",
-        }),
-    })), async (c) => {
+    }), validator("json", StakeReputationLockRequest), async (c) => {
         const { platform, amount, poolId, lockPeriod } = c.req.valid("json");
         const deployed = stake(reputationLock.template, {
             platform: platform,

package/dist/stakingTemplates/templates/{reputationLock/v0 → rwa}/createPlatform.d.ts

@@ -1,4 +1,15 @@
-export declare const CreateReputationLockPlatformV0: 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 CreateRwaPlatformRequest: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532">[]>;
+    erc721: z.ZodObject<{
+        symbol: z.ZodString;
+        name: z.ZodString;
+        baseUri: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strip>;
+    isSoulbound: z.ZodBoolean;
+    adminAddress: 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 CreateRwaPlatform: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPlatform.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/rwa/createPlatform.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,wBAAwB;;;;;;;;;iBAeC,CAAC;AAEvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwC5B,CAAC"}

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

@@ -3,11 +3,27 @@ import { resolver, validator } from "hono-openapi";
 import { FacetSlot } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { createPlatform, FacetOptionEnum } 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 { AddressSchema, StakingChainId, toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { Erc721Schema } from "../../../../common/models/erc721.js";
-export const CreateRwaPlatformV0 = createController({
+import { rwa } from "./common.js";
+import { createController } from "../../../common/controller.js";
+import { AddressSchema, StakingChainId, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { Erc721Schema } from "../../../common/models/erc721.js";
+export const CreateRwaPlatformRequest = z
+    .object({
+    chainId: StakingChainId.openapi({
+        description: "Id of targeted chain",
+    }),
+    erc721: Erc721Schema.openapi({
+        description: "Details of the NFT that is going to be minted for user to track it's stake",
+    }),
+    isSoulbound: z.boolean().openapi({
+        description: "Whether NFT can be transferred to other wallet (secondary market the stake)",
+    }),
+    adminAddress: AddressSchema.openapi({
+        description: "Grant admin role to speficied address",
+    }),
+})
+    .openapi("CreateRwaPlatformRequest");
+export const CreateRwaPlatform = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Create platform",
         description: "Generates a transaction for a new platform",
@@ -22,20 +38,7 @@ export const CreateRwaPlatformV0 = createController({
                 },
             },
         },
-    }), validator("json", z.object({
-        chainId: StakingChainId.openapi({
-            description: "Id of targeted chain",
-        }),
-        erc721: Erc721Schema.openapi({
-            description: "Details of the NFT that is going to be minted for user to track it's stake",
-        }),
-        isSoulbound: z.boolean().openapi({
-            description: "Whether NFT can be transferred to other wallet (secondary market the stake)",
-        }),
-        adminAddress: AddressSchema.openapi({
-            description: "Grant admin role to speficied address",
-        }),
-    })), async (c) => {
+    }), validator("json", CreateRwaPlatformRequest), async (c) => {
         const { chainId, erc721, isSoulbound, adminAddress } = c.req.valid("json");
         const deployed = createPlatform(rwa.template, {
             chainId: chainId,