@evergonlabs/tmi-protocol-api 0.1.3 → 0.1.4

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

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

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

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

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

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

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

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

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

@@ -1,44 +0,0 @@
-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);
-    });
-}