@evergonlabs/tmi-protocol-api 0.3.0 → 0.4.0

package/dist/lending/createLendingSale.d.ts

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

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

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