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

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

@@ -1,4 +1,14 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { ITemplateHelper } from "./templates.js";
+export declare const GetStakeEventResponse: z.ZodObject<{
+    poolId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    stakeId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    operator: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    owner: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    inputPacketsStaked: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    stakeStartActiveTimestamp: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    unlockTimestamp: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
 export declare function createGetStakeEventController(template: ITemplateHelper): import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $get: {
@@ -9,13 +19,13 @@ export declare function createGetStakeEventController(template: ITemplateHelper)
                 };
             };
             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;

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

@@ -1 +1 @@
-{"version":3,"file":"getStakeEvent.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getStakeEvent.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAOjD,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;cA4CtE"}
+{"version":3,"file":"getStakeEvent.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getStakeEvent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAOjD,eAAO,MAAM,qBAAqB;;;;;;;;iBAUC,CAAC;AAEpC,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;cA6CtE"}

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

@@ -8,6 +8,17 @@ 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 GetStakeEventResponse = z
+    .object({
+    poolId: Int256Json.openapi({ description: "Id of a Pool", example: "1" }),
+    stakeId: Int256Json.openapi({ description: "Id of a Stake position (NFT Id)", example: "1" }),
+    operator: AddressSchema,
+    owner: AddressSchema,
+    inputPacketsStaked: Int256Json.openapi({ description: "Number of input packets staked" }),
+    stakeStartActiveTimestamp: Int256Json.openapi({ description: "Timestamp when the stake became active" }),
+    unlockTimestamp: Int256Json.openapi({ description: "Timestamp when the stake can be unlocked" }),
+})
+    .openapi("GetStakeEventResponse");
 export function createGetStakeEventController(template) {
     return createController({
         build: (factory) => factory.createApp().get("/", describeRoute({
@@ -19,15 +30,7 @@ export function createGetStakeEventController(template) {
                     description: "Details of the created stake position",
                     content: {
                         "application/json": {
-                            schema: resolver(z.object({
-                                poolId: Int256Json.openapi({ description: "Id of a Pool", example: "1" }),
-                                stakeId: Int256Json.openapi({ description: "Id of a Stake position (NFT Id)", example: "1" }),
-                                operator: AddressSchema,
-                                owner: AddressSchema,
-                                // inputPacketsStaked: result.args.inputPacketsStaked,
-                                // stakeStartActiveTimestamp: result.args.stakeStartActiveTimestamp,
-                                // unlockTimestamp: result.args.unlockTimestamp,
-                            })),
+                            schema: resolver(GetStakeEventResponse),
                         },
                     },
                 },
@@ -41,7 +44,15 @@ export function createGetStakeEventController(template) {
             if (!result) {
                 throw new UnableParseStakeEvent();
             }
-            return c.json(result, 200);
+            return c.json({
+                poolId: String(result.poolId),
+                stakeId: String(result.stakeId),
+                operator: result.operator,
+                owner: result.owner,
+                inputPacketsStaked: String(result.inputPacketsStaked),
+                stakeStartActiveTimestamp: String(result.stakeStartActiveTimestamp),
+                unlockTimestamp: String(result.unlockTimestamp),
+            }, 200);
         }),
     });
 }

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

@@ -1,4 +1,10 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { ITemplateHelper } from "./templates.js";
+export declare const PartialUnstakeRequest: 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">;
+    amount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
 export declare function createPartialUnstakeController(template: ITemplateHelper): import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $post: {

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

@@ -1 +1 @@
-{"version":3,"file":"partialUnstake.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/partialUnstake.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKjD,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;cA2CvE"}
+{"version":3,"file":"partialUnstake.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/partialUnstake.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKjD,eAAO,MAAM,qBAAqB;;;;iBAQC,CAAC;AAEpC,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;cAkCvE"}

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

@@ -5,6 +5,15 @@ import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { createController } from "../../../common/controller.js";
 import { PlatformContractAddress, StakeIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+export const PartialUnstakeRequest = z
+    .object({
+    platform: PlatformContractAddress,
+    stakeId: StakeIdSchema,
+    amount: Int256Json.openapi({
+        description: `The number of input packets to withdraw from the position, thereby decreasing it.`,
+    }),
+})
+    .openapi("PartialUnstakeRequest");
 export function createPartialUnstakeController(template) {
     return createController({
         build: (factory) => factory.createApp().post("/", describeRoute({
@@ -21,13 +30,7 @@ export function createPartialUnstakeController(template) {
                     },
                 },
             },
-        }), validator("json", z.object({
-            platform: PlatformContractAddress,
-            stakeId: StakeIdSchema,
-            amount: Int256Json.openapi({
-                description: `The number of input packets to withdraw from the position, thereby decreasing it.`,
-            }),
-        })), async (c) => {
+        }), validator("json", PartialUnstakeRequest), async (c) => {
             const { platform, stakeId, amount } = c.req.valid("json");
             const deployed = partialUnstake(template.template, {
                 platform: platform,

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"unstake.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/unstake.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKjD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;cAuChE"}
+{"version":3,"file":"unstake.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/unstake.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAKjD,eAAO,MAAM,cAAc;;;iBAKC,CAAC;AAE7B,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;cAiChE"}

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

@@ -4,6 +4,12 @@ import { unstake } from "@evergonlabs/tmi-protocol-staking-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { createController } from "../../../common/controller.js";
 import { PlatformContractAddress, StakeIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+export const UnstakeRequest = z
+    .object({
+    platform: PlatformContractAddress,
+    stakeId: StakeIdSchema,
+})
+    .openapi("UnstakeRequest");
 export function createUnstakeController(template) {
     return createController({
         build: (factory) => factory.createApp().post("/", describeRoute({
@@ -20,10 +26,7 @@ export function createUnstakeController(template) {
                     },
                 },
             },
-        }), validator("json", z.object({
-            platform: PlatformContractAddress,
-            stakeId: StakeIdSchema,
-        })), async (c) => {
+        }), validator("json", UnstakeRequest), async (c) => {
             const { platform, stakeId } = c.req.valid("json");
             const deployed = unstake(template.template, {
                 platform: platform,

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

@@ -1,4 +1,15 @@
-export declare const CreateReputationPlatformV0: 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 CreateReputationPlatformRequest: 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 CreateReputationPlatform: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {

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

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

package/dist/stakingTemplates/templates/reputation/{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 { reputation } 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 CreateReputationPlatformV0 = createController({
+import { reputation } 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 CreateReputationPlatformRequest = 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("CreateReputationPlatformRequest");
+export const CreateReputationPlatform = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Create platform",
         description: "Generates a transaction for a new platform",
@@ -22,20 +38,7 @@ export const CreateReputationPlatformV0 = 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", CreateReputationPlatformRequest), async (c) => {
         const { chainId, erc721, isSoulbound, adminAddress } = c.req.valid("json");
         const deployed = createPlatform(reputation.template, {
             chainId: chainId,

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

@@ -0,0 +1,58 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const CreateReputationPoolRequest: 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>>;
+    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">;
+}, z.core.$strip>;
+export declare const CreateReputationPool: 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][];
+                    stakingErc20: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    rewardErc20: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    rate: 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/reputation/createPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPool.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/reputation/createPool.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAaxD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;iBAUC,CAAC;AAE1C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAqE/B,CAAC"}

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

@@ -2,17 +2,28 @@ 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 { reputation } 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 { RewardRateSchema } from "../../../../stakingTemplates/templates/common/rewardDistribution.js";
-import { StartTimeSchema } from "../../../../stakingTemplates/templates/common/time.js";
-export const CreateReputationPoolV0 = createController({
+import { reputation } 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 { RewardRateSchema } from "../../../stakingTemplates/templates/common/rewardDistribution.js";
+import { StartTimeSchema } from "../../../stakingTemplates/templates/common/time.js";
+export const CreateReputationPoolRequest = z
+    .object({
+    platform: PlatformContractAddress,
+    startDate: StartTimeSchema,
+    amount: AmountTwoBorderSchema,
+    amountMult: AmountMultIntervalSchema,
+    stakingErc20: Erc20InputSchema,
+    rewardErc20: Erc20RewardSchema,
+    rate: RewardRateSchema,
+})
+    .openapi("CreateReputationPoolRequest");
+export const CreateReputationPool = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Create pool",
         description: "Generates a transaction for a new staking pool within the platform",
@@ -27,15 +38,7 @@ export const CreateReputationPoolV0 = createController({
                 },
             },
         },
-    }), validator("json", z.object({
-        platform: PlatformContractAddress,
-        startDate: StartTimeSchema,
-        amount: AmountTwoBorderSchema,
-        amountMult: AmountMultIntervalSchema,
-        stakingErc20: Erc20InputSchema,
-        rewardErc20: Erc20RewardSchema,
-        rate: RewardRateSchema,
-    })), async (c) => {
+    }), validator("json", CreateReputationPoolRequest), async (c) => {
         const { platform, startDate, amountMult, amount, rate, stakingErc20, rewardErc20 } = c.req.valid("json");
         const deployed = createPool(reputation.template, {
             platform: platform,

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/reputation/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAEvC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/reputation/index.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAc7B,CAAC"}

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

@@ -1,5 +1,26 @@
-import { ReputationTemplateV0 } from "./v0/index.js";
+import { reputation } from "./common.js";
+import { CreateReputationPlatform } from "./createPlatform.js";
+import { CreateReputationPool } from "./createPool.js";
+import { RestakeReputation } from "./restake.js";
+import { StakeReputation } from "./stake.js";
 import { createController } from "../../../common/controller.js";
-export const ReputationTemplateController = createController({
-    build: (factory) => factory.createApp().route("/v0", ReputationTemplateV0.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 ReputationTemplate = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/getPlatformDeployEvent", createGetPlatformDeployEventController(reputation).build(factory))
+        .route("/getStakeEvent", createGetStakeEventController(reputation).build(factory))
+        .route("/getCreatePoolEvent", createGetCreatePoolEventController(reputation).build(factory))
+        .route("/getReward", createGetRewardController(reputation).build(factory))
+        .route("/partialUnstake", createPartialUnstakeController(reputation).build(factory))
+        .route("/restake", RestakeReputation.build(factory))
+        .route("/stake", StakeReputation.build(factory))
+        .route("/unstake", createUnstakeController(reputation).build(factory))
+        .route("/createPool", CreateReputationPool.build(factory))
+        .route("/createPlatform", CreateReputationPlatform.build(factory)),
 });

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

@@ -0,0 +1,32 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const RestakeReputationRequest: 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 RestakeReputation: 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/reputation/restake.d.ts.map

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

package/dist/stakingTemplates/templates/reputation/{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 { reputation } from "../common.js";
-import { createController } from "../../../../common/controller.js";
-import { PlatformContractAddress, PoolIdSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
-export const RestakeReputationV0 = createController({
+import { reputation } from "./common.js";
+import { createController } from "../../../common/controller.js";
+import { PlatformContractAddress, PoolIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+export const RestakeReputationRequest = 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("RestakeReputationRequest");
+export const RestakeReputation = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Restake",
         description: "Generates a transaction for updating staking position",
@@ -21,13 +30,7 @@ export const RestakeReputationV0 = 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", RestakeReputationRequest), async (c) => {
         const { platform, poolId, amount } = c.req.valid("json");
         const deployed = stake(reputation.template, {
             platform: platform,

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

@@ -1,4 +1,10 @@
-export declare const RestakeRwaV0: 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 StakeReputationRequest: 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 StakeReputation: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
@@ -23,4 +29,4 @@ export declare const RestakeRwaV0: import("../../../../common/controller.js").IC
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=restake.d.ts.map
+//# sourceMappingURL=stake.d.ts.map

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

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

package/dist/stakingTemplates/templates/reputation/{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 { reputation } 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 StakeReputationV0 = createController({
+import { reputation } 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 StakeReputationRequest = 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("StakeReputationRequest");
+export const StakeReputation = 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 StakeReputationV0 = 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", StakeReputationRequest), async (c) => {
         const { platform, amount, poolId } = c.req.valid("json");
         const deployed = stake(reputation.template, {
             platform: platform,