@evergonlabs/tmi-protocol-api 0.2.1 → 0.4.0

package/dist/src/staking-templates/templates/reputationLock/v0/createPool.d.ts

@@ -0,0 +1,149 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+export declare function createCreatePoolRoute<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            platform: `0x${string}`;
+            amount: {
+                minAmount: string | number | bigint;
+                maxAmount: string | number | bigint;
+            };
+            startDate: string;
+            distribution: {
+                duration: string | number | bigint;
+                distributor: `0x${string}`;
+            };
+            amountMult: [string | number | bigint, string | number | bigint][];
+            stakingErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: string;
+            };
+            rewardErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: string | number | bigint;
+            };
+            rate: string | number | bigint;
+            lock: {
+                minAcceptedLockPeriod: string | number | bigint;
+                maxAcceptedLockPeriod: string | number | bigint;
+            };
+            lockMult: [string | number | bigint, string | number | bigint][];
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            amount: {
+                minAmount: bigint;
+                maxAmount: bigint;
+            };
+            startDate: string;
+            distribution: {
+                duration: bigint;
+                distributor: `0x${string}`;
+            };
+            amountMult: [bigint, bigint][];
+            stakingErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: bigint;
+            };
+            rewardErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: bigint;
+            };
+            rate: bigint;
+            lock: {
+                minAcceptedLockPeriod: bigint;
+                maxAcceptedLockPeriod: bigint;
+            };
+            lockMult: [bigint, bigint][];
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            platform: `0x${string}`;
+            amount: {
+                minAmount: string | number | bigint;
+                maxAmount: string | number | bigint;
+            };
+            startDate: string;
+            distribution: {
+                duration: string | number | bigint;
+                distributor: `0x${string}`;
+            };
+            amountMult: [string | number | bigint, string | number | bigint][];
+            stakingErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: string;
+            };
+            rewardErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: string | number | bigint;
+            };
+            rate: string | number | bigint;
+            lock: {
+                minAcceptedLockPeriod: string | number | bigint;
+                maxAcceptedLockPeriod: string | number | bigint;
+            };
+            lockMult: [string | number | bigint, string | number | bigint][];
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            amount: {
+                minAmount: bigint;
+                maxAmount: bigint;
+            };
+            startDate: string;
+            distribution: {
+                duration: bigint;
+                distributor: `0x${string}`;
+            };
+            amountMult: [bigint, bigint][];
+            stakingErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: bigint;
+            };
+            rewardErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: bigint;
+            };
+            rate: bigint;
+            lock: {
+                minAcceptedLockPeriod: bigint;
+                maxAcceptedLockPeriod: bigint;
+            };
+            lockMult: [bigint, 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=createPool.d.ts.map

package/dist/src/staking-templates/templates/reputationLock/v0/createPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPool.d.ts","sourceRoot":"","sources":["../../../../../../src/staking-templates/templates/reputationLock/v0/createPool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAiB3B,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA2FvE"}

package/dist/src/staking-templates/templates/reputationLock/v0/createPool.js

@@ -0,0 +1,99 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { createPool, FacetOptionEnum, FacetSlot } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { PlatformContractAddress } from "../../../../common/models/platform.js";
+import { reputationLock } from "../common.js";
+import { RewardDistributionComplexSchema, RewardRateSchema } from "../../common/rewardDistribution.js";
+import { Erc20InputSchema } from "../../common/erc20Input.js";
+import { Erc20RewardSchema } from "../../common/erc20Reward.js";
+import { AmountTwoBorderSchema } from "../../common/amount.js";
+import { StartTimeSchema } from "../../common/time.js";
+import { AmountMultIntervalSchema } from "../../common/amountMult.js";
+import { LockTwoBorderSchema } from "../../common/lock.js";
+import { LockMultIntervalSchema } from "../../common/lockMult.js";
+import { z } from "../../../../common/zod.js";
+export function createCreatePoolRoute(factory) {
+    return factory.createHandlers(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/src/staking-templates/templates/reputationLock/v0/index.d.ts

@@ -0,0 +1,244 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createReputationLockTemplateV0App<E extends Env>(factory: Factory<E>): import("hono/hono-base").HonoBase<E, {
+    "/getPlatformDeployEvent": {
+        $get: {
+            input: {
+                query: {
+                    chainId: "11155111" | "31337";
+                    hash: `0x${string}`;
+                };
+            };
+            output: {
+                diamondAddress: `0x${string}`;
+                admin: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/getStakeEvent": {
+        $get: {
+            input: {
+                query: {
+                    chainId: "11155111" | "31337";
+                    hash: `0x${string}`;
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/getCreatePoolEvent": {
+        $get: {
+            input: {
+                query: {
+                    chainId: "11155111" | "31337";
+                    hash: `0x${string}`;
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/getReward": {
+        $post: {
+            input: {
+                json: {
+                    platform: `0x${string}`;
+                    stakeId: string | number | bigint;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/partialUnstake": {
+        $post: {
+            input: {
+                json: {
+                    platform: `0x${string}`;
+                    stakeId: string | number | bigint;
+                    amount: string | number | bigint;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/restake": {
+        $post: {
+            input: {
+                json: {
+                    platform: `0x${string}`;
+                    poolId: string | number | bigint;
+                    amount: string | number | bigint;
+                    lockPeriod: string | number | bigint;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/stake": {
+        $post: {
+            input: {
+                json: {
+                    platform: `0x${string}`;
+                    poolId: string | number | bigint;
+                    amount: string | number | bigint;
+                    lockPeriod: string | number | bigint;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/unstake": {
+        $post: {
+            input: {
+                json: {
+                    platform: `0x${string}`;
+                    stakeId: string | number | bigint;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/createPool": {
+        $post: {
+            input: {
+                json: {
+                    platform: `0x${string}`;
+                    amount: {
+                        minAmount: string | number | bigint;
+                        maxAmount: string | number | bigint;
+                    };
+                    startDate: string;
+                    distribution: {
+                        duration: string | number | bigint;
+                        distributor: `0x${string}`;
+                    };
+                    amountMult: [string | number | bigint, string | number | bigint][];
+                    stakingErc20: {
+                        contract: `0x${string}`;
+                        amountOfTokensPerPacket: string;
+                    };
+                    rewardErc20: {
+                        contract: `0x${string}`;
+                        amountOfTokensPerPacket: string | number | bigint;
+                    };
+                    rate: string | number | bigint;
+                    lock: {
+                        minAcceptedLockPeriod: string | number | bigint;
+                        maxAcceptedLockPeriod: string | number | bigint;
+                    };
+                    lockMult: [string | number | bigint, string | number | bigint][];
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/createPlatform": {
+        $post: {
+            input: {
+                json: {
+                    chainId: "11155111" | "31337";
+                    adminAddress: `0x${string}`;
+                    erc721: {
+                        symbol: string;
+                        name: string;
+                        baseUri: string;
+                    };
+                    isSoulbound: boolean;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/staking-templates/templates/reputationLock/v0/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/staking-templates/templates/reputationLock/v0/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAavC,wBAAgB,iCAAiC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAanF"}

package/dist/src/staking-templates/templates/reputationLock/v0/index.js

@@ -0,0 +1,25 @@
+import { createGetPlatformDeployEventRoute } from "../../common/getPlatformDeployEvent.js";
+import { createGetRewardRoute } from "../../common/getReward.js";
+import { createStakeEventRoute } from "../../common/getStakeEvent.js";
+import { createPartialUnstakeRoute } from "../../common/partialUnstake.js";
+import { createRestakeRoute } from "./restake.js";
+import { createStakeRoute } from "./stake.js";
+import { reputationLock } from "../common.js";
+import { createUnstakeRoute } from "../../common/unstake.js";
+import { createGetCreatePoolEventRoute } from "../../common/getCreatePoolEvent.js";
+import { createCreatePoolRoute } from "./createPool.js";
+import { createCreatePlatformRoute } from "./createPlatform.js";
+export function createReputationLockTemplateV0App(factory) {
+    return factory
+        .createApp()
+        .get("/getPlatformDeployEvent", ...createGetPlatformDeployEventRoute(factory, reputationLock))
+        .get("/getStakeEvent", ...createStakeEventRoute(factory, reputationLock))
+        .get("/getCreatePoolEvent", ...createGetCreatePoolEventRoute(factory, reputationLock))
+        .post("/getReward", ...createGetRewardRoute(factory, reputationLock))
+        .post("/partialUnstake", ...createPartialUnstakeRoute(factory, reputationLock))
+        .post("/restake", ...createRestakeRoute(factory))
+        .post("/stake", ...createStakeRoute(factory))
+        .post("/unstake", ...createUnstakeRoute(factory, reputationLock))
+        .post("/createPool", ...createCreatePoolRoute(factory))
+        .post("/createPlatform", ...createCreatePlatformRoute(factory));
+}

package/dist/src/staking-templates/templates/reputationLock/v0/restake.d.ts

@@ -0,0 +1,65 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createRestakeRoute<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            platform: `0x${string}`;
+            poolId: string | number | bigint;
+            amount: string | number | bigint;
+            lockPeriod: string | number | bigint;
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            poolId: bigint;
+            amount: bigint;
+            lockPeriod: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            platform: `0x${string}`;
+            poolId: string | number | bigint;
+            amount: string | number | bigint;
+            lockPeriod: string | number | bigint;
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            poolId: bigint;
+            amount: bigint;
+            lockPeriod: 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=restake.d.ts.map

package/dist/src/staking-templates/templates/reputationLock/v0/restake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restake.d.ts","sourceRoot":"","sources":["../../../../../../src/staking-templates/templates/reputationLock/v0/restake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA2CpE"}

package/dist/src/staking-templates/templates/reputationLock/v0/restake.js

@@ -0,0 +1,44 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { stake } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { z } from "../../../../common/zod.js";
+import { PlatformContractAddress, PoolIdSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { reputationLock } from "../common.js";
+export function createRestakeRoute(factory) {
+    return factory.createHandlers(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: Int256Positive.openapi({
+            description: `Number of Packets to be stacked. Each underlying asset must be approved to Staking Platform contract instance`,
+        }),
+        lockPeriod: Int256Positive.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);
+    });
+}