@evergonlabs/tmi-protocol-api 0.1.0

package/dist/staking-templates/templates/reputation/v0/createPlatform.d.ts

@@ -0,0 +1,81 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createCreatePlatformRoute<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: {
+            chainId: "11155111" | "31337";
+            adminAddress: `0x${string}`;
+            erc721: {
+                symbol: string;
+                name: string;
+                baseUri: string;
+            };
+            isSoulbound: boolean;
+        };
+    };
+    out: {
+        json: {
+            chainId: "11155111" | "31337";
+            adminAddress: `0x${string}`;
+            erc721: {
+                symbol: string;
+                name: string;
+                baseUri: string;
+            };
+            isSoulbound: boolean;
+        };
+    };
+}, 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: {
+            chainId: "11155111" | "31337";
+            adminAddress: `0x${string}`;
+            erc721: {
+                symbol: string;
+                name: string;
+                baseUri: string;
+            };
+            isSoulbound: boolean;
+        };
+    };
+    out: {
+        json: {
+            chainId: "11155111" | "31337";
+            adminAddress: `0x${string}`;
+            erc721: {
+                symbol: string;
+                name: string;
+                baseUri: string;
+            };
+            isSoulbound: boolean;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, 200, "json">>>];
+//# sourceMappingURL=createPlatform.d.ts.map

package/dist/staking-templates/templates/reputation/v0/createPlatform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPlatform.d.ts","sourceRoot":"","sources":["../../../../../src/staking-templates/templates/reputation/v0/createPlatform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAUvC,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsD3E"}

package/dist/staking-templates/templates/reputation/v0/createPlatform.js

@@ -0,0 +1,56 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { FacetSlot } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { createPlatform, FacetOptionEnum } from "@evergonlabs/tmi-protocol-staking-sdk";
+import { z } from "../../../../common/zod.js";
+import { AddressSchema, StakingChainId, toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { reputation } from "../common.js";
+import { Erc721Schema } from "../../../../common/models/erc721.js";
+export function createCreatePlatformRoute(factory) {
+    return factory.createHandlers(describeRoute({
+        summary: "Create Platform",
+        description: "Generates a transaction for a new Platform",
+        tags: [reputation.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(reputation.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/staking-templates/templates/reputation/v0/createPool.d.ts

@@ -0,0 +1,113 @@
+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}`;
+            startDate: string;
+            amount: {
+                minAmount: string | number | bigint;
+                maxAmount: string | number | bigint;
+            };
+            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;
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            startDate: string;
+            amount: {
+                minAmount: bigint;
+                maxAmount: bigint;
+            };
+            amountMult: [bigint, bigint][];
+            stakingErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: bigint;
+            };
+            rewardErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: bigint;
+            };
+            rate: 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}`;
+            startDate: string;
+            amount: {
+                minAmount: string | number | bigint;
+                maxAmount: string | number | bigint;
+            };
+            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;
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            startDate: string;
+            amount: {
+                minAmount: bigint;
+                maxAmount: bigint;
+            };
+            amountMult: [bigint, bigint][];
+            stakingErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: bigint;
+            };
+            rewardErc20: {
+                contract: `0x${string}`;
+                amountOfTokensPerPacket: bigint;
+            };
+            rate: 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/staking-templates/templates/reputation/v0/createPool.d.ts.map

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

package/dist/staking-templates/templates/reputation/v0/createPool.js

@@ -0,0 +1,85 @@
+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 { z } from "../../../../common/zod.js";
+import { PlatformContractAddress } from "../../../../common/models/platform.js";
+import { reputation } from "../common.js";
+import { 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";
+export function createCreatePoolRoute(factory) {
+    return factory.createHandlers(describeRoute({
+        summary: "Create Pool",
+        description: "Generates a transaction for a new Staking Pool within the Platform",
+        tags: [reputation.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,
+        stakingErc20: Erc20InputSchema,
+        rewardErc20: Erc20RewardSchema,
+        rate: RewardRateSchema,
+    })), async (c) => {
+        const { platform, startDate, amountMult, amount, rate, stakingErc20, rewardErc20 } = c.req.valid("json");
+        const deployed = createPool(reputation.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.RewardDistributionRateBasedOpen,
+                    campaignRate: rate,
+                },
+                [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/staking-templates/templates/reputation/v0/index.d.ts

@@ -0,0 +1,233 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createReputationTemplateV0App<E extends Env>(factory: Factory<E>): import("hono/hono-base").HonoBase<E, {
+    "/getPlatformDeployEvent": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                diamondAddress: `0x${string}`;
+                admin: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/getStakeEvent": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/getCreatePoolEvent": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | 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;
+                };
+            };
+            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;
+                };
+            };
+            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}`;
+                    startDate: string;
+                    amount: {
+                        minAmount: string | number | bigint;
+                        maxAmount: string | number | bigint;
+                    };
+                    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;
+                };
+            };
+            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/staking-templates/templates/reputation/v0/index.d.ts.map

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

package/dist/staking-templates/templates/reputation/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 { reputation } 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 createReputationTemplateV0App(factory) {
+    return factory
+        .createApp()
+        .get("/getPlatformDeployEvent", ...createGetPlatformDeployEventRoute(factory, reputation))
+        .get("/getStakeEvent", ...createStakeEventRoute(factory, reputation))
+        .get("/getCreatePoolEvent", ...createGetCreatePoolEventRoute(factory, reputation))
+        .post("/getReward", ...createGetRewardRoute(factory, reputation))
+        .post("/partialUnstake", ...createPartialUnstakeRoute(factory, reputation))
+        .post("/restake", ...createRestakeRoute(factory))
+        .post("/stake", ...createStakeRoute(factory))
+        .post("/unstake", ...createUnstakeRoute(factory, reputation))
+        .post("/createPool", ...createCreatePoolRoute(factory))
+        .post("/createPlatform", ...createCreatePlatformRoute(factory));
+}

package/dist/staking-templates/templates/reputation/v0/restake.d.ts

@@ -0,0 +1,61 @@
+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;
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            poolId: 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: `0x${string}`;
+            poolId: string | number | bigint;
+            amount: string | number | bigint;
+        };
+    };
+    out: {
+        json: {
+            platform: `0x${string}`;
+            poolId: 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=restake.d.ts.map

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

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