@evergonlabs/tmi-protocol-api 0.1.0

package/dist/staking-templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/staking-templates/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAMvC,eAAO,MAAM,mBAAmB;;gBAElB,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe/C,CAAC"}

package/dist/staking-templates/index.js

@@ -0,0 +1,18 @@
+import { createApiConfig } from "../common/app.js";
+import { createRWATemplateApp } from "./templates/rwa/index.js";
+import { createReputationTemplateApp } from "./templates/reputation/index.js";
+import { createReputationLockTemplateApp } from "./templates/reputationLock/index.js";
+export const stakingTemplatesApi = {
+    name: "Staking Templates",
+    createApp: (factory) => factory
+        .createApp()
+        .route("/stakingTemplates", factory
+        .createApp()
+        .route("/reputation", createReputationTemplateApp(factory))
+        .route("/reputationLock", createReputationLockTemplateApp(factory))
+        .route("/rwa", createRWATemplateApp(factory))),
+    config: createApiConfig({
+        title: "Staking Templates API",
+        description: "Staking Templates API for Decentralized finance",
+    }),
+};

package/dist/staking-templates/templates/common/amount.d.ts

@@ -0,0 +1,13 @@
+import { z } from "../../../common/zod.js";
+export declare const AmountHardCapSchema: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+export declare const AmountTwoBorderSchema: z.ZodObject<{
+    minAmount: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    maxAmount: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+}, "strip", z.ZodTypeAny, {
+    minAmount: bigint;
+    maxAmount: bigint;
+}, {
+    minAmount: string | number | bigint;
+    maxAmount: string | number | bigint;
+}>;
+//# sourceMappingURL=amount.d.ts.map

package/dist/staking-templates/templates/common/amount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amount.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/amount.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAE3C,eAAO,MAAM,mBAAmB,iFAE9B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;EAa9B,CAAC"}

package/dist/staking-templates/templates/common/amount.js

@@ -0,0 +1,17 @@
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { z } from "../../../common/zod.js";
+export const AmountHardCapSchema = Int256Positive.openapi({
+    description: `The maximum number (uint256) of input Packets that can be allocated to the campaign.\n\nIf 0, then no upper limit is enforced on the specified campaign.`,
+});
+export const AmountTwoBorderSchema = z
+    .object({
+    minAmount: Int256Positive.openapi({
+        description: "The minimum number (uint256) of input packets required to create and maintain a position within the campaign must be less than or equal to maxAmount.",
+    }),
+    maxAmount: Int256Positive.openapi({
+        description: "The maximum number (uint256) of input packets that a position can support within the campaign. must be strictly greater than 0 (if no upper limit is required, use safe uint256 value.",
+    }),
+})
+    .openapi({
+    ref: "AmountTwoBorder",
+});

package/dist/staking-templates/templates/common/amountMult.d.ts

@@ -0,0 +1,3 @@
+import { z } from "../../../common/zod.js";
+export declare const AmountMultIntervalSchema: z.ZodArray<z.ZodTuple<[z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>, z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>], null>, "many">;
+//# sourceMappingURL=amountMult.d.ts.map

package/dist/staking-templates/templates/common/amountMult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amountMult.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/amountMult.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAG3C,eAAO,MAAM,wBAAwB,0MAoBnC,CAAC"}

package/dist/staking-templates/templates/common/amountMult.js

@@ -0,0 +1,23 @@
+import { z } from "../../../common/zod.js";
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+export const AmountMultIntervalSchema = z.array(z.tuple([Int256Positive, Int256Positive])).openapi({
+    ref: "AmountMultInterval",
+    description: `An array of tuples where:
+      1st element: An amount of Packets defining thresholds for amount-based multipliers.
+      2nd element: A respective multiplier values for each threshold.
+
+      Example of an interval-based schema configuration: If packetsAndMultipliers = \`[[100, 2], [300, 4]]\`:
+      A position with less than 100 staked packets will receive an amount multiplier of 1 (no multiplier).
+      A position with staked packets between 100 and 299 will receive an amount multiplier of 2.
+      A position with staked packets 300 or more will receive an amount multiplier of 4.
+
+      In addition to amount-wise scaling of rewards, staking campaigns may also scale 
+      rewards based on the lock period (i.e., lock multipliers). 
+      
+      This implementation focuses solely on staked amount scaling, ensuring that 
+      positions receive rewards according to the interval-based amount multiplier 
+      schema defined by the associated campaign.
+
+      IMPORTANT: \`All values must be in strictly increasing order\`
+    `,
+});

package/dist/staking-templates/templates/common/erc20Input.d.ts

@@ -0,0 +1,12 @@
+import { z } from "../../../common/zod.js";
+export declare const Erc20InputSchema: z.ZodObject<{
+    contract: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amountOfTokensPerPacket: z.ZodPipeline<z.ZodString, z.ZodBigInt>;
+}, "strip", z.ZodTypeAny, {
+    contract: `0x${string}`;
+    amountOfTokensPerPacket: bigint;
+}, {
+    contract: `0x${string}`;
+    amountOfTokensPerPacket: string;
+}>;
+//# sourceMappingURL=erc20Input.d.ts.map

package/dist/staking-templates/templates/common/erc20Input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc20Input.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/erc20Input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAG3C,eAAO,MAAM,gBAAgB;;;;;;;;;EAazB,CAAC"}

package/dist/staking-templates/templates/common/erc20Input.js

@@ -0,0 +1,16 @@
+import { z } from "../../../common/zod.js";
+import { AddressSchema } from "../../../common/index.js";
+export const Erc20InputSchema = z
+    .object({
+    contract: AddressSchema.openapi({
+        description: "An address of the ERC20 token encapsulated by the Input Packet.",
+    }),
+    amountOfTokensPerPacket: z.string().pipe(z.coerce.bigint()).openapi({
+        type: "string",
+        description: "Amount of tokens per Packet (using Wei)",
+    }),
+})
+    .openapi({
+    ref: "Erc20Input",
+    description: "Address and amount of tokens per Packet to be used as an Input for a Staking Pool",
+});

package/dist/staking-templates/templates/common/erc20Reward.d.ts

@@ -0,0 +1,12 @@
+import { z } from "../../../common/zod.js";
+export declare const Erc20RewardSchema: z.ZodObject<{
+    contract: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amountOfTokensPerPacket: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+}, "strip", z.ZodTypeAny, {
+    contract: `0x${string}`;
+    amountOfTokensPerPacket: bigint;
+}, {
+    contract: `0x${string}`;
+    amountOfTokensPerPacket: string | number | bigint;
+}>;
+//# sourceMappingURL=erc20Reward.d.ts.map

package/dist/staking-templates/templates/common/erc20Reward.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc20Reward.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/erc20Reward.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAI3C,eAAO,MAAM,iBAAiB;;;;;;;;;EAY1B,CAAC"}

package/dist/staking-templates/templates/common/erc20Reward.js

@@ -0,0 +1,16 @@
+import { z } from "../../../common/zod.js";
+import { AddressSchema } from "../../../common/index.js";
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+export const Erc20RewardSchema = z
+    .object({
+    contract: AddressSchema.openapi({
+        description: `An address of the ERC20 token encapsulated by the reward Packet.`,
+    }),
+    amountOfTokensPerPacket: Int256Positive.openapi({
+        description: `Amount of tokens per Packet \n\nIMPORTANT: should be parsed with each token's decimal precision (using wei values)`,
+    }),
+})
+    .openapi({
+    ref: "Erc20Reward",
+    description: "Address and amount of tokens per Packet to be used as a Reward for a staking Pool",
+});

package/dist/staking-templates/templates/common/getCreatePoolEvent.d.ts

@@ -0,0 +1,31 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITemplateHelper } from "./templates.js";
+export declare function createGetCreatePoolEventRoute<E extends Env>(factory: Factory<E>, template: ITemplateHelper): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        query: {
+            chainId: string | string[];
+            hash: string | string[];
+        };
+    };
+    out: {
+        query: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            hash: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        query: {
+            chainId: string | string[];
+            hash: string | string[];
+        };
+    };
+    out: {
+        query: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            hash: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
+//# sourceMappingURL=getCreatePoolEvent.d.ts.map

package/dist/staking-templates/templates/common/getCreatePoolEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCreatePoolEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getCreatePoolEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAQvC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;0EAoC1G"}

package/dist/staking-templates/templates/common/getCreatePoolEvent.js

@@ -0,0 +1,47 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { waitForTransactionReceipt } from "viem/actions";
+import { parseAssetManagersDeployEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { AddressSchema, PoolIdSchema, SentTransactionParamsSchema } from "../../../common/index.js";
+import { getPublicClient } from "../../../common/blockchain.js";
+import { HttpError } from "../../../common/http-error.js";
+import { z } from "../../../common/zod.js";
+export function createGetCreatePoolEventRoute(factory, template) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get Pool Create Event",
+        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted with corresponding \`createPool\` action`,
+        tags: [template.tag.tag],
+        responses: {
+            200: {
+                description: "Details of the created pool",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            poolId: PoolIdSchema,
+                            rewardAssetHandler: AddressSchema,
+                            inputAssetKeeper: AddressSchema,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", SentTransactionParamsSchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId), {
+            hash: params.hash,
+        });
+        const result = parseAssetManagersDeployEvent(template.template, receipt.logs);
+        if (!result) {
+            throw new UnableParseCreatePoolEvent();
+        }
+        return c.json(result, 200);
+    });
+}
+class UnableParseCreatePoolEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse pool create transaction. Make sure you're passing transaction that is generated by \`createPool\` action`,
+            name: "UnableParseCreatePoolEvent",
+        });
+    }
+}

package/dist/staking-templates/templates/common/getPlatformDeployEvent.d.ts

@@ -0,0 +1,40 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITemplateHelper } from "./templates.js";
+export declare function createGetPlatformDeployEventRoute<E extends Env>(factory: Factory<E>, template: ITemplateHelper): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    diamondAddress: `0x${string}`;
+    admin: `0x${string}`;
+}, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        query: {
+            chainId: string | string[];
+            hash: string | string[];
+        };
+    };
+    out: {
+        query: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            hash: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    diamondAddress: `0x${string}`;
+    admin: `0x${string}`;
+}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        query: {
+            chainId: string | string[];
+            hash: string | string[];
+        };
+    };
+    out: {
+        query: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            hash: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    diamondAddress: `0x${string}`;
+    admin: `0x${string}`;
+}, 200, "json">>>];
+//# sourceMappingURL=getPlatformDeployEvent.d.ts.map

package/dist/staking-templates/templates/common/getPlatformDeployEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPlatformDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getPlatformDeployEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,iCAAiC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAmC9G"}

package/dist/staking-templates/templates/common/getPlatformDeployEvent.js

@@ -0,0 +1,46 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { parseDeployDiamondEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { waitForTransactionReceipt } from "viem/actions";
+import { AddressSchema, SentTransactionParamsSchema } from "../../../common/index.js";
+import { getPublicClient } from "../../../common/blockchain.js";
+import { HttpError } from "../../../common/http-error.js";
+import { z } from "../../../common/zod.js";
+export function createGetPlatformDeployEventRoute(factory, template) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get Platform Deploy Event",
+        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted with corresponding \`createPlatform\` action`,
+        tags: [template.tag.tag],
+        responses: {
+            200: {
+                description: "Returns estimated gas or estimation error",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            diamondAddress: AddressSchema,
+                            admin: AddressSchema,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", SentTransactionParamsSchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId), {
+            hash: params.hash,
+        });
+        const result = parseDeployDiamondEvent(receipt.logs);
+        if (!result) {
+            throw new UnableParsePlatformDeployEvent();
+        }
+        return c.json(result, 200);
+    });
+}
+class UnableParsePlatformDeployEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse platform deployment transaction. Make sure you're passing transaction that is generated by \`createPlatform\` action`,
+            name: "UnableParsePlatformDeployEvent",
+        });
+    }
+}

package/dist/staking-templates/templates/common/getReward.d.ts

@@ -0,0 +1,58 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { ITemplateHelper } from "./templates.js";
+export declare function createGetRewardRoute<E extends Env>(factory: Factory<E>, template: ITemplateHelper): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            platform: `0x${string}`;
+            stakeId: string | number | bigint;
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            stakeId: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            platform: `0x${string}`;
+            stakeId: string | number | bigint;
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            stakeId: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>];
+//# sourceMappingURL=getReward.d.ts.map

package/dist/staking-templates/templates/common/getReward.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getReward.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getReward.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAM3B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAmCjG"}

package/dist/staking-templates/templates/common/getReward.js

@@ -0,0 +1,34 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { z } from "../../../common/zod.js";
+import { getReward } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { PlatformContractAddress, StakeIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+export function createGetRewardRoute(factory, template) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get Reward",
+        description: "Generates a transaction for claiming all accumulated Rewards",
+        tags: [template.tag.tag],
+        responses: {
+            200: {
+                description: "Compiled Get Rewards transaction details",
+                content: {
+                    "application/json": {
+                        schema: resolver(TransactionSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        platform: PlatformContractAddress,
+        stakeId: StakeIdSchema,
+    })), async (c) => {
+        const { platform, stakeId } = c.req.valid("json");
+        const deployed = getReward(template.template, {
+            platform: platform,
+            data: {
+                stakeId: stakeId,
+            },
+        });
+        return c.json(toTransaction(deployed), 200);
+    });
+}

package/dist/staking-templates/templates/common/getStakeEvent.d.ts

@@ -0,0 +1,31 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { ITemplateHelper } from "./templates.js";
+export declare function createStakeEventRoute<E extends Env>(factory: Factory<E>, template: ITemplateHelper): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        query: {
+            chainId: string | string[];
+            hash: string | string[];
+        };
+    };
+    out: {
+        query: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            hash: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        query: {
+            chainId: string | string[];
+            hash: string | string[];
+        };
+    };
+    out: {
+        query: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            hash: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
+//# sourceMappingURL=getStakeEvent.d.ts.map

package/dist/staking-templates/templates/common/getStakeEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStakeEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getStakeEvent.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAM3B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;0EAwClG"}

package/dist/staking-templates/templates/common/getStakeEvent.js

@@ -0,0 +1,51 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { parseStakeEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { AddressSchema, PoolIdSchema, SentTransactionParamsSchema, StakeIdSchema } from "../../../common/index.js";
+import { z } from "../../../common/zod.js";
+import { getPublicClient } from "../../../common/blockchain.js";
+import { HttpError } from "../../../common/http-error.js";
+import { waitForTransactionReceipt } from "viem/actions";
+export function createStakeEventRoute(factory, template) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get Stake Event",
+        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted with corresponding \`stake\` action`,
+        tags: [template.tag.tag],
+        responses: {
+            200: {
+                description: "Details of the created stake position",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            poolId: PoolIdSchema,
+                            stakeId: StakeIdSchema,
+                            operator: AddressSchema,
+                            owner: AddressSchema,
+                            // inputPacketsStaked: result.args.inputPacketsStaked,
+                            // stakeStartActiveTimestamp: result.args.stakeStartActiveTimestamp,
+                            // unlockTimestamp: result.args.unlockTimestamp,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", SentTransactionParamsSchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId), {
+            hash: params.hash,
+        });
+        const result = parseStakeEvent(template.template, receipt.logs);
+        if (!result) {
+            throw new UnableParseStakeEvent();
+        }
+        return c.json(result, 200);
+    });
+}
+class UnableParseStakeEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse stake transaction. Make sure you're passing transaction that is generated by \`stake\` action`,
+            name: "UnableParseStakeEvent",
+        });
+    }
+}

package/dist/staking-templates/templates/common/lock.d.ts

@@ -0,0 +1,12 @@
+import { z } from "../../../common/zod.js";
+export declare const LockTwoBorderSchema: z.ZodObject<{
+    minAcceptedLockPeriod: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    maxAcceptedLockPeriod: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+}, "strip", z.ZodTypeAny, {
+    minAcceptedLockPeriod: bigint;
+    maxAcceptedLockPeriod: bigint;
+}, {
+    minAcceptedLockPeriod: string | number | bigint;
+    maxAcceptedLockPeriod: string | number | bigint;
+}>;
+//# sourceMappingURL=lock.d.ts.map

package/dist/staking-templates/templates/common/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAG3C,eAAO,MAAM,mBAAmB;;;;;;;;;EAiB5B,CAAC"}

package/dist/staking-templates/templates/common/lock.js

@@ -0,0 +1,20 @@
+import { z } from "../../../common/zod.js";
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+export const LockTwoBorderSchema = z
+    .object({
+    minAcceptedLockPeriod: Int256Positive.openapi({
+        description: `The minimum required time duration (in seconds), that staked assets must 
+      be locked when the positions are either created (stake) or increased (restake).
+      \n\n
+      Note: Must be less than or equal to maxAcceptedLockPeriod.`,
+    }),
+    maxAcceptedLockPeriod: Int256Positive.openapi({
+        description: `The maximum allowed time duration (in seconds), that staked assets can be 
+      locked when the positions are either created (stake) or increased (restake).
+      \n\n
+      Note: Must be greater than 0 (if no upper limit is required, use max int 256).`,
+    }),
+})
+    .openapi({
+    ref: "LockTwoBorder",
+});

package/dist/staking-templates/templates/common/lockMult.d.ts

@@ -0,0 +1,3 @@
+import { z } from "../../../common/zod.js";
+export declare const LockMultIntervalSchema: z.ZodArray<z.ZodTuple<[z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>, z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>], null>, "many">;
+//# sourceMappingURL=lockMult.d.ts.map

package/dist/staking-templates/templates/common/lockMult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockMult.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/lockMult.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAG3C,eAAO,MAAM,sBAAsB,0MAYjC,CAAC"}

package/dist/staking-templates/templates/common/lockMult.js

@@ -0,0 +1,15 @@
+import { z } from "../../../common/zod.js";
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+export const LockMultIntervalSchema = z.array(z.tuple([Int256Positive, Int256Positive])).openapi({
+    ref: "LockMultInterval",
+    description: `An array of tuples where:
+    
+    1st element: A time duration (in seconds) defining lock duration thresholds for lock-based multipliers.
+    2nd element: A respective multiplier values for each threshold.
+    Example: If lockPeriods = [[100, 2], [300, 4]]
+    
+    A position with lock duration less than 100 seconds will receive a lock multiplier of 1 (no multiplier).
+    A position with lock duration between 100 and 299 seconds will receive a lock multiplier of 2.
+    A position with lock duration 300 seconds or more will receive a lock multiplier of 4.
+    `,
+});