@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/fractions/sales/completeSale.route.js

@@ -0,0 +1,35 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { buildFinishSaleTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
+export const CompleteSaleRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    campaignId: Int256BigInt(z.bigint().nonnegative()),
+});
+const route = describeRoute({
+    summary: "Complete a sale",
+    description: "Returns transaction data for completing a sale",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for completing a sale",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CompleteSaleV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", CompleteSaleRequestSchema.openapi("CompleteSaleRequestSchema")), async (c) => {
+        const { marketAddress, campaignId } = c.req.valid("json");
+        const tx = buildFinishSaleTx({ market: marketAddress, campaignId: campaignId });
+        return c.json(toTransaction(tx));
+    }),
+});

package/dist/fractions/sales/createFractions.route.d.ts

@@ -0,0 +1,71 @@
+export declare const CreateFractionsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    market: string;
+                    fractions: {
+                        symbol: string;
+                        name: string;
+                        amount: string;
+                        token?: string | undefined;
+                    };
+                    timeBoundary: {
+                        start: string;
+                        end: string;
+                    };
+                    cap: {
+                        soft: string;
+                        hard: string;
+                        softPerAccount?: string | undefined;
+                        hardPerAccount?: string | undefined;
+                    };
+                    wrapped: ({
+                        type: "ERC20";
+                        address: string;
+                        values: string[];
+                    } | {
+                        type: "ERC721";
+                        address: string;
+                        tokenIds: string[];
+                    } | {
+                        type: "ERC1155";
+                        address: string;
+                        tokenIds: string[];
+                        values: string[];
+                    })[];
+                    funding: {
+                        token: string;
+                        amountPerPacket: string;
+                    }[];
+                    refundAddress: string;
+                    amountOfPacketsPerFraction: string;
+                    discounts?: {
+                        burnableTokenAddress: string;
+                        amountToBurn: string;
+                        percentDiscount: number;
+                    } | undefined;
+                    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=createFractions.route.d.ts.map

package/dist/fractions/sales/createFractions.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFractions.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/createFractions.route.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmD5B,CAAC"}

package/dist/fractions/sales/createFractions.route.js

@@ -0,0 +1,51 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { buildCreateFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../common/index.js";
+import { CreateFractionsRequestSchema, createWrapped } from "./createFractions.schema.js";
+const route = describeRoute({
+    summary: "Create fractions",
+    description: "Returns transaction data for creating fractions",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for creating fractions",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateFractionsV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", CreateFractionsRequestSchema.openapi("CreateFractionsRequestSchema")), async (c) => {
+        const { chainId, market, wrapped, funding, fractions, timeBoundary, cap, vesting, amountOfPacketsPerFraction, refundAddress, discounts, } = c.req.valid("json");
+        const wrappedTokens = wrapped.map(createWrapped);
+        const fractionsConfig = {
+            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,
+            vesting: vesting,
+        };
+        const tx = buildCreateFractionsTx(fractionsConfig);
+        return c.json(toTransaction(tx));
+    }),
+});

package/dist/fractions/sales/createFractions.schema.d.ts

@@ -0,0 +1,123 @@
+import { z } from "zod";
+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>;
+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>;
+export declare const ERC20TokenSchema: 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>;
+export declare const ERC721TokenSchema: 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>;
+export declare const ERC1155TokenSchema: 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>;
+export declare const WrappedTokenTypeSchema: 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>]>;
+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>;
+export declare const FractionSchema: 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>;
+export declare const BurnForDiscountSchema: 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>;
+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>;
+export declare const CreateFractionsRequestSchema: 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>>;
+    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}`>>;
+    amountOfPacketsPerFraction: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare function createWrapped(token: z.infer<typeof WrappedTokenTypeSchema>): {
+    type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum;
+    tokenAddress: `0x${string}`;
+    amount: bigint;
+    toParams: () => readonly [readonly [`0x${string}`], readonly [bigint], readonly [bigint], readonly [bigint]];
+} | {
+    type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum;
+    tokenAddress: `0x${string}`;
+    tokenIds: bigint[];
+    toParams: () => readonly [`0x${string}`[], bigint[], bigint[], bigint[]];
+};
+//# sourceMappingURL=createFractions.schema.d.ts.map

package/dist/fractions/sales/createFractions.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFractions.schema.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/createFractions.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;iBAK/B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;iBAI3B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;iBAK7B,CAAC;AAGH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;mBAAqE,CAAC;AAGzG,eAAO,MAAM,aAAa;;;iBAGxB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;iBAKzB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAC;AAEH,eAAO,MAAM,aAAa;;;;iBAIxB,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYvC,CAAC;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC;;;;;;;;;;EAS1E"}

package/dist/fractions/sales/createFractions.schema.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { createWrappedErc20, createWrappedErc721, createWrappedErc1155 } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { AddressSchema, FractionsChainId } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
+import { ISODate } from "../../common/models/date.js";
+import { PercentageSchema } from "../../common/models/index.js";
+// TimeBoundarySchema: Represents a time range with start and end dates
+export const TimeBoundarySchema = z.object({
+    start: ISODate(),
+    end: ISODate(),
+});
+// CapitalizationSchema: Represents the capitalization details of a market
+export const CapitalizationSchema = z.object({
+    soft: Int256BigInt(z.bigint().positive()),
+    hard: Int256BigInt(z.bigint().positive()),
+    softPerAccount: Int256BigInt(z.bigint().positive()).optional(),
+    hardPerAccount: Int256BigInt(z.bigint().positive()).optional(),
+});
+export const ERC20TokenSchema = z.object({
+    type: z.literal("ERC20"),
+    address: AddressSchema,
+    values: Int256BigInt().array().nonempty(),
+});
+export const ERC721TokenSchema = z.object({
+    type: z.literal("ERC721"),
+    address: AddressSchema,
+    tokenIds: Int256BigInt().array().nonempty(),
+});
+export const ERC1155TokenSchema = z.object({
+    type: z.literal("ERC1155"),
+    address: AddressSchema,
+    tokenIds: Int256BigInt().array().nonempty(),
+    values: Int256BigInt().array().nonempty(),
+});
+// Union schema to represent any of the three token types
+export const WrappedTokenTypeSchema = z.union([ERC20TokenSchema, ERC721TokenSchema, ERC1155TokenSchema]);
+// FundingSchema: Represents funding details for a market
+export const FundingSchema = z.object({
+    token: AddressSchema,
+    amountPerPacket: Int256BigInt(z.bigint().positive()),
+});
+export const FractionSchema = z.object({
+    token: AddressSchema.optional().describe("DO NOT USE. This field will be removed"),
+    symbol: z.string(),
+    name: z.string(),
+    amount: Int256BigInt(z.bigint().positive()),
+});
+export const BurnForDiscountSchema = z.object({
+    burnableTokenAddress: AddressSchema,
+    amountToBurn: Int256BigInt(z.bigint().positive()),
+    percentDiscount: PercentageSchema,
+});
+export const VestingSchema = z.object({
+    cliff: ISODate(),
+    totalVestingPeriod: z.number().positive(),
+    portionPeriod: z.number().positive(),
+});
+export const CreateFractionsRequestSchema = 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(),
+    vesting: VestingSchema.optional(),
+    refundAddress: AddressSchema,
+    amountOfPacketsPerFraction: Int256BigInt(z.bigint().positive()),
+});
+export 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/fractions/sales/createNftFractions.routes.d.ts

@@ -0,0 +1,180 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+/**
+ * Creates handlers for the create NFT fractions endpoint
+ */
+export declare function createNftFractionsTransactionV0<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;
+            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;
+        };
+    };
+    out: {
+        json: {
+            chainId: 1 | 11155111 | 31337 | 72080;
+            market: `0x${string}`;
+            nft: {
+                contractAddress: `0x${string}`;
+                tokenIds: bigint[];
+            };
+            fractions: {
+                name: string;
+                symbol: string;
+                amount: bigint;
+            };
+            timeBoundary: {
+                start: Date;
+                end: Date;
+            };
+            cap: {
+                soft: bigint;
+                hard: bigint;
+                softPerAccount?: bigint | undefined;
+                hardPerAccount?: bigint | undefined;
+            };
+            funding: {
+                token: `0x${string}`;
+                amountPerPacket: bigint;
+            }[];
+            amountOfPacketsPerFraction: bigint;
+            refundAddress: `0x${string}`;
+            vesting?: {
+                cliff: Date;
+                totalVestingPeriod: number;
+                portionPeriod: 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;
+            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;
+        };
+    };
+    out: {
+        json: {
+            chainId: 1 | 11155111 | 31337 | 72080;
+            market: `0x${string}`;
+            nft: {
+                contractAddress: `0x${string}`;
+                tokenIds: bigint[];
+            };
+            fractions: {
+                name: string;
+                symbol: string;
+                amount: bigint;
+            };
+            timeBoundary: {
+                start: Date;
+                end: Date;
+            };
+            cap: {
+                soft: bigint;
+                hard: bigint;
+                softPerAccount?: bigint | undefined;
+                hardPerAccount?: bigint | undefined;
+            };
+            funding: {
+                token: `0x${string}`;
+                amountPerPacket: bigint;
+            }[];
+            amountOfPacketsPerFraction: bigint;
+            refundAddress: `0x${string}`;
+            vesting?: {
+                cliff: Date;
+                totalVestingPeriod: number;
+                portionPeriod: 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=createNftFractions.routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNftFractions.routes.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/createNftFractions.routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAyBvC;;GAEG;AACH,wBAAgB,+BAA+B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA8CjF"}

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

@@ -0,0 +1,58 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { buildCreateNftFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+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),
+                },
+            },
+        },
+    },
+});
+/**
+ * Creates handlers for the create NFT fractions endpoint
+ */
+export function createNftFractionsTransactionV0(factory) {
+    return factory.createHandlers(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));
+    });
+}