@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

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

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

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

@@ -0,0 +1,5 @@
+import { createController } from "../../../common/controller.js";
+import { ReputationLockTemplateV0 } from "./v0/index.js";
+export const ReputationLockTemplateController = createController({
+    build: (factory) => factory.createApp().route("/v0", ReputationLockTemplateV0.build(factory)),
+});

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

@@ -0,0 +1,31 @@
+export declare const CreateReputationLockPlatformV0: import("../../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    erc721: {
+                        symbol: string;
+                        name: string;
+                        baseUri: string;
+                    };
+                    isSoulbound: boolean;
+                    adminAddress: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=createPlatform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPlatform.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/reputationLock/v0/createPlatform.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAwDzC,CAAC"}

package/dist/stakingTemplates/templates/reputationLock/v0/createPlatform.js

@@ -0,0 +1,57 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { FacetSlot } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { createPlatform, FacetOptionEnum } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { createController } from "../../../../common/controller.js";
+import { AddressSchema, StakingChainId, toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { Erc721Schema } from "../../../../common/models/erc721.js";
+import { reputationLock } from "../common.js";
+export const CreateReputationLockPlatformV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Create Platform",
+        description: "Generates a transaction for a new Platform",
+        tags: [reputationLock.tag.tag],
+        responses: {
+            200: {
+                description: "Compiled Create Platform transaction details",
+                content: {
+                    "application/json": {
+                        schema: resolver(TransactionSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        chainId: StakingChainId.openapi({
+            description: "Id of targeted chain",
+        }),
+        erc721: Erc721Schema.openapi({
+            description: "Details of the NFT that is going to be minted for user to track it's stake",
+        }),
+        isSoulbound: z.boolean().openapi({
+            description: "Whether NFT can be transferred to other wallet (secondary market the stake)",
+        }),
+        adminAddress: AddressSchema.openapi({
+            description: "Grant admin role to speficied address",
+        }),
+    })), async (c) => {
+        const { chainId, erc721, isSoulbound, adminAddress } = c.req.valid("json");
+        const deployed = createPlatform(reputationLock.template, {
+            chainId: chainId,
+            admin: adminAddress,
+            data: {
+                [FacetSlot.Erc721]: {
+                    type: FacetOptionEnum.Erc721Default,
+                    isSoulbound: isSoulbound,
+                    erc721: {
+                        symbol: erc721.symbol,
+                        name: erc721.name,
+                        baseUri: erc721.baseUri,
+                    },
+                },
+            },
+        });
+        return c.json(toTransaction(deployed), 200);
+    }),
+});

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

@@ -0,0 +1,48 @@
+export declare const CreateReputationLockPoolV0: import("../../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    startDate: string;
+                    amount: {
+                        minAmount: string;
+                        maxAmount: string;
+                    };
+                    amountMult: [string, string][];
+                    distribution: {
+                        duration: string;
+                        distributor: string;
+                    };
+                    stakingErc20: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    rewardErc20: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    rate: string;
+                    lock: {
+                        minAcceptedLockPeriod: string;
+                        maxAcceptedLockPeriod: string;
+                    };
+                    lockMult: [string, string][];
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=createPool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPool.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/reputationLock/v0/createPool.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6FrC,CAAC"}

package/dist/stakingTemplates/templates/reputationLock/v0/createPool.js

@@ -0,0 +1,100 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { createPool, FacetOptionEnum, FacetSlot } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { createController } from "../../../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { PlatformContractAddress } from "../../../../common/models/platform.js";
+import { AmountTwoBorderSchema } from "../../common/amount.js";
+import { AmountMultIntervalSchema } from "../../common/amountMult.js";
+import { Erc20InputSchema } from "../../common/erc20Input.js";
+import { Erc20RewardSchema } from "../../common/erc20Reward.js";
+import { LockTwoBorderSchema } from "../../common/lock.js";
+import { LockMultIntervalSchema } from "../../common/lockMult.js";
+import { RewardDistributionComplexSchema, RewardRateSchema } from "../../common/rewardDistribution.js";
+import { StartTimeSchema } from "../../common/time.js";
+import { reputationLock } from "../common.js";
+export const CreateReputationLockPoolV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Create Pool",
+        description: "Generates a transaction for a new Staking Pool within the Platform",
+        tags: [reputationLock.tag.tag],
+        responses: {
+            200: {
+                description: "Compiled Create Pool transaction details",
+                content: {
+                    "application/json": {
+                        schema: resolver(TransactionSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        platform: PlatformContractAddress,
+        startDate: StartTimeSchema,
+        amount: AmountTwoBorderSchema,
+        amountMult: AmountMultIntervalSchema,
+        distribution: RewardDistributionComplexSchema,
+        stakingErc20: Erc20InputSchema,
+        rewardErc20: Erc20RewardSchema,
+        rate: RewardRateSchema,
+        lock: LockTwoBorderSchema,
+        lockMult: LockMultIntervalSchema,
+    })), async (c) => {
+        const { platform, startDate, amountMult, amount, lock, lockMult, rate, stakingErc20, rewardErc20 } = c.req.valid("json");
+        const deployed = createPool(reputationLock.template, {
+            platform: platform,
+            data: {
+                [FacetSlot.Time]: {
+                    type: FacetOptionEnum.TimeOnlyStarting,
+                    startDate: new Date(startDate),
+                },
+                [FacetSlot.AmountMult]: {
+                    type: FacetOptionEnum.AmountMultInterval,
+                    packetsAndMultipliers: amountMult,
+                },
+                [FacetSlot.Amount]: {
+                    type: FacetOptionEnum.AmountTwoBorder,
+                    minAmount: amount.minAmount,
+                    maxAmount: amount.maxAmount,
+                },
+                [FacetSlot.StakersEligibility]: {
+                    type: FacetOptionEnum.StakersEligibilityDefault,
+                    isCampaignScoped: false,
+                },
+                [FacetSlot.RewardsDistribution]: {
+                    type: FacetOptionEnum.RewardDistributionRateBasedLock,
+                    campaignRate: rate,
+                },
+                [FacetSlot.Lock]: {
+                    type: FacetOptionEnum.LockTwoBorder,
+                    minAcceptedLockPeriod: lock.minAcceptedLockPeriod,
+                    maxAcceptedLockPeriod: lock.maxAcceptedLockPeriod,
+                },
+                [FacetSlot.LockMult]: {
+                    type: FacetOptionEnum.LockMultInterval,
+                    lockPeriods: lockMult,
+                },
+                [FacetSlot.Input]: {
+                    type: FacetOptionEnum.InputErc20,
+                    entries: [
+                        {
+                            tokenAddress: stakingErc20.contract,
+                            amountOfTokensPerPacket: stakingErc20.amountOfTokensPerPacket,
+                        },
+                    ],
+                },
+                [FacetSlot.Reward]: {
+                    type: FacetOptionEnum.RewardErc20Minter,
+                    entries: [
+                        {
+                            tokenAddress: rewardErc20.contract,
+                            amountOfTokensPerPacket: rewardErc20.amountOfTokensPerPacket,
+                        },
+                    ],
+                },
+            },
+        });
+        return c.json(toTransaction(deployed), 200);
+    }),
+});

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

@@ -0,0 +1,242 @@
+export declare const ReputationLockTemplateV0: import("../../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                diamondAddress: `0x${string}`;
+                admin: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/getPlatformDeployEvent"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/getStakeEvent"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/getCreatePoolEvent"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $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;
+        };
+    };
+}, "/getReward"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $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;
+        };
+    };
+}, "/partialUnstake"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $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;
+        };
+    };
+}, "/unstake"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    poolId: string;
+                    amount: string;
+                    lockPeriod: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/restake"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    poolId: string;
+                    amount: string;
+                    lockPeriod: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/stake"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    startDate: string;
+                    amount: {
+                        minAmount: string;
+                        maxAmount: string;
+                    };
+                    amountMult: [string, string][];
+                    distribution: {
+                        duration: string;
+                        distributor: string;
+                    };
+                    stakingErc20: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    rewardErc20: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    rate: string;
+                    lock: {
+                        minAcceptedLockPeriod: string;
+                        maxAcceptedLockPeriod: string;
+                    };
+                    lockMult: [string, string][];
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/createPool"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    erc721: {
+                        symbol: string;
+                        name: string;
+                        baseUri: string;
+                    };
+                    isSoulbound: boolean;
+                    adminAddress: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/createPlatform">, "/">>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/reputationLock/v0/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAcnC,CAAC"}

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

@@ -0,0 +1,26 @@
+import { createController } from "../../../../common/controller.js";
+import { createGetCreatePoolEventController } from "../../common/getCreatePoolEvent.js";
+import { createGetPlatformDeployEventController } from "../../common/getPlatformDeployEvent.js";
+import { createGetRewardController } from "../../common/getReward.js";
+import { createGetStakeEventController } from "../../common/getStakeEvent.js";
+import { createPartialUnstakeController } from "../../common/partialUnstake.js";
+import { createUnstakeController } from "../../common/unstake.js";
+import { reputationLock } from "../common.js";
+import { CreateReputationLockPlatformV0 } from "./createPlatform.js";
+import { CreateReputationLockPoolV0 } from "./createPool.js";
+import { RestakeReputationLockV0 } from "./restake.js";
+import { StakeReputationLockV0 } from "./stake.js";
+export const ReputationLockTemplateV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/getPlatformDeployEvent", createGetPlatformDeployEventController(reputationLock).build(factory))
+        .route("/getStakeEvent", createGetStakeEventController(reputationLock).build(factory))
+        .route("/getCreatePoolEvent", createGetCreatePoolEventController(reputationLock).build(factory))
+        .route("/getReward", createGetRewardController(reputationLock).build(factory))
+        .route("/partialUnstake", createPartialUnstakeController(reputationLock).build(factory))
+        .route("/restake", RestakeReputationLockV0.build(factory))
+        .route("/stake", StakeReputationLockV0.build(factory))
+        .route("/unstake", createUnstakeController(reputationLock).build(factory))
+        .route("/createPool", CreateReputationLockPoolV0.build(factory))
+        .route("/createPlatform", CreateReputationLockPlatformV0.build(factory)),
+});

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

@@ -0,0 +1,27 @@
+export declare const RestakeReputationLockV0: import("../../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    poolId: string;
+                    amount: string;
+                    lockPeriod: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=restake.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"restake.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/reputationLock/v0/restake.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;QA6ClC,CAAC"}

package/dist/stakingTemplates/templates/reputationLock/v0/restake.js

@@ -0,0 +1,45 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { stake } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { createController } from "../../../../common/controller.js";
+import { PlatformContractAddress, PoolIdSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { Int256BigInt } from "../../../../common/int256.js";
+import { reputationLock } from "../common.js";
+export const RestakeReputationLockV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Restake",
+        description: "Generates a transaction for updating staking position",
+        tags: [reputationLock.tag.tag],
+        responses: {
+            200: {
+                description: "Get the Stake transaction details",
+                content: {
+                    "application/json": {
+                        schema: resolver(TransactionSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        platform: PlatformContractAddress,
+        poolId: PoolIdSchema,
+        amount: Int256BigInt(z.bigint().positive()).openapi({
+            description: `Number of Packets to be stacked. Each underlying asset must be approved to Staking Platform contract instance`,
+        }),
+        lockPeriod: Int256BigInt(z.bigint().positive()).openapi({
+            description: "The duration, in seconds, during which the position's staked Packets will be locked.",
+        }),
+    })), async (c) => {
+        const { platform, poolId, amount, lockPeriod } = c.req.valid("json");
+        const deployed = stake(reputationLock.template, {
+            platform: platform,
+            data: {
+                poolId: poolId,
+                packets: amount,
+                lockPeriod: lockPeriod,
+            },
+        });
+        return c.json(toTransaction(deployed), 200);
+    }),
+});

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

@@ -0,0 +1,27 @@
+export declare const StakeReputationLockV0: import("../../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    poolId: string;
+                    amount: string;
+                    lockPeriod: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=stake.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stake.d.ts","sourceRoot":"","sources":["../../../../../src/stakingTemplates/templates/reputationLock/v0/stake.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;QA8ChC,CAAC"}