@evergonlabs/tmi-protocol-api 0.9.0 → 0.10.0-rc.0

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

@@ -1,65 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare function createBuybackTransactionV0<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: unknown;
-            buybackPacketsAmount: string;
-            market: string;
-            campaignId: string;
-        };
-    };
-    out: {
-        json: {
-            chainId: 1 | 11155111 | 31337 | 72080;
-            buybackPacketsAmount: bigint;
-            market: `0x${string}`;
-            campaignId: bigint;
-        };
-    };
-}, 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: unknown;
-            buybackPacketsAmount: string;
-            market: string;
-            campaignId: string;
-        };
-    };
-    out: {
-        json: {
-            chainId: 1 | 11155111 | 31337 | 72080;
-            buybackPacketsAmount: bigint;
-            market: `0x${string}`;
-            campaignId: bigint;
-        };
-    };
-}, 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=buyback.routes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"buyback.routes.d.ts","sourceRoot":"","sources":["../../../../../src/v1/fractions/lending/buyback/buyback.routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAuBvC,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAQ5E"}

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

@@ -1,27 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { buildBuybackTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-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 function createBuybackTransactionV0(factory) {
-    return factory.createHandlers(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/v1/fractions/lending/buyback/buyback.schema.d.ts

@@ -1,8 +0,0 @@
-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/v1/fractions/lending/buyback/buyback.schema.d.ts.map

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

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

@@ -1,13 +0,0 @@
-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/v1/fractions/lending/createLendingSale.d.ts

@@ -1,303 +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;
-}, 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 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: 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;
-        };
-    };
-    out: {
-        json: {
-            chainId: 1 | 11155111 | 31337 | 72080;
-            market: `0x${string}`;
-            fractions: {
-                symbol: string;
-                name: string;
-                amount: bigint;
-                token?: `0x${string}` | undefined;
-            };
-            timeBoundary: {
-                start: Date;
-                end: Date;
-            };
-            cap: {
-                soft: bigint;
-                hard: bigint;
-                softPerAccount?: bigint | undefined;
-                hardPerAccount?: bigint | undefined;
-            };
-            wrapped: ({
-                type: "ERC20";
-                address: `0x${string}`;
-                values: bigint[];
-            } | {
-                type: "ERC721";
-                address: `0x${string}`;
-                tokenIds: bigint[];
-            } | {
-                type: "ERC1155";
-                address: `0x${string}`;
-                tokenIds: bigint[];
-                values: bigint[];
-            })[];
-            funding: {
-                token: `0x${string}`;
-                amountPerPacket: bigint;
-            }[];
-            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: 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;
-        };
-    };
-    out: {
-        json: {
-            chainId: 1 | 11155111 | 31337 | 72080;
-            market: `0x${string}`;
-            fractions: {
-                symbol: string;
-                name: string;
-                amount: bigint;
-                token?: `0x${string}` | undefined;
-            };
-            timeBoundary: {
-                start: Date;
-                end: Date;
-            };
-            cap: {
-                soft: bigint;
-                hard: bigint;
-                softPerAccount?: bigint | undefined;
-                hardPerAccount?: bigint | undefined;
-            };
-            wrapped: ({
-                type: "ERC20";
-                address: `0x${string}`;
-                values: bigint[];
-            } | {
-                type: "ERC721";
-                address: `0x${string}`;
-                tokenIds: bigint[];
-            } | {
-                type: "ERC1155";
-                address: `0x${string}`;
-                tokenIds: bigint[];
-                values: bigint[];
-            })[];
-            funding: {
-                token: `0x${string}`;
-                amountPerPacket: bigint;
-            }[];
-            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/v1/fractions/lending/createLendingSale.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createLendingSale.d.ts","sourceRoot":"","sources":["../../../../src/v1/fractions/lending/createLendingSale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,eAAO,MAAM,mBAAmB;;;;;iBAK9B,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY9C,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA+DnE"}

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

@@ -1,79 +0,0 @@
-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 { 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,
-});
-export function createLendingSale(factory) {
-    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),
-                    },
-                },
-            },
-        },
-    });
-    return factory.createHandlers(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);
-    }
-}

package/dist/v1/fractions/lending/deployMarket/lending.routes.d.ts

@@ -1,113 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare function createDeployLendingMarketTransactionV0<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: 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;
-        };
-    };
-    out: {
-        json: {
-            chainId: 11155111 | 31337 | 72080;
-            adminAddress: `0x${string}`;
-            minInterest: number;
-            maxInterest: number;
-            minDuration: bigint;
-            maxDuration: bigint;
-            minimumProportionOverObligation: bigint;
-            ownerAddress?: `0x${string}` | undefined;
-            discount?: {
-                burnForDiscount: {
-                    burnableTokenAddress: `0x${string}`;
-                };
-            } | undefined;
-            cap?: {
-                maxHardCap: bigint;
-            } | 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: 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;
-        };
-    };
-    out: {
-        json: {
-            chainId: 11155111 | 31337 | 72080;
-            adminAddress: `0x${string}`;
-            minInterest: number;
-            maxInterest: number;
-            minDuration: bigint;
-            maxDuration: bigint;
-            minimumProportionOverObligation: bigint;
-            ownerAddress?: `0x${string}` | undefined;
-            discount?: {
-                burnForDiscount: {
-                    burnableTokenAddress: `0x${string}`;
-                };
-            } | undefined;
-            cap?: {
-                maxHardCap: bigint;
-            } | 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=lending.routes.d.ts.map

package/dist/v1/fractions/lending/deployMarket/lending.routes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lending.routes.d.ts","sourceRoot":"","sources":["../../../../../src/v1/fractions/lending/deployMarket/lending.routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAwBvC,wBAAgB,sCAAsC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA+BxF"}

package/dist/v1/fractions/lending/deployMarket/lending.routes.js

@@ -1,41 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { createLendingPlatform } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { getFeeConfig } from "../../../../fractions/platforms/index.js";
-import { DeployLendingMarketRequestSchema } from "../../schemas.js";
-const route = describeRoute({
-    summary: "Deploy a lending market",
-    description: "Returns transaction data for deploying a lending market with fractionalized collateral",
-    tags: ["Buy-back"],
-    responses: {
-        200: {
-            description: "Returns transaction data for deploying a lending market",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export function createDeployLendingMarketTransactionV0(factory) {
-    return factory.createHandlers(route, validator("json", DeployLendingMarketRequestSchema), async (c) => {
-        const { cap, chainId, adminAddress, discount, minInterest, maxInterest, minDuration, maxDuration, ownerAddress, minimumProportionOverObligation, } = c.req.valid("json");
-        const fee = getFeeConfig();
-        const tx = createLendingPlatform({
-            chainId: chainId,
-            adminAddress: adminAddress,
-            ownerAddress: ownerAddress || adminAddress,
-            fee: fee,
-            minInterest,
-            maxInterest,
-            minDuration,
-            maxDuration,
-            minimumProportionOverObligation,
-            maxHardCap: cap ? cap.maxHardCap : null,
-            burnDiscountToken: discount ? discount.burnForDiscount.burnableTokenAddress : null,
-        });
-        return c.json(toTransaction(tx));
-    });
-}