@evergonlabs/tmi-protocol-api 0.8.1 → 0.10.0-rc.0

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

@@ -1 +0,0 @@
-{"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

@@ -1,18 +0,0 @@
-import { createApiConfig } from "../common/app.js";
-import { createReputationTemplateApp } from "./templates/reputation/index.js";
-import { createReputationLockTemplateApp } from "./templates/reputationLock/index.js";
-import { createRWATemplateApp } from "./templates/rwa/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

@@ -1,7 +0,0 @@
-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/staking-templates/templates/common/amount.d.ts.map

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

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

@@ -1,15 +0,0 @@
-import { Int256BigInt } from "../../../common/int256.js";
-import { z } from "zod";
-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/staking-templates/templates/common/amountMult.d.ts

@@ -1,3 +0,0 @@
-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/staking-templates/templates/common/amountMult.d.ts.map

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

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

@@ -1,22 +0,0 @@
-import { Int256BigInt } from "../../../common/int256.js";
-import { z } from "zod";
-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/staking-templates/templates/common/erc20Input.d.ts

@@ -1,6 +0,0 @@
-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/staking-templates/templates/common/erc20Input.d.ts.map

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

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

@@ -1,14 +0,0 @@
-import { AddressSchema } from "../../../common/index.js";
-import { Int256BigInt } from "../../../common/int256.js";
-import { z } from "zod";
-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/staking-templates/templates/common/erc20Reward.d.ts

@@ -1,6 +0,0 @@
-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/staking-templates/templates/common/erc20Reward.d.ts.map

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

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

@@ -1,13 +0,0 @@
-import { AddressSchema } from "../../../common/index.js";
-import { Int256BigInt } from "../../../common/int256.js";
-import { z } from "zod";
-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/staking-templates/templates/common/getCreatePoolEvent.d.ts

@@ -1,31 +0,0 @@
-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: 1 | 11155111 | 31337 | 72080;
-            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: 1 | 11155111 | 31337 | 72080;
-            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

@@ -1 +0,0 @@
-{"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;AASvC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,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

@@ -1,47 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { waitForTransactionReceipt } from "viem/actions";
-import { parseAssetManagersDeployEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
-import { getPublicClient } from "../../../common/blockchain.js";
-import { HttpError } from "../../../common/http-error.js";
-import { AddressSchema, PoolIdSchema, SentTransactionParamsSchema } from "../../../common/index.js";
-import { z } from "zod";
-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

@@ -1,40 +0,0 @@
-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: 1 | 11155111 | 31337 | 72080;
-            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: 1 | 11155111 | 31337 | 72080;
-            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

@@ -1 +0,0 @@
-{"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

@@ -1,46 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { waitForTransactionReceipt } from "viem/actions";
-import { parseDeployDiamondEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
-import { getPublicClient } from "../../../common/blockchain.js";
-import { HttpError } from "../../../common/http-error.js";
-import { AddressSchema, SentTransactionParamsSchema } from "../../../common/index.js";
-import { z } from "zod";
-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

@@ -1,58 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-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: string;
-            stakeId: string;
-        };
-    };
-    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: string;
-            stakeId: string;
-        };
-    };
-    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

@@ -1 +0,0 @@
-{"version":3,"file":"getReward.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getReward.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAMvC,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

@@ -1,34 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { getReward } from "@evergonlabs/tmi-protocol-staking-sdk";
-import { PlatformContractAddress, StakeIdSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
-import { z } from "zod";
-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

@@ -1,31 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-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: 1 | 11155111 | 31337 | 72080;
-            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: 1 | 11155111 | 31337 | 72080;
-            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

@@ -1 +0,0 @@
-{"version":3,"file":"getStakeEvent.d.ts","sourceRoot":"","sources":["../../../../src/staking-templates/templates/common/getStakeEvent.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,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

@@ -1,51 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { waitForTransactionReceipt } from "viem/actions";
-import { parseStakeEvent } from "@evergonlabs/tmi-protocol-staking-sdk";
-import { getPublicClient } from "../../../common/blockchain.js";
-import { HttpError } from "../../../common/http-error.js";
-import { AddressSchema, PoolIdSchema, SentTransactionParamsSchema, StakeIdSchema } from "../../../common/index.js";
-import { z } from "zod";
-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

@@ -1,6 +0,0 @@
-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/staking-templates/templates/common/lock.d.ts.map

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

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

@@ -1,18 +0,0 @@
-import { Int256BigInt } from "../../../common/int256.js";
-import { z } from "zod";
-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/staking-templates/templates/common/lockMult.d.ts

@@ -1,3 +0,0 @@
-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/staking-templates/templates/common/lockMult.d.ts.map

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

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

@@ -1,14 +0,0 @@
-import { Int256BigInt } from "../../../common/int256.js";
-import { z } from "zod";
-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/staking-templates/templates/common/partialUnstake.d.ts

@@ -1,62 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { ITemplateHelper } from "./templates.js";
-export declare function createPartialUnstakeRoute<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: string;
-            stakeId: string;
-            amount: string;
-        };
-    };
-    out: {
-        json: {
-            platform: `0x${string}`;
-            stakeId: bigint;
-            amount: 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: string;
-            stakeId: string;
-            amount: string;
-        };
-    };
-    out: {
-        json: {
-            platform: `0x${string}`;
-            stakeId: bigint;
-            amount: 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=partialUnstake.d.ts.map

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

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