@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

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

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

package/dist/stakingTemplates/index.js

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

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

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const AmountHardCapSchema: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+export declare const AmountTwoBorderSchema: z.ZodObject<{
+    minAmount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    maxAmount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+//# sourceMappingURL=amount.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"amount.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/amount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,mBAAmB,uHAE9B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;iBAWL,CAAC"}

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { Int256BigInt } from "../../../common/int256.js";
+export const AmountHardCapSchema = Int256BigInt(z.bigint().positive()).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: Int256BigInt(z.bigint().positive()).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: Int256BigInt(z.bigint().positive()).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("AmountTwoBorder");

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

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const AmountMultIntervalSchema: z.ZodArray<z.ZodTuple<[z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>, z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>], null>>;
+//# sourceMappingURL=amountMult.d.ts.map

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

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

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

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { Int256BigInt } from "../../../common/int256.js";
+export const AmountMultIntervalSchema = z
+    .array(z.tuple([Int256BigInt(z.bigint().positive()), Int256BigInt(z.bigint().positive())]))
+    .openapi("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/stakingTemplates/templates/common/erc20Input.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const Erc20InputSchema: 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.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+//# sourceMappingURL=erc20Input.d.ts.map

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const Erc20RewardSchema: 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.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+//# sourceMappingURL=erc20Reward.d.ts.map

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

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

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

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

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

@@ -0,0 +1,17 @@
+import { ITemplateHelper } from "./templates.js";
+export declare function createGetCreatePoolEventController(template: ITemplateHelper): import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=getCreatePoolEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getCreatePoolEvent.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getCreatePoolEvent.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,kCAAkC,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;SAwC3E"}

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

@@ -0,0 +1,51 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { waitForTransactionReceipt } from "viem/actions";
+import { z } from "zod";
+import { parseAssetManagersDeployEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { getPublicClient } from "../../../common/blockchain.js";
+import { createController } from "../../../common/controller.js";
+import { HttpError } from "../../../common/http-error.js";
+import { AddressSchema, SentTransactionParamsSchema } from "../../../common/index.js";
+export function createGetCreatePoolEventController(template) {
+    return createController({
+        build: (factory) => factory.createApp().get("/", 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: Int256Json.openapi({ description: "Id of a Pool", example: "1" }),
+                                rewardAssetHandler: AddressSchema,
+                                inputAssetKeeper: AddressSchema,
+                            })),
+                        },
+                    },
+                },
+            },
+        }), validator("query", SentTransactionParamsSchema), async (c) => {
+            const params = c.req.valid("query");
+            const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
+                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/stakingTemplates/templates/common/getPlatformDeployEvent.d.ts

@@ -0,0 +1,20 @@
+import { ITemplateHelper } from "./templates.js";
+export declare function createGetPlatformDeployEventController(template: ITemplateHelper): import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                diamondAddress: `0x${string}`;
+                admin: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=getPlatformDeployEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getPlatformDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getPlatformDeployEvent.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,sCAAsC,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;SAuC/E"}

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

@@ -0,0 +1,49 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { waitForTransactionReceipt } from "viem/actions";
+import { z } from "zod";
+import { parseDeployDiamondEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
+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 function createGetPlatformDeployEventController(template) {
+    return createController({
+        build: (factory) => factory.createApp().get("/", 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, c.env.config), {
+                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/stakingTemplates/templates/common/getReward.d.ts

@@ -0,0 +1,26 @@
+import { ITemplateHelper } from "./templates.js";
+export declare function createGetRewardController(template: ITemplateHelper): import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    stakeId: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=getReward.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getReward.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getReward.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;SAuClE"}

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

@@ -0,0 +1,37 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { getReward } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { createController } from "../../../common/controller.js";
+import { PlatformContractAddress, StakeIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+export function createGetRewardController(template) {
+    return createController({
+        build: (factory) => factory.createApp().post("/", 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/stakingTemplates/templates/common/getStakeEvent.d.ts

@@ -0,0 +1,17 @@
+import { ITemplateHelper } from "./templates.js";
+export declare function createGetStakeEventController(template: ITemplateHelper): import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=getStakeEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getStakeEvent.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/getStakeEvent.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;SA4CtE"}

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

@@ -0,0 +1,55 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { waitForTransactionReceipt } from "viem/actions";
+import { z } from "zod";
+import { parseStakeEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { getPublicClient } from "../../../common/blockchain.js";
+import { createController } from "../../../common/controller.js";
+import { HttpError } from "../../../common/http-error.js";
+import { AddressSchema, SentTransactionParamsSchema } from "../../../common/index.js";
+export function createGetStakeEventController(template) {
+    return createController({
+        build: (factory) => factory.createApp().get("/", 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: 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,
+                            })),
+                        },
+                    },
+                },
+            },
+        }), validator("query", SentTransactionParamsSchema), async (c) => {
+            const params = c.req.valid("query");
+            const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
+                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/stakingTemplates/templates/common/lock.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const LockTwoBorderSchema: z.ZodObject<{
+    minAcceptedLockPeriod: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    maxAcceptedLockPeriod: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+//# sourceMappingURL=lock.d.ts.map

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

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

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

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { Int256BigInt } from "../../../common/int256.js";
+export const LockTwoBorderSchema = z
+    .object({
+    minAcceptedLockPeriod: Int256BigInt(z.bigint().positive()).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: Int256BigInt(z.bigint().positive()).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("LockTwoBorder");

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

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const LockMultIntervalSchema: z.ZodArray<z.ZodTuple<[z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>, z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>], null>>;
+//# sourceMappingURL=lockMult.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lockMult.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/lockMult.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB,8QAa/B,CAAC"}

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

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { Int256BigInt } from "../../../common/int256.js";
+export const LockMultIntervalSchema = z
+    .array(z.tuple([Int256BigInt(z.bigint().positive()), Int256BigInt(z.bigint().positive())]))
+    .openapi("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.
+    `,
+});

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

@@ -0,0 +1,27 @@
+import { ITemplateHelper } from "./templates.js";
+export declare function createPartialUnstakeController(template: ITemplateHelper): import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    stakeId: 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=partialUnstake.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"partialUnstake.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/partialUnstake.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;SA2CvE"}

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

@@ -0,0 +1,42 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { partialUnstake } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { createController } from "../../../common/controller.js";
+import { PlatformContractAddress, StakeIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+export function createPartialUnstakeController(template) {
+    return createController({
+        build: (factory) => factory.createApp().post("/", describeRoute({
+            summary: "Partial Unstake",
+            description: `Generates a transaction for withdraw a portion of the staked assets and all accumulated rewards from an expired position.`,
+            tags: [template.tag.tag],
+            responses: {
+                200: {
+                    description: "Compiled Partial Unstake transaction details",
+                    content: {
+                        "application/json": {
+                            schema: resolver(TransactionSchema),
+                        },
+                    },
+                },
+            },
+        }), validator("json", z.object({
+            platform: PlatformContractAddress,
+            stakeId: StakeIdSchema,
+            amount: Int256BigInt(z.bigint().positive()).openapi({
+                description: `The number of input packets to withdraw from the position, thereby decreasing it.`,
+            }),
+        })), async (c) => {
+            const { platform, stakeId, amount } = c.req.valid("json");
+            const deployed = partialUnstake(template.template, {
+                platform: platform,
+                data: {
+                    stakeId: stakeId,
+                    amount: amount,
+                },
+            });
+            return c.json(toTransaction(deployed), 200);
+        }),
+    });
+}

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

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const RewardDistributionComplexSchema: z.ZodObject<{
+    duration: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    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>;
+export declare const RewardRateSchema: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+//# sourceMappingURL=rewardDistribution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rewardDistribution.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/common/rewardDistribution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,+BAA+B;;;iBAS+C,CAAC;AAE5F,eAAO,MAAM,gBAAgB,uHAE3B,CAAC"}

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

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { AddressSchema } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+export const RewardDistributionComplexSchema = z
+    .object({
+    duration: Int256BigInt(z.bigint().positive()).openapi({
+        description: `Duration applied for rewards to be fully distributed in seconds.\n\ne.g. if 5 minutes, rewards are expected to be fully distributed 5 minutes after the reward notification is successful`,
+    }),
+    distributor: AddressSchema.openapi({
+        description: `Wallet address that is configured as distributor of rewards\n\nThe distributor must approve asset-spending at each notification of rewards`,
+    }),
+})
+    .openapi("RewardDistributionComplex", { description: "Details of Rewards Distribution" });
+export const RewardRateSchema = Int256BigInt(z.bigint().positive()).openapi({
+    description: "Base campaign rate multiplier. How many Packets allocated to a Staker each second as a Reward",
+});