@evergonlabs/tmi-protocol-api 0.1.4 → 0.2.0

package/dist/lending/createLendingSale.d.ts

@@ -0,0 +1,585 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { z } from "zod";
+export declare const BuyBackConfigSchema: z.ZodObject<{
+    durationSeconds: z.ZodNumber;
+    interestPercentage: z.ZodNumber;
+    liquidationLimitPercentage: z.ZodNumber;
+    marginCallLimitPercentage: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    durationSeconds: number;
+    interestPercentage: number;
+    liquidationLimitPercentage: number;
+    marginCallLimitPercentage: number;
+}, {
+    durationSeconds: number;
+    interestPercentage: number;
+    liquidationLimitPercentage: number;
+    marginCallLimitPercentage: number;
+}>;
+export declare const CreateLendingFractionsRequestSchema: z.ZodObject<{
+    chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+    market: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    fractions: z.ZodObject<{
+        token: z.ZodOptional<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
+        symbol: z.ZodString;
+        name: z.ZodString;
+        amount: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        symbol: string;
+        name: string;
+        amount: bigint;
+        token?: `0x${string}` | undefined;
+    }, {
+        symbol: string;
+        name: string;
+        amount: bigint;
+        token?: `0x${string}` | undefined;
+    }>;
+    timeBoundary: z.ZodObject<{
+        start: z.ZodDate;
+        end: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        start: Date;
+        end: Date;
+    }, {
+        start: Date;
+        end: Date;
+    }>;
+    cap: z.ZodObject<{
+        soft: z.ZodBigInt;
+        hard: z.ZodBigInt;
+        softPerAccount: z.ZodOptional<z.ZodBigInt>;
+        hardPerAccount: z.ZodOptional<z.ZodBigInt>;
+    }, "strip", z.ZodTypeAny, {
+        soft: bigint;
+        hard: bigint;
+        softPerAccount?: bigint | undefined;
+        hardPerAccount?: bigint | undefined;
+    }, {
+        soft: bigint;
+        hard: bigint;
+        softPerAccount?: bigint | undefined;
+        hardPerAccount?: bigint | undefined;
+    }>;
+    wrapped: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"ERC20">;
+        address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        values: z.ZodArray<z.ZodBigInt, "atleastone">;
+    }, "strip", z.ZodTypeAny, {
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    }, {
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"ERC721">;
+        address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        tokenIds: z.ZodArray<z.ZodBigInt, "atleastone">;
+    }, "strip", z.ZodTypeAny, {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }, {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"ERC1155">;
+        address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        tokenIds: z.ZodArray<z.ZodBigInt, "atleastone">;
+        values: z.ZodArray<z.ZodBigInt, "atleastone">;
+    }, "strip", z.ZodTypeAny, {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }, {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }>]>, "atleastone">;
+    funding: z.ZodArray<z.ZodObject<{
+        token: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        amountPerPacket: z.ZodBigInt;
+    }, "strip", z.ZodTypeAny, {
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }, {
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }>, "atleastone">;
+    discounts: z.ZodOptional<z.ZodObject<{
+        burnableTokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        amountToBurn: z.ZodBigInt;
+        percentDiscount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        burnableTokenAddress: `0x${string}`;
+        amountToBurn: bigint;
+        percentDiscount: number;
+    }, {
+        burnableTokenAddress: `0x${string}`;
+        amountToBurn: bigint;
+        percentDiscount: number;
+    }>>;
+    refundAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amountOfPacketsPerFraction: z.ZodBigInt;
+    buyback: z.ZodObject<{
+        durationSeconds: z.ZodNumber;
+        interestPercentage: z.ZodNumber;
+        liquidationLimitPercentage: z.ZodNumber;
+        marginCallLimitPercentage: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        durationSeconds: number;
+        interestPercentage: number;
+        liquidationLimitPercentage: number;
+        marginCallLimitPercentage: number;
+    }, {
+        durationSeconds: number;
+        interestPercentage: number;
+        liquidationLimitPercentage: number;
+        marginCallLimitPercentage: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    fractions: {
+        symbol: string;
+        name: string;
+        amount: bigint;
+        token?: `0x${string}` | undefined;
+    };
+    cap: {
+        soft: bigint;
+        hard: bigint;
+        softPerAccount?: bigint | undefined;
+        hardPerAccount?: bigint | undefined;
+    };
+    market: `0x${string}`;
+    timeBoundary: {
+        start: Date;
+        end: Date;
+    };
+    wrapped: [{
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    } | {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    } | {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }, ...({
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    } | {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    } | {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    })[]];
+    funding: [{
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }, ...{
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }[]];
+    refundAddress: `0x${string}`;
+    amountOfPacketsPerFraction: bigint;
+    buyback: {
+        durationSeconds: number;
+        interestPercentage: number;
+        liquidationLimitPercentage: number;
+        marginCallLimitPercentage: number;
+    };
+    discounts?: {
+        burnableTokenAddress: `0x${string}`;
+        amountToBurn: bigint;
+        percentDiscount: number;
+    } | undefined;
+}, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    fractions: {
+        symbol: string;
+        name: string;
+        amount: bigint;
+        token?: `0x${string}` | undefined;
+    };
+    cap: {
+        soft: bigint;
+        hard: bigint;
+        softPerAccount?: bigint | undefined;
+        hardPerAccount?: bigint | undefined;
+    };
+    market: `0x${string}`;
+    timeBoundary: {
+        start: Date;
+        end: Date;
+    };
+    wrapped: [{
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    } | {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    } | {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    }, ...({
+        values: [bigint, ...bigint[]];
+        type: "ERC20";
+        address: `0x${string}`;
+    } | {
+        type: "ERC721";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    } | {
+        values: [bigint, ...bigint[]];
+        type: "ERC1155";
+        address: `0x${string}`;
+        tokenIds: [bigint, ...bigint[]];
+    })[]];
+    funding: [{
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }, ...{
+        amountPerPacket: bigint;
+        token: `0x${string}`;
+    }[]];
+    refundAddress: `0x${string}`;
+    amountOfPacketsPerFraction: bigint;
+    buyback: {
+        durationSeconds: number;
+        interestPercentage: number;
+        liquidationLimitPercentage: number;
+        marginCallLimitPercentage: number;
+    };
+    discounts?: {
+        burnableTokenAddress: `0x${string}`;
+        amountToBurn: bigint;
+        percentDiscount: number;
+    } | undefined;
+}>;
+export declare function createLendingSale<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[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            fractions: {
+                symbol: string;
+                name: string;
+                amount: bigint;
+                token?: `0x${string}` | undefined;
+            };
+            cap: {
+                soft: bigint;
+                hard: bigint;
+                softPerAccount?: bigint | undefined;
+                hardPerAccount?: bigint | undefined;
+            };
+            market: `0x${string}`;
+            timeBoundary: {
+                start: Date;
+                end: Date;
+            };
+            wrapped: [{
+                values: [bigint, ...bigint[]];
+                type: "ERC20";
+                address: `0x${string}`;
+            } | {
+                type: "ERC721";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            } | {
+                values: [bigint, ...bigint[]];
+                type: "ERC1155";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            }, ...({
+                values: [bigint, ...bigint[]];
+                type: "ERC20";
+                address: `0x${string}`;
+            } | {
+                type: "ERC721";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            } | {
+                values: [bigint, ...bigint[]];
+                type: "ERC1155";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            })[]];
+            funding: [{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }, ...{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }[]];
+            refundAddress: `0x${string}`;
+            amountOfPacketsPerFraction: bigint;
+            buyback: {
+                durationSeconds: number;
+                interestPercentage: number;
+                liquidationLimitPercentage: number;
+                marginCallLimitPercentage: number;
+            };
+            discounts?: {
+                burnableTokenAddress: `0x${string}`;
+                amountToBurn: bigint;
+                percentDiscount: number;
+            } | undefined;
+        };
+    };
+    out: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            fractions: {
+                symbol: string;
+                name: string;
+                amount: bigint;
+                token?: `0x${string}` | undefined;
+            };
+            cap: {
+                soft: bigint;
+                hard: bigint;
+                softPerAccount?: bigint | undefined;
+                hardPerAccount?: bigint | undefined;
+            };
+            market: `0x${string}`;
+            timeBoundary: {
+                start: Date;
+                end: Date;
+            };
+            wrapped: [{
+                values: [bigint, ...bigint[]];
+                type: "ERC20";
+                address: `0x${string}`;
+            } | {
+                type: "ERC721";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            } | {
+                values: [bigint, ...bigint[]];
+                type: "ERC1155";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            }, ...({
+                values: [bigint, ...bigint[]];
+                type: "ERC20";
+                address: `0x${string}`;
+            } | {
+                type: "ERC721";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            } | {
+                values: [bigint, ...bigint[]];
+                type: "ERC1155";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            })[]];
+            funding: [{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }, ...{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }[]];
+            refundAddress: `0x${string}`;
+            amountOfPacketsPerFraction: bigint;
+            buyback: {
+                durationSeconds: number;
+                interestPercentage: number;
+                liquidationLimitPercentage: number;
+                marginCallLimitPercentage: number;
+            };
+            discounts?: {
+                burnableTokenAddress: `0x${string}`;
+                amountToBurn: bigint;
+                percentDiscount: number;
+            } | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            fractions: {
+                symbol: string;
+                name: string;
+                amount: bigint;
+                token?: `0x${string}` | undefined;
+            };
+            cap: {
+                soft: bigint;
+                hard: bigint;
+                softPerAccount?: bigint | undefined;
+                hardPerAccount?: bigint | undefined;
+            };
+            market: `0x${string}`;
+            timeBoundary: {
+                start: Date;
+                end: Date;
+            };
+            wrapped: [{
+                values: [bigint, ...bigint[]];
+                type: "ERC20";
+                address: `0x${string}`;
+            } | {
+                type: "ERC721";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            } | {
+                values: [bigint, ...bigint[]];
+                type: "ERC1155";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            }, ...({
+                values: [bigint, ...bigint[]];
+                type: "ERC20";
+                address: `0x${string}`;
+            } | {
+                type: "ERC721";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            } | {
+                values: [bigint, ...bigint[]];
+                type: "ERC1155";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            })[]];
+            funding: [{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }, ...{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }[]];
+            refundAddress: `0x${string}`;
+            amountOfPacketsPerFraction: bigint;
+            buyback: {
+                durationSeconds: number;
+                interestPercentage: number;
+                liquidationLimitPercentage: number;
+                marginCallLimitPercentage: number;
+            };
+            discounts?: {
+                burnableTokenAddress: `0x${string}`;
+                amountToBurn: bigint;
+                percentDiscount: number;
+            } | undefined;
+        };
+    };
+    out: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            fractions: {
+                symbol: string;
+                name: string;
+                amount: bigint;
+                token?: `0x${string}` | undefined;
+            };
+            cap: {
+                soft: bigint;
+                hard: bigint;
+                softPerAccount?: bigint | undefined;
+                hardPerAccount?: bigint | undefined;
+            };
+            market: `0x${string}`;
+            timeBoundary: {
+                start: Date;
+                end: Date;
+            };
+            wrapped: [{
+                values: [bigint, ...bigint[]];
+                type: "ERC20";
+                address: `0x${string}`;
+            } | {
+                type: "ERC721";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            } | {
+                values: [bigint, ...bigint[]];
+                type: "ERC1155";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            }, ...({
+                values: [bigint, ...bigint[]];
+                type: "ERC20";
+                address: `0x${string}`;
+            } | {
+                type: "ERC721";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            } | {
+                values: [bigint, ...bigint[]];
+                type: "ERC1155";
+                address: `0x${string}`;
+                tokenIds: [bigint, ...bigint[]];
+            })[]];
+            funding: [{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }, ...{
+                amountPerPacket: bigint;
+                token: `0x${string}`;
+            }[]];
+            refundAddress: `0x${string}`;
+            amountOfPacketsPerFraction: bigint;
+            buyback: {
+                durationSeconds: number;
+                interestPercentage: number;
+                liquidationLimitPercentage: number;
+                marginCallLimitPercentage: number;
+            };
+            discounts?: {
+                burnableTokenAddress: `0x${string}`;
+                amountToBurn: bigint;
+                percentDiscount: number;
+            } | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=createLendingSale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createLendingSale.d.ts","sourceRoot":"","sources":["../../src/lending/createLendingSale.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAWvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAK9B,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY9C,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAyEnE"}

package/dist/lending/createLendingSale.js

@@ -0,0 +1,81 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { buildCreateLendingFractionsTx, WrappedERC1155, WrappedERC20, WrappedERC721, } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { z } from "zod";
+import { AddressSchema, TmiChainIdSchema, toTransaction, TransactionSchema } from "../common/index.js";
+import { BurnForDiscountSchema, CapitalizationSchema, FractionSchema, FundingSchema, TimeBoundarySchema, WrappedTokenTypeSchema, } from "../fractions/createFractions/v0/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: TmiChainIdSchema,
+    market: AddressSchema,
+    fractions: FractionSchema,
+    timeBoundary: TimeBoundarySchema,
+    cap: CapitalizationSchema,
+    wrapped: z.array(WrappedTokenTypeSchema).nonempty(),
+    funding: z.array(FundingSchema).nonempty(),
+    discounts: BurnForDiscountSchema.optional(),
+    refundAddress: AddressSchema,
+    amountOfPacketsPerFraction: z.coerce.bigint().positive(),
+    buyback: BuyBackConfigSchema,
+});
+export function createLendingSale(factory) {
+    const route = describeRoute({
+        summary: "Create lending sale fractions",
+        description: "Returns transaction data for creating lending sale fractions",
+        tags: ["Lending"],
+        responses: {
+            200: {
+                description: "Returns transaction data for creating lending sale fractions",
+                content: {
+                    "application/json": {
+                        schema: resolver(TransactionSchema),
+                    },
+                },
+            },
+        },
+    });
+    return factory.createHandlers(route, validator("json", CreateLendingFractionsRequestSchema.openapi({ ref: "CreateLendingFractionsRequestSchema" })), async (c) => {
+        const { chainId, market, wrapped, funding, fractions, timeBoundary, cap, amountOfPacketsPerFraction, refundAddress, discounts, buyback, } = c.req.valid("json");
+        const wrappedTokens = wrapped.map((token) => {
+            if (token.type === "ERC20") {
+                return new WrappedERC20(token.address, token.values[0]);
+            }
+            else if (token.type === "ERC721") {
+                return new WrappedERC721(token.address, token.tokenIds);
+            }
+            else if (token.type === "ERC1155") {
+                return new WrappedERC1155(token.address, token.tokenIds, token.values);
+            }
+            else {
+                throw new Error(`Unsupported token type: ${JSON.stringify(token)}`);
+            }
+        });
+        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, true));
+    });
+}