@evergonlabs/tmi-protocol-api 0.10.1 → 0.11.0-rc.0

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

@@ -98,10 +98,20 @@ export declare const NextFractionsApi: import("../../common/controller.js").IApi
                 json: {
                     chainId: unknown;
                     market: string;
-                    nft: {
-                        contractAddress: string;
+                    wrapped: ({
+                        type: "ERC20";
+                        address: string;
+                        values: string[];
+                    } | {
+                        type: "ERC721";
+                        address: string;
                         tokenIds: string[];
-                    };
+                    } | {
+                        type: "ERC1155";
+                        address: string;
+                        tokenIds: string[];
+                        values: string[];
+                    })[];
                     fractions: {
                         name: string;
                         symbol: string;
@@ -352,5 +362,310 @@ export declare const NextFractionsApi: import("../../common/controller.js").IApi
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/buyback">, "/lending">, "/", "/">>;
+}, "/buyback">, "/lending"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    adminAddress: string;
+                    acceptedFundingTokens: string[];
+                    ownerAddress?: string | undefined;
+                    platformEntryFee?: {
+                        collectorAddress: string;
+                        basisPoints: number;
+                    } | undefined;
+                    platformExitFee?: {
+                        collectorAddress: string;
+                        basisPoints: number;
+                    } | undefined;
+                    receiptNft?: {
+                        baseName: string;
+                        baseSymbol: 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;
+        };
+    };
+}, "/deployMarket"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    market: string;
+                    nft: {
+                        contractAddress: string;
+                        tokenId: string;
+                    };
+                    fractions: {
+                        name: string;
+                        symbol: string;
+                    };
+                    refundAddress: string;
+                    funding: {
+                        token: string;
+                        amountPerPacket: string;
+                    };
+                    startDate: string;
+                    softCapPerPurchase: string;
+                    hardCapPerAccount: string;
+                    fundsReceiver: string;
+                    priceSetter: string;
+                    fundsProvider: string;
+                    issuerEntryFee?: {
+                        collectorAddress: string;
+                        proportion: string;
+                    } | undefined;
+                    issuerExitFee?: {
+                        collectorAddress: string;
+                        proportion: 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;
+        };
+    };
+}, "/createCampaign"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    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;
+        };
+    };
+}, "/approveCampaign"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    market: string;
+                    campaignId: string;
+                    price: 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;
+        };
+    };
+}, "/setEpochPrice"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    market: string | string[];
+                    campaignId: string | string[];
+                };
+            };
+            output: {
+                currentEpoch: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/getCurrentEpoch"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    market: string | string[];
+                    campaignId: string | string[];
+                    epoch: string | string[];
+                };
+            };
+            output: {
+                price: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/getPurchasePriceForEpoch"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    market: string;
+                    campaignId: string;
+                    amountToProvide: 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;
+        };
+    };
+}, "/purchase"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                campaignId: string;
+                nftId: string;
+                purchaser: `0x${string}`;
+                amountProvided: string;
+                amountAfterFees: string;
+                epochPurchased: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/getEpochPurchaseEvent"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    market: string;
+                    campaignId: string;
+                    nftId: 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;
+        };
+    };
+}, "/exchangeNftForFractions"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    market: string;
+                    campaignId: string;
+                    amountOfFractions: 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;
+        };
+    };
+}, "/requestWithdrawal"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                campaignId: string;
+                nftId: string;
+                requester: `0x${string}`;
+                amountOfFractions: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/getWithdrawalRequestedEvent"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    market: string;
+                    campaignId: string;
+                    nftId: 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;
+        };
+    };
+}, "/withdraw">, "/vestingRedemptionDynamic">, "/", "/">>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/next/fractions/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAS3B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/next/fractions/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAU3B,CAAC"}

package/dist/next/fractions/index.js

@@ -2,6 +2,7 @@ import { createApi } from "../../common/controller.js";
 import { LendingController } from "./lending/index.js";
 import { PlatformsController } from "./platforms/index.js";
 import { SalesController } from "./sales/index.js";
+import { VestingRedemptionDynamicController } from "./vestingRedemptionDynamic/index.js";
 export const NextFractionsApi = createApi({
     title: "Next Fraction API",
     description: "NFT Fractions and Financing markets (next-gen SDK)",
@@ -9,5 +10,6 @@ export const NextFractionsApi = createApi({
         .createApp()
         .route("/platforms", PlatformsController.build(factory))
         .route("/sales", SalesController.build(factory))
-        .route("/lending", LendingController.build(factory)),
+        .route("/lending", LendingController.build(factory))
+        .route("/vestingRedemptionDynamic", VestingRedemptionDynamicController.build(factory)),
 });

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

@@ -1,6 +1,6 @@
 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>[]]>>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 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">>>;

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

@@ -6,7 +6,7 @@ export declare const BuyBackConfigSchema: z.ZodObject<{
     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>[]]>>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 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}`>>>;

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

@@ -1,6 +1,6 @@
 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>[]]>>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<11155111 | 31337 | 84532 | 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<{

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

@@ -1,7 +1,7 @@
 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";
+import { CapConfigSchema, DiscountConfigSchema, FeeConfigSchema, } from "../../../fractions/markets/deployMarket.schema.js";
 export const DeployLendingMarketRequestSchema = z
     .object({
     chainId: NextFractionsChainId,

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

@@ -9,7 +9,7 @@ export declare const CapConfigSchema: z.ZodObject<{
  * Request schema for deploying an NFT Fractions market (non-gated)
  */
 export declare const DeployNftFractionsMarketDefaultRequestSchema: 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>[]]>>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<11155111 | 31337 | 84532 | 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}`>>>;
     cap: z.ZodOptional<z.ZodObject<{

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

@@ -1,7 +1,7 @@
 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";
+import { FeeConfigSchema } from "../../../../fractions/markets/deployMarket.schema.js";
 /**
  * Cap configuration schema for market limits
  */

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

@@ -9,7 +9,7 @@ export declare const CapConfigSchema: z.ZodObject<{
  * Request schema for deploying a gated NFT Fractions market (with ComPilot gating)
  */
 export declare const DeployNftFractionsMarketGatedRequestSchema: 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>[]]>>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<11155111 | 31337 | 84532 | 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}`>>>;

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

@@ -1,7 +1,7 @@
 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";
+import { FeeConfigSchema } from "../../../../fractions/markets/deployMarket.schema.js";
 /**
  * Cap configuration schema for market limits
  */

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

@@ -8,10 +8,20 @@ export declare const CreateNftFractionsV0: import("../../../common/controller.js
                 json: {
                     chainId: unknown;
                     market: string;
-                    nft: {
-                        contractAddress: string;
+                    wrapped: ({
+                        type: "ERC20";
+                        address: string;
+                        values: string[];
+                    } | {
+                        type: "ERC721";
+                        address: string;
                         tokenIds: string[];
-                    };
+                    } | {
+                        type: "ERC1155";
+                        address: string;
+                        tokenIds: string[];
+                        values: string[];
+                    })[];
                     fractions: {
                         name: string;
                         symbol: string;

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA+C/B,CAAC"}
+{"version":3,"file":"createNftFractions.routes.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/sales/createNftFractions.routes.ts"],"names":[],"mappings":"AAgCA;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8C/B,CAAC"}

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

@@ -1,13 +1,13 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { buildCreateNftFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { buildCreateNftFractionsTx, createWrappedErc20, createWrappedErc721, createWrappedErc1155, } 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.",
+    description: "Returns transaction data for wrapping assets and creating ERC-20 compatible fractions. " +
+        "The asset owner must first approve the wrapper to transfer the wrapped tokens.",
     tags: ["NFT Fractions"],
     responses: {
         200: {
@@ -25,14 +25,12 @@ const route = describeRoute({
  */
 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 { chainId, market, wrapped, fractions, timeBoundary, cap, funding, amountOfPacketsPerFraction, vesting, refundAddress, } = c.req.valid("json");
+        const wrappedTokens = wrapped.map(createWrapped);
         const tx = buildCreateNftFractionsTx({
             chainId: chainId,
             market: market,
-            nft: {
-                contractAddress: nft.contractAddress,
-                tokenIds: nft.tokenIds,
-            },
+            wrapped: wrappedTokens,
             fractions: {
                 name: fractions.name,
                 symbol: fractions.symbol,
@@ -57,3 +55,13 @@ export const CreateNftFractionsV0 = createController({
         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/next/fractions/sales/createNftFractions.schema.d.ts

@@ -15,13 +15,6 @@ export declare const CapitalizationSchema: z.ZodObject<{
     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
  */
@@ -49,12 +42,22 @@ export declare const VestingSchema: z.ZodObject<{
  * 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>[]]>>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 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}`>>;
+    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.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>]>>;
     fractions: z.ZodObject<{
         name: z.ZodString;
         symbol: z.ZodString;

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

@@ -1 +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"}
+{"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;AAMxB;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;iBAK/B,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"}

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

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { AddressSchema, FractionsChainId } from "../../../common/index.js";
 import { Int256BigInt } from "../../../common/int256.js";
 import { ISODate } from "../../../common/models/base/date.js";
+import { WrappedTokenTypeSchema } from "../../../fractions/sales/createFractions.schema.js";
 /**
  * Time boundary schema for sale period
  */
@@ -18,13 +19,6 @@ export const CapitalizationSchema = z.object({
     softPerAccount: Int256BigInt(z.bigint().positive()).optional().describe("Optional soft cap per account"),
     hardPerAccount: Int256BigInt(z.bigint().positive()).optional().describe("Optional hard cap per account"),
 });
-/**
- * NFT details schema for ERC-721 tokens to be wrapped
- */
-export const NftDetailsSchema = z.object({
-    contractAddress: AddressSchema.describe("ERC-721 contract address"),
-    tokenIds: z.array(Int256BigInt(z.bigint().nonnegative())).nonempty().describe("Token IDs to wrap"),
-});
 /**
  * Fraction configuration schema
  */
@@ -55,7 +49,7 @@ export const CreateNftFractionsRequestSchema = z
     .object({
     chainId: FractionsChainId.describe("Chain ID where the market is deployed"),
     market: AddressSchema.describe("Address of the NFT Fractions market"),
-    nft: NftDetailsSchema.describe("NFT details to wrap"),
+    wrapped: z.array(WrappedTokenTypeSchema).nonempty().describe("Wrapped asset details to include in the sale"),
     fractions: FractionSchema.describe("Fraction token configuration"),
     timeBoundary: TimeBoundarySchema.describe("Purchase time window"),
     cap: CapitalizationSchema.describe("Capitalization limits"),

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

@@ -31,10 +31,20 @@ export declare const SalesController: import("../../../common/controller.js").IC
                 json: {
                     chainId: unknown;
                     market: string;
-                    nft: {
-                        contractAddress: string;
+                    wrapped: ({
+                        type: "ERC20";
+                        address: string;
+                        values: string[];
+                    } | {
+                        type: "ERC721";
+                        address: string;
                         tokenIds: string[];
-                    };
+                    } | {
+                        type: "ERC1155";
+                        address: string;
+                        tokenIds: string[];
+                        values: string[];
+                    })[];
                     fractions: {
                         name: string;
                         symbol: string;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/sales/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAO1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/sales/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAO1B,CAAC"}