@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

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

@@ -0,0 +1,47 @@
+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, TransactionSchema } from "../../../../common/index.js";
+import { toTransaction } from "../../../../common/index.js";
+import { Int256BigInt } from "../../../../common/int256.js";
+import { reputationLock } from "../common.js";
+export const StakeReputationLockV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Stake",
+        description: "Generates a transaction for a new Stake position in specified Pool",
+        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({
+            example: "600",
+            description: "Lock period in Seconds",
+        }),
+    })), async (c) => {
+        const { platform, amount, poolId, 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/rwa/common.d.ts

@@ -0,0 +1,23 @@
+export declare const rwa: {
+    tag: {
+        tag: "RWA";
+    };
+    template: {
+        RewardsDistribution: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.RewardDistributionComplex;
+        StakeCreation: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.StakeCreationDefault;
+        PoolCreation: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.PoolCreationDefault;
+        Time: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.TimeOnlyStarting;
+        Amount: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.AmountHardCap;
+        CreatorsEligibility: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.CreatorsEligibilityDefault;
+        Erc721: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.Erc721Default;
+        Input: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.InputErc20;
+        Lock: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.LockAutoComplex;
+        LockMult: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.LockMultNoMultiplier;
+        Reward: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.RewardErc20Transfer;
+        StakersEligibility: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.StakersEligibilityDefault;
+        Withdrawal: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.WithdrawalLockChecker;
+        AmountMult: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.AmountMultNoMultiplier;
+        AccessControl: import("@evergonlabs/tmi-protocol-staking-sdk").FacetOptionEnum.AccessControlDefault;
+    };
+};
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/stakingTemplates/templates/rwa/common.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;CAA6C,CAAC"}

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

@@ -0,0 +1,3 @@
+import { TemplateEnum } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { getTemplateHelper } from "../common/templates.js";
+export const rwa = getTemplateHelper(TemplateEnum.RWA, "RWA");

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

@@ -0,0 +1,254 @@
+export declare const RwaTemplateController: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $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;
+                };
+            };
+            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;
+                };
+            };
+            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;
+                    hardcapAmount: string;
+                    distribution: {
+                        duration: string;
+                        distributor: string;
+                    };
+                    erc20Input: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    erc20Reward: {
+                        contract: string;
+                        amountOfTokensPerPacket: 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"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    poolId: string;
+                    amount: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/distributeRewards">, "/v0">, "/">>;
+//# sourceMappingURL=index.d.ts.map

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

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

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

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

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

@@ -0,0 +1,31 @@
+export declare const CreateRwaPlatformV0: 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/rwa/v0/createPlatform.d.ts.map

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

package/dist/stakingTemplates/templates/rwa/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 { rwa } from "../common.js";
+export const CreateRwaPlatformV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Create Platform",
+        description: "Generates a transaction for a new Platform",
+        tags: [rwa.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(rwa.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/rwa/v0/createPool.d.ts

@@ -0,0 +1,38 @@
+export declare const CreateRwaPoolV0: import("../../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    startDate: string;
+                    hardcapAmount: string;
+                    distribution: {
+                        duration: string;
+                        distributor: string;
+                    };
+                    erc20Input: {
+                        contract: string;
+                        amountOfTokensPerPacket: string;
+                    };
+                    erc20Reward: {
+                        contract: string;
+                        amountOfTokensPerPacket: 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/rwa/v0/createPool.d.ts.map

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

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

@@ -0,0 +1,80 @@
+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 { AmountHardCapSchema } from "../../common/amount.js";
+import { Erc20InputSchema } from "../../common/erc20Input.js";
+import { Erc20RewardSchema } from "../../common/erc20Reward.js";
+import { RewardDistributionComplexSchema } from "../../common/rewardDistribution.js";
+import { StartTimeSchema } from "../../common/time.js";
+import { rwa } from "../common.js";
+export const CreateRwaPoolV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Create Pool",
+        description: "Generates a transaction for a new Staking Pool within the Platform",
+        tags: [rwa.tag.tag],
+        responses: {
+            200: {
+                description: "Compiled Create Pool transaction details",
+                content: {
+                    "application/json": {
+                        schema: resolver(TransactionSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        platform: PlatformContractAddress,
+        startDate: StartTimeSchema,
+        hardcapAmount: AmountHardCapSchema,
+        distribution: RewardDistributionComplexSchema,
+        erc20Input: Erc20InputSchema,
+        erc20Reward: Erc20RewardSchema,
+    })), async (c) => {
+        const { platform, startDate, hardcapAmount, distribution, erc20Input, erc20Reward } = c.req.valid("json");
+        const deployed = createPool(rwa.template, {
+            platform: platform,
+            data: {
+                [FacetSlot.Time]: {
+                    type: FacetOptionEnum.TimeOnlyStarting,
+                    startDate: new Date(startDate),
+                },
+                [FacetSlot.Amount]: {
+                    type: FacetOptionEnum.AmountHardCap,
+                    hardCap: BigInt(hardcapAmount),
+                },
+                [FacetSlot.StakersEligibility]: {
+                    type: FacetOptionEnum.StakersEligibilityDefault,
+                    isCampaignScoped: false,
+                },
+                [FacetSlot.RewardsDistribution]: {
+                    type: FacetOptionEnum.RewardDistributionComplex,
+                    duration: distribution.duration,
+                    distributor: distribution.distributor,
+                },
+                [FacetSlot.Input]: {
+                    type: FacetOptionEnum.InputErc20,
+                    entries: [
+                        {
+                            tokenAddress: erc20Input.contract,
+                            amountOfTokensPerPacket: erc20Input.amountOfTokensPerPacket,
+                        },
+                    ],
+                },
+                [FacetSlot.Reward]: {
+                    type: FacetOptionEnum.RewardErc20Transfer,
+                    entries: [
+                        {
+                            tokenAddress: erc20Reward.contract,
+                            amountOfTokensPerPacket: erc20Reward.amountOfTokensPerPacket,
+                        },
+                    ],
+                },
+            },
+        });
+        return c.json(toTransaction(deployed), 200);
+    }),
+});

package/dist/stakingTemplates/templates/rwa/v0/distributeRewards.d.ts

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

package/dist/stakingTemplates/templates/rwa/v0/distributeRewards.d.ts.map

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

package/dist/stakingTemplates/templates/rwa/v0/distributeRewards.js

@@ -0,0 +1,42 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { distributeRewards } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { createController } from "../../../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { Int256BigInt } from "../../../../common/int256.js";
+import { PlatformContractAddress, PoolIdSchema } from "../../../../common/models/platform.js";
+import { rwa } from "../common.js";
+export const DistributeRewardsRwaV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Distribute Rewards",
+        description: "Generates a transaction for Rewards allocation for certain Pool.",
+        tags: [rwa.tag.tag],
+        responses: {
+            200: {
+                description: "Compiled Reward notification 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 Reward Packets to distribute to pool stakers.",
+        }),
+    })), async (c) => {
+        const { platform, poolId, amount } = c.req.valid("json");
+        const transaction = distributeRewards(rwa.template, {
+            platform: platform,
+            data: {
+                poolId: poolId,
+                packets: amount,
+            },
+        });
+        return c.json(toTransaction(transaction), 200);
+    }),
+});