@evergonlabs/tmi-protocol-api 0.4.1 → 0.7.0

package/dist/issuance/transfer.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi/zod";
 import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
-import { erc20GatedAbi } from "../common/abis/erc20Whitelisted.js";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
 export const TransferErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     to: AddressSchema,

package/dist/issuance/upgrade.d.ts

@@ -21,8 +21,8 @@ export declare function upgradeTransparentProxy<E extends Env>(factory: Factory<
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };
@@ -47,8 +47,8 @@ export declare function upgradeTransparentProxy<E extends Env>(factory: Factory<
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };
@@ -73,8 +73,8 @@ export declare function upgradeTransparentProxy<E extends Env>(factory: Factory<
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };

package/dist/next/fractions/index.d.ts

@@ -0,0 +1,275 @@
+export declare const NextFractionsApi: import("../../common/controller.js").IApi<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<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    adminAddress: string;
+                    acceptedFundingTokens: string[];
+                    ownerAddress?: string | undefined;
+                    compilotSignerAddress?: string | undefined;
+                    cap?: {
+                        maxHardCap: string;
+                    } | undefined;
+                    fee?: {
+                        percent: number;
+                        collectorAddress: string;
+                        feeAdmin: string;
+                    } | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deployNftFractions">, "/platforms"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    market: string;
+                    nft: {
+                        contractAddress: string;
+                        tokenIds: string[];
+                    };
+                    fractions: {
+                        name: string;
+                        symbol: string;
+                        amount: string;
+                    };
+                    timeBoundary: {
+                        start: string;
+                        end: string;
+                    };
+                    cap: {
+                        soft: string;
+                        hard: string;
+                        softPerAccount?: string | undefined;
+                        hardPerAccount?: string | undefined;
+                    };
+                    funding: {
+                        token: string;
+                        amountPerPacket: string;
+                    }[];
+                    amountOfPacketsPerFraction: string;
+                    refundAddress: string;
+                    vesting?: {
+                        cliff: string;
+                        totalVestingPeriod: number;
+                        portionPeriod: number;
+                    } | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/nftFractions">, "/sales"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    adminAddress: string;
+                    minInterest: number;
+                    maxInterest: number;
+                    minDuration: string;
+                    maxDuration: string;
+                    minimumProportionOverObligation: string;
+                    ownerAddress?: string | undefined;
+                    discount?: {
+                        burnForDiscount: {
+                            burnableTokenAddress: string;
+                        };
+                    } | undefined;
+                    cap?: {
+                        maxHardCap: string;
+                    } | undefined;
+                    fee?: {
+                        percent: number;
+                        collectorAddress: string;
+                        feeAdmin: string;
+                    } | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deploy"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    market: string;
+                    fractions: {
+                        symbol: string;
+                        name: string;
+                        amount: string;
+                        token?: string | undefined;
+                    };
+                    timeBoundary: {
+                        start: string;
+                        end: string;
+                    };
+                    cap: {
+                        soft: string;
+                        hard: string;
+                        softPerAccount?: string | undefined;
+                        hardPerAccount?: string | undefined;
+                    };
+                    wrapped: ({
+                        type: "ERC20";
+                        address: string;
+                        values: string[];
+                    } | {
+                        type: "ERC721";
+                        address: string;
+                        tokenIds: string[];
+                    } | {
+                        type: "ERC1155";
+                        address: string;
+                        tokenIds: string[];
+                        values: string[];
+                    })[];
+                    funding: {
+                        token: string;
+                        amountPerPacket: string;
+                    }[];
+                    refundAddress: string;
+                    amountOfPacketsPerFraction: string;
+                    buyback: {
+                        durationSeconds: number;
+                        interestPercentage: number;
+                        liquidationLimitPercentage: number;
+                        marginCallLimitPercentage: number;
+                    };
+                    discounts?: {
+                        burnableTokenAddress: string;
+                        amountToBurn: string;
+                        percentDiscount: number;
+                    } | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/createSale"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    market: string;
+                    campaignId: string;
+                    chainId: unknown;
+                    amountToBuy: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/purchase"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    collateralPriceInFundingPackets: string;
+                    market: string;
+                    campaignId: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/setCollateralPrice"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    buybackPacketsAmount: string;
+                    market: string;
+                    campaignId: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/buyback">, "/lending">, "/">>;
+//# sourceMappingURL=index.d.ts.map

package/dist/next/fractions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/next/fractions/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAS3B,CAAC"}

package/dist/next/fractions/index.js

@@ -0,0 +1,13 @@
+import { createApi } from "../../common/controller.js";
+import { LendingController } from "./lending/index.js";
+import { PlatformsController } from "./platforms/index.js";
+import { SalesController } from "./sales/index.js";
+export const NextFractionsApi = createApi({
+    title: "Next Fractions API",
+    description: "NFT Fractions and Lending markets (next-gen SDK)",
+    build: (factory) => factory
+        .createApp()
+        .route("/platforms", PlatformsController.build(factory))
+        .route("/sales", SalesController.build(factory))
+        .route("/lending", LendingController.build(factory)),
+});

package/dist/next/fractions/lending/buyback/buyback.routes.d.ts

@@ -0,0 +1,27 @@
+export declare const BuybackV0: import("../../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    buybackPacketsAmount: string;
+                    market: string;
+                    campaignId: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=buyback.routes.d.ts.map

package/dist/next/fractions/lending/buyback/buyback.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buyback.routes.d.ts","sourceRoot":"","sources":["../../../../../src/next/fractions/lending/buyback/buyback.routes.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;QASpB,CAAC"}

package/dist/next/fractions/lending/buyback/buyback.routes.js

@@ -0,0 +1,28 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { buildBuybackTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { createController } from "../../../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { BuybackRequestSchema } from "./buyback.schema.js";
+const route = describeRoute({
+    summary: "Perform buyback of lending position",
+    description: "Returns transaction data for buying back the lending position with interest",
+    tags: ["Buy-back"],
+    responses: {
+        200: {
+            description: "Returns transaction data for buyback operation",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const BuybackV0 = createController({
+    build: (factory) => factory.createApp().post("/", route, validator("json", BuybackRequestSchema), async (c) => {
+        const { market, campaignId, buybackPacketsAmount } = c.req.valid("json");
+        const tx = buildBuybackTx(market, campaignId, buybackPacketsAmount);
+        return c.json(toTransaction(tx));
+    }),
+});

package/dist/next/fractions/lending/buyback/buyback.schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const BuybackRequestSchema: z.ZodObject<{
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 72080>[]]>>;
+    buybackPacketsAmount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    campaignId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+//# sourceMappingURL=buyback.schema.d.ts.map

package/dist/next/fractions/lending/buyback/buyback.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buyback.schema.d.ts","sourceRoot":"","sources":["../../../../../src/next/fractions/lending/buyback/buyback.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,oBAAoB;;;;;iBAQC,CAAC"}

package/dist/next/fractions/lending/buyback/buyback.schema.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { FractionsChainId } from "../../../../common/index.js";
+import { Int256BigInt } from "../../../../common/int256.js";
+import { SaleIdSchema } from "../../../../common/models/saleId.js";
+export const BuybackRequestSchema = z
+    .object({
+    chainId: FractionsChainId,
+    buybackPacketsAmount: Int256BigInt().openapi({
+        description: "Amount of packets to buyback (with interest)",
+    }),
+})
+    .extend(SaleIdSchema.shape)
+    .openapi("BuybackRequestSchema");

package/dist/next/fractions/lending/createLendingSale.d.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+export declare const BuyBackConfigSchema: z.ZodObject<{
+    durationSeconds: z.ZodNumber;
+    interestPercentage: z.ZodNumber;
+    liquidationLimitPercentage: z.ZodNumber;
+    marginCallLimitPercentage: z.ZodNumber;
+}, z.core.$strip>;
+export declare const CreateLendingFractionsRequestSchema: z.ZodObject<{
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 72080>[]]>>;
+    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    fractions: z.ZodObject<{
+        token: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+        symbol: z.ZodString;
+        name: z.ZodString;
+        amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    }, z.core.$strip>;
+    timeBoundary: z.ZodObject<{
+        start: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+        end: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+    }, z.core.$strip>;
+    cap: z.ZodObject<{
+        soft: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+        hard: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+        softPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+        hardPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    }, z.core.$strip>;
+    wrapped: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"ERC20">;
+        address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        values: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ERC721">;
+        address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        tokenIds: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ERC1155">;
+        address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        tokenIds: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+        values: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    }, z.core.$strip>]>>;
+    funding: z.ZodArray<z.ZodObject<{
+        token: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        amountPerPacket: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    }, z.core.$strip>>;
+    discounts: z.ZodOptional<z.ZodObject<{
+        burnableTokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        amountToBurn: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+        percentDiscount: z.ZodNumber;
+    }, z.core.$strip>>;
+    refundAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    amountOfPacketsPerFraction: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    buyback: z.ZodObject<{
+        durationSeconds: z.ZodNumber;
+        interestPercentage: z.ZodNumber;
+        liquidationLimitPercentage: z.ZodNumber;
+        marginCallLimitPercentage: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CreateLendingSaleController: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    market: string;
+                    fractions: {
+                        symbol: string;
+                        name: string;
+                        amount: string;
+                        token?: string | undefined;
+                    };
+                    timeBoundary: {
+                        start: string;
+                        end: string;
+                    };
+                    cap: {
+                        soft: string;
+                        hard: string;
+                        softPerAccount?: string | undefined;
+                        hardPerAccount?: string | undefined;
+                    };
+                    wrapped: ({
+                        type: "ERC20";
+                        address: string;
+                        values: string[];
+                    } | {
+                        type: "ERC721";
+                        address: string;
+                        tokenIds: string[];
+                    } | {
+                        type: "ERC1155";
+                        address: string;
+                        tokenIds: string[];
+                        values: string[];
+                    })[];
+                    funding: {
+                        token: string;
+                        amountPerPacket: string;
+                    }[];
+                    refundAddress: string;
+                    amountOfPacketsPerFraction: string;
+                    buyback: {
+                        durationSeconds: number;
+                        interestPercentage: number;
+                        liquidationLimitPercentage: number;
+                        marginCallLimitPercentage: number;
+                    };
+                    discounts?: {
+                        burnableTokenAddress: string;
+                        amountToBurn: string;
+                        percentDiscount: number;
+                    } | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=createLendingSale.d.ts.map

package/dist/next/fractions/lending/createLendingSale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLendingSale.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/lending/createLendingSale.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoBxB,eAAO,MAAM,mBAAmB;;;;;iBAK9B,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY9C,CAAC;AAkBH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmDtC,CAAC"}

package/dist/next/fractions/lending/createLendingSale.js

@@ -0,0 +1,82 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { buildCreateLendingFractionsTx, createWrappedErc20, createWrappedErc721, createWrappedErc1155, } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { createController } from "../../../common/controller.js";
+import { AddressSchema, FractionsChainId, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+import { BurnForDiscountSchema, CapitalizationSchema, FractionSchema, FundingSchema, TimeBoundarySchema, WrappedTokenTypeSchema, } from "../../../fractions/sales/createFractions.schema.js";
+export const BuyBackConfigSchema = z.object({
+    durationSeconds: z.number().int().positive(),
+    interestPercentage: z.number().int().min(0).max(10000),
+    liquidationLimitPercentage: z.number().int().min(0).max(10000),
+    marginCallLimitPercentage: z.number().int().min(0).max(10000),
+});
+export const CreateLendingFractionsRequestSchema = z.object({
+    chainId: FractionsChainId,
+    market: AddressSchema,
+    fractions: FractionSchema,
+    timeBoundary: TimeBoundarySchema,
+    cap: CapitalizationSchema,
+    wrapped: z.array(WrappedTokenTypeSchema).nonempty(),
+    funding: z.array(FundingSchema).nonempty(),
+    discounts: BurnForDiscountSchema.optional(),
+    refundAddress: AddressSchema,
+    amountOfPacketsPerFraction: Int256BigInt(z.bigint().positive()),
+    buyback: BuyBackConfigSchema,
+});
+const route = describeRoute({
+    summary: "Create lending sale fractions",
+    description: "Returns transaction data for creating lending sale fractions",
+    tags: ["Buy-back"],
+    responses: {
+        200: {
+            description: "Returns transaction data for creating lending sale fractions",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateLendingSaleController = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", CreateLendingFractionsRequestSchema.openapi("CreateLendingFractionsRequestSchema")), async (c) => {
+        const { chainId, market, wrapped, funding, fractions, timeBoundary, cap, amountOfPacketsPerFraction, refundAddress, discounts, buyback, } = c.req.valid("json");
+        const wrappedTokens = wrapped.map(createWrapped);
+        const lendingFractionsConfig = {
+            chainId: chainId,
+            market: market,
+            wrapped: wrappedTokens,
+            funding: funding,
+            fractions: {
+                name: fractions.name,
+                symbol: fractions.symbol,
+                amount: fractions.amount,
+            },
+            timeBoundary: {
+                start: new Date(timeBoundary.start),
+                end: new Date(timeBoundary.end),
+            },
+            discounts: discounts,
+            cap: cap,
+            amountOfPacketsPerFraction: amountOfPacketsPerFraction,
+            refundAddress: refundAddress,
+            buyback: buyback,
+        };
+        const tx = buildCreateLendingFractionsTx(lendingFractionsConfig);
+        return c.json(toTransaction(tx));
+    }),
+});
+function createWrapped(token) {
+    switch (token.type) {
+        case "ERC20":
+            return createWrappedErc20(token.address, token.values[0]);
+        case "ERC721":
+            return createWrappedErc721(token.address, token.tokenIds);
+        case "ERC1155":
+            return createWrappedErc1155(token.address, token.tokenIds, token.values);
+    }
+}