@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/next/fractions/lending/purchase/directPurchase.route.js

@@ -0,0 +1,34 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { buildDirectPurchaseTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { createController } from "../../../../common/controller.js";
+import { FractionsChainId, SaleIdSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
+export const DirectPurchaseRequestSchema = SaleIdSchema.extend({
+    chainId: FractionsChainId,
+    amountToBuy: Int256Json,
+});
+const route = describeRoute({
+    summary: "Make a purchase",
+    description: "Returns transaction data for making a purchase",
+    tags: ["Buy-back"],
+    responses: {
+        200: {
+            description: "Returns transaction data for making a purchase",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const DirectPurchaseV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", DirectPurchaseRequestSchema.openapi("PurchaseRequestSchema")), async (c) => {
+        const { chainId, market, campaignId, amountToBuy } = c.req.valid("json");
+        const tx = buildDirectPurchaseTx(chainId, market, campaignId, BigInt(amountToBuy));
+        return c.json(toTransaction(tx));
+    }),
+});

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const DeployLendingMarketRequestSchema: z.ZodObject<{
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 72080>, z.ZodLiteral<11155111 | 31337 | 72080>, ...z.ZodLiteral<11155111 | 31337 | 72080>[]]>>;
+    adminAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    ownerAddress: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+    discount: z.ZodOptional<z.ZodObject<{
+        burnForDiscount: z.ZodObject<{
+            burnableTokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    cap: z.ZodOptional<z.ZodObject<{
+        maxHardCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    }, z.core.$strip>>;
+    fee: z.ZodOptional<z.ZodObject<{
+        percent: z.ZodNumber;
+        collectorAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        feeAdmin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    }, z.core.$strip>>;
+    minInterest: z.ZodNumber;
+    maxInterest: z.ZodNumber;
+    minDuration: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    maxDuration: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    minimumProportionOverObligation: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/lending/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;iBAgBC,CAAC"}

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { AddressSchema, NextFractionsChainId } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+import { CapConfigSchema, DiscountConfigSchema, FeeConfigSchema, } from "../../../fractions/platforms/deployMarket.schema.js";
+export const DeployLendingMarketRequestSchema = z
+    .object({
+    chainId: NextFractionsChainId,
+    adminAddress: AddressSchema,
+    ownerAddress: AddressSchema.optional().openapi({
+        description: "If not defined then `adminAddress` is going to be used",
+    }),
+    discount: DiscountConfigSchema.optional(),
+    cap: CapConfigSchema.optional(),
+    fee: FeeConfigSchema.optional(),
+    minInterest: z.number(), // 0 to 100000 basis points (0% to 1000%)
+    maxInterest: z.number(), // 0 to 100000 basis points (0% to 1000%)
+    minDuration: Int256BigInt(), // Minimum duration in seconds
+    maxDuration: Int256BigInt(), // Maximum duration in seconds
+    minimumProportionOverObligation: Int256BigInt(),
+})
+    .openapi("DeployLendingMarketRequestSchema");

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

@@ -0,0 +1,26 @@
+export declare const SetCollateralPriceV0: import("../../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../../common/context.js").AppContext, {
+    "/": {
+        $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;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=setCollateralPrice.routes.d.ts.map

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

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

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

@@ -0,0 +1,28 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { buildSetCollateralPriceTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { createController } from "../../../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { SetCollateralPriceRequestSchema } from "./setCollateralPrice.schema.js";
+const route = describeRoute({
+    summary: "Set collateral price for lending market",
+    description: "Returns transaction data for setting the collateral price in a lending market",
+    tags: ["Buy-back"],
+    responses: {
+        200: {
+            description: "Returns transaction data for setting collateral price",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const SetCollateralPriceV0 = createController({
+    build: (factory) => factory.createApp().post("/", route, validator("json", SetCollateralPriceRequestSchema), async (c) => {
+        const { market, campaignId, collateralPriceInFundingPackets } = c.req.valid("json");
+        const tx = buildSetCollateralPriceTx(market, campaignId, collateralPriceInFundingPackets);
+        return c.json(toTransaction(tx));
+    }),
+});

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

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const SetCollateralPriceRequestSchema: z.ZodObject<{
+    collateralPriceInFundingPackets: 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=setCollateralPrice.schema.d.ts.map

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

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

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

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { Int256BigInt } from "../../../../common/int256.js";
+import { SaleIdSchema } from "../../../../common/models/saleId.js";
+export const SetCollateralPriceRequestSchema = z
+    .object({
+    collateralPriceInFundingPackets: Int256BigInt().openapi({
+        description: "Collateral price in funding packets",
+    }),
+})
+    .extend(SaleIdSchema.shape)
+    .openapi("SetCollateralPriceRequestSchema");

package/dist/next/fractions/platforms/deployNftFractionsMarket.routes.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Controller for deploying an NFT Fractions market
+ */
+export declare const DeployNftFractionsMarketV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $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;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=deployNftFractionsMarket.routes.d.ts.map

package/dist/next/fractions/platforms/deployNftFractionsMarket.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployNftFractionsMarket.routes.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/platforms/deployNftFractionsMarket.routes.ts"],"names":[],"mappings":"AAyBA;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkBrC,CAAC"}

package/dist/next/fractions/platforms/deployNftFractionsMarket.routes.js

@@ -0,0 +1,40 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { createNftFractionsPlatform } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { createController } from "../../../common/controller.js";
+import { DEFAULT_COMPILOT_SIGNER, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { DeployNftFractionsMarketRequestSchema } from "./deployNftFractionsMarket.schema.js";
+const route = describeRoute({
+    summary: "Deploy an NFT Fractions market",
+    description: "Returns transaction data for deploying an NFT Fractions market with ComPilot gating. " +
+        "This market type supports wrapping ERC-721 tokens and fractionalizing them into ERC-20 compatible tokens.",
+    tags: ["NFT Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying an NFT Fractions market",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+/**
+ * Controller for deploying an NFT Fractions market
+ */
+export const DeployNftFractionsMarketV0 = createController({
+    build: (factory) => factory.createApp().post("/", route, validator("json", DeployNftFractionsMarketRequestSchema), async (c) => {
+        const { chainId, adminAddress, ownerAddress, compilotSignerAddress, cap, fee, acceptedFundingTokens } = c.req.valid("json");
+        const tx = createNftFractionsPlatform({
+            chainId: chainId,
+            adminAddress: adminAddress,
+            ownerAddress: ownerAddress ?? adminAddress,
+            compilotSignerAddress: compilotSignerAddress ?? DEFAULT_COMPILOT_SIGNER,
+            fee: fee ?? null,
+            maxHardCap: cap ? cap.maxHardCap : null,
+            acceptedFundingTokens: acceptedFundingTokens,
+        });
+        return c.json(toTransaction(tx));
+    }),
+});

package/dist/next/fractions/platforms/deployNftFractionsMarket.schema.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+/**
+ * Cap configuration schema for market limits
+ */
+export declare const CapConfigSchema: z.ZodObject<{
+    maxHardCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+/**
+ * Request schema for deploying an NFT Fractions market
+ */
+export declare const DeployNftFractionsMarketRequestSchema: z.ZodObject<{
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 72080>, z.ZodLiteral<11155111 | 31337 | 72080>, ...z.ZodLiteral<11155111 | 31337 | 72080>[]]>>;
+    adminAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    ownerAddress: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+    compilotSignerAddress: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+    cap: z.ZodOptional<z.ZodObject<{
+        maxHardCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    }, z.core.$strip>>;
+    fee: z.ZodOptional<z.ZodObject<{
+        percent: z.ZodNumber;
+        collectorAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        feeAdmin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    }, z.core.$strip>>;
+    acceptedFundingTokens: z.ZodArray<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+}, z.core.$strip>;
+//# sourceMappingURL=deployNftFractionsMarket.schema.d.ts.map

package/dist/next/fractions/platforms/deployNftFractionsMarket.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployNftFractionsMarket.schema.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/platforms/deployNftFractionsMarket.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,eAAO,MAAM,eAAe;;iBAE1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;iBAcC,CAAC"}

package/dist/next/fractions/platforms/deployNftFractionsMarket.schema.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { AddressSchema, NextFractionsChainId } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+import { FeeConfigSchema } from "../../../fractions/platforms/deployMarket.schema.js";
+/**
+ * Cap configuration schema for market limits
+ */
+export const CapConfigSchema = z.object({
+    maxHardCap: Int256BigInt(z.bigint().min(BigInt(1))).describe("Maximum hard cap for the market"),
+});
+/**
+ * Request schema for deploying an NFT Fractions market
+ */
+export const DeployNftFractionsMarketRequestSchema = z
+    .object({
+    chainId: NextFractionsChainId.describe("Chain ID where the market will be deployed"),
+    adminAddress: AddressSchema.describe("Address of the market administrator"),
+    ownerAddress: AddressSchema.optional().describe("Address of the market owner. Defaults to adminAddress if not provided"),
+    compilotSignerAddress: AddressSchema.optional().describe("ComPilot signer address. Uses platform default if not provided"),
+    cap: CapConfigSchema.optional().describe("Optional cap configuration"),
+    fee: FeeConfigSchema.optional().describe("Optional fee configuration"),
+    acceptedFundingTokens: z.array(AddressSchema).describe("Accepted funding token addresses"),
+})
+    .openapi("DeployNftFractionsMarketRequestSchema");

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

@@ -0,0 +1,36 @@
+export declare const PlatformsController: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, 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">, "/">>;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/next/fractions/platforms/index.js

@@ -0,0 +1,5 @@
+import { createController } from "../../../common/controller.js";
+import { DeployNftFractionsMarketV0 } from "./deployNftFractionsMarket.routes.js";
+export const PlatformsController = createController({
+    build: (factory) => factory.createApp().route("/deployNftFractions", DeployNftFractionsMarketV0.build(factory)),
+});

package/dist/next/fractions/sales/createNftFractions.routes.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Controller for the create NFT fractions endpoint
+ */
+export declare const CreateNftFractionsV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $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;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=createNftFractions.routes.d.ts.map

package/dist/next/fractions/sales/createNftFractions.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNftFractions.routes.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/sales/createNftFractions.routes.ts"],"names":[],"mappings":"AAyBA;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA+C/B,CAAC"}

package/dist/next/fractions/sales/createNftFractions.routes.js

@@ -0,0 +1,59 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { buildCreateNftFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { createController } from "../../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../../common/index.js";
+import { CreateNftFractionsRequestSchema } from "./createNftFractions.schema.js";
+const route = describeRoute({
+    summary: "Create NFT fractions",
+    description: "Returns transaction data for wrapping ERC-721 tokens (NFTs) and creating ERC-20 compatible fractions. " +
+        "The NFT owner must first approve the market contract to transfer their NFTs.",
+    tags: ["NFT Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for creating NFT fractions",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+/**
+ * Controller for the create NFT fractions endpoint
+ */
+export const CreateNftFractionsV0 = createController({
+    build: (factory) => factory.createApp().post("/", route, validator("json", CreateNftFractionsRequestSchema), async (c) => {
+        const { chainId, market, nft, fractions, timeBoundary, cap, funding, amountOfPacketsPerFraction, vesting, refundAddress, } = c.req.valid("json");
+        const tx = buildCreateNftFractionsTx({
+            chainId: chainId,
+            market: market,
+            nft: {
+                contractAddress: nft.contractAddress,
+                tokenIds: nft.tokenIds,
+            },
+            fractions: {
+                name: fractions.name,
+                symbol: fractions.symbol,
+                amount: fractions.amount,
+            },
+            timeBoundary: {
+                start: new Date(timeBoundary.start),
+                end: new Date(timeBoundary.end),
+            },
+            cap: cap,
+            funding: funding,
+            amountOfPacketsPerFraction: amountOfPacketsPerFraction,
+            vesting: vesting
+                ? {
+                    cliff: new Date(vesting.cliff),
+                    totalVestingPeriod: vesting.totalVestingPeriod,
+                    portionPeriod: vesting.portionPeriod,
+                }
+                : undefined,
+            refundAddress: refundAddress,
+        });
+        return c.json(toTransaction(tx));
+    }),
+});

package/dist/next/fractions/sales/createNftFractions.schema.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+/**
+ * Time boundary schema for sale period
+ */
+export declare const TimeBoundarySchema: 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>;
+/**
+ * Capitalization schema for sale limits
+ */
+export declare const CapitalizationSchema: 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>;
+/**
+ * NFT details schema for ERC-721 tokens to be wrapped
+ */
+export declare const NftDetailsSchema: z.ZodObject<{
+    contractAddress: 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>;
+/**
+ * Fraction configuration schema
+ */
+export declare const FractionSchema: z.ZodObject<{
+    name: z.ZodString;
+    symbol: z.ZodString;
+    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+/**
+ * Funding configuration schema for payment tokens
+ */
+export declare const FundingSchema: 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>;
+/**
+ * Vesting configuration schema
+ */
+export declare const VestingSchema: z.ZodObject<{
+    cliff: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+    totalVestingPeriod: z.ZodNumber;
+    portionPeriod: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Request schema for creating NFT fractions
+ */
+export declare const CreateNftFractionsRequestSchema: 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}`>>;
+    nft: z.ZodObject<{
+        contractAddress: 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>;
+    fractions: z.ZodObject<{
+        name: z.ZodString;
+        symbol: 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>;
+    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>>;
+    amountOfPacketsPerFraction: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    vesting: z.ZodOptional<z.ZodObject<{
+        cliff: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+        totalVestingPeriod: z.ZodNumber;
+        portionPeriod: 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}`>>;
+}, z.core.$strip>;
+//# sourceMappingURL=createNftFractions.schema.d.ts.map

package/dist/next/fractions/sales/createNftFractions.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNftFractions.schema.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/sales/createNftFractions.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;iBAK/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;iBAIzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;iBAGxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;iBAIxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAaC,CAAC"}