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

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

@@ -1,4 +1,37 @@
 export declare const NextFractionsApi: import("../../common/controller.js").IApi<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    adminAddress: string;
+                    acceptedFundingTokens: string[];
+                    ownerAddress?: 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"> | import("hono/types").MergeSchemaPath<{
     "/": {
         $post: {
             input: {
@@ -32,7 +65,33 @@ export declare const NextFractionsApi: import("../../common/controller.js").IApi
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/deployNftFractions">, "/platforms"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/deployNftFractionsGated">, "/platforms"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    market: string;
+                    campaignId: string;
+                    chainId: unknown;
+                    amountToBuy: string;
+                    applyDiscount: boolean;
+                };
+            };
+            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<{
     "/": {
         $post: {
             input: {
@@ -85,7 +144,54 @@ export declare const NextFractionsApi: import("../../common/controller.js").IApi
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/nftFractions">, "/sales"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+}, "/nftFractions"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                campaignId: string;
+                creator: `0x${string}`;
+                nftId: string;
+                fractionsCreated: string;
+                fractionsAddress: `0x${string}`;
+                vaultAddress: `0x${string}` | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/getFractionsCreatedEvent">, "/sales"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    market: string;
+                    campaignId: string;
+                    chainId: unknown;
+                    amountToBuy: string;
+                    applyDiscount: boolean;
+                };
+            };
+            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<{
     "/": {
         $post: {
             input: {
@@ -198,31 +304,6 @@ export declare const NextFractionsApi: import("../../common/controller.js").IApi
         };
     };
 }, "/createSale"> | import("hono/types").MergeSchemaPath<{
-    "/": {
-        $post: {
-            input: {
-                json: {
-                    market: string;
-                    campaignId: string;
-                    chainId: unknown;
-                    amountToBuy: 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<{
     "/": {
         $post: {
             input: {

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":"AAKA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAS3B,CAAC"}

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

@@ -1,4 +1,30 @@
 export declare const LendingController: 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: {
+                    market: string;
+                    campaignId: string;
+                    chainId: unknown;
+                    amountToBuy: string;
+                    applyDiscount: boolean;
+                };
+            };
+            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<{
     "/": {
         $post: {
             input: {
@@ -111,31 +137,6 @@ export declare const LendingController: import("../../../common/controller.js").
         };
     };
 }, "/createSale"> | import("hono/types").MergeSchemaPath<{
-    "/": {
-        $post: {
-            input: {
-                json: {
-                    market: string;
-                    campaignId: string;
-                    chainId: unknown;
-                    amountToBuy: 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<{
     "/": {
         $post: {
             input: {

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/lending/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAS5B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/lending/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAS5B,CAAC"}

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

@@ -1,7 +1,7 @@
 import { createController } from "../../../common/controller.js";
+import { PurchaseV0 } from "../../../fractions/sales/purchase.route.js";
 import { BuybackV0 } from "./buyback/buyback.routes.js";
 import { DeployLendingMarketV0 } from "./deployMarket/lending.routes.js";
-import { DirectPurchaseV0 } from "./purchase/directPurchase.route.js";
 import { SetCollateralPriceV0 } from "./setCollateralPrice/setCollateralPrice.routes.js";
 import { CreateLendingSaleController } from "./createLendingSale.js";
 export const LendingController = createController({
@@ -9,7 +9,7 @@ export const LendingController = createController({
         .createApp()
         .route("/deploy", DeployLendingMarketV0.build(factory))
         .route("/createSale", CreateLendingSaleController.build(factory))
-        .route("/purchase", DirectPurchaseV0.build(factory))
+        .route("/purchase", PurchaseV0.build(factory))
         .route("/setCollateralPrice", SetCollateralPriceV0.build(factory))
         .route("/buyback", BuybackV0.build(factory)),
 });

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

@@ -0,0 +1,38 @@
+/**
+ * Controller for deploying an NFT Fractions market (non-gated)
+ */
+export declare const DeployNftFractionsMarketDefaultV0: 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;
+                    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/default/deployNftFractionsMarket.routes.d.ts.map

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

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

@@ -0,0 +1,39 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { createNftFractionsPlatformNoNid } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { createController } from "../../../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { DeployNftFractionsMarketDefaultRequestSchema } from "./deployNftFractionsMarket.schema.js";
+const route = describeRoute({
+    summary: "Deploy an NFT Fractions market",
+    description: "Returns transaction data for deploying an NFT Fractions market (non-gated). " +
+        "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 (non-gated)
+ */
+export const DeployNftFractionsMarketDefaultV0 = createController({
+    build: (factory) => factory.createApp().post("/", route, validator("json", DeployNftFractionsMarketDefaultRequestSchema), async (c) => {
+        const { chainId, adminAddress, ownerAddress, cap, fee, acceptedFundingTokens } = c.req.valid("json");
+        const tx = createNftFractionsPlatformNoNid({
+            chainId: chainId,
+            adminAddress: adminAddress,
+            ownerAddress: ownerAddress ?? adminAddress,
+            fee: fee ?? undefined,
+            maxHardCap: cap ? cap.maxHardCap : null,
+            acceptedFundingTokens: acceptedFundingTokens,
+        });
+        return c.json(toTransaction(tx));
+    }),
+});

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

@@ -0,0 +1,25 @@
+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 (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>[]]>>;
+    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<{
+        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/default/deployNftFractionsMarket.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployNftFractionsMarket.schema.d.ts","sourceRoot":"","sources":["../../../../../src/next/fractions/platforms/default/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,4CAA4C;;;;;;;;;;;;;iBAWC,CAAC"}

package/dist/{fractions/nftfractions/v0 → next/fractions/platforms/default}/deployNftFractionsMarket.schema.js

@@ -1,28 +1,23 @@
 import { z } from "zod";
-import { AddressSchema, NextFractionsChainId, PercentageSchema } from "../../../common/index.js";
+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: z.coerce.bigint().min(BigInt(1)).describe("Maximum hard cap for the market"),
+    maxHardCap: Int256BigInt(z.bigint().min(BigInt(1))).describe("Maximum hard cap for the market"),
 });
 /**
- * Fee configuration schema for market fees
+ * Request schema for deploying an NFT Fractions market (non-gated)
  */
-export const FeeConfigSchema = z.object({
-    percent: PercentageSchema.describe("Fee percentage in basis points"),
-});
-/**
- * Request schema for deploying an NFT Fractions market
- */
-export const DeployNftFractionsMarketRequestSchema = z
+export const DeployNftFractionsMarketDefaultRequestSchema = 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({ ref: "DeployNftFractionsMarketRequestSchema" });
+    .openapi("DeployNftFractionsMarketDefaultRequestSchema");

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

@@ -0,0 +1,39 @@
+/**
+ * Controller for deploying a gated NFT Fractions market (with ComPilot gating)
+ */
+export declare const DeployNftFractionsMarketGatedV0: 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/gated/deployNftFractionsMarket.routes.d.ts.map

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

package/dist/{fractions/platforms → next/fractions/platforms/gated}/deployNftFractionsMarket.routes.js

@@ -1,18 +1,17 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { zeroAddress } from "viem";
-import { getEnv, getEnvNumber } from "@evergonlabs/internal/node/getEnv";
 import { createNftFractionsPlatform } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { DEFAULT_COMPILOT_SIGNER, toTransaction, TransactionSchema } from "../../common/index.js";
-import { DeployNftFractionsMarketRequestSchema } from "./deployNftFractionsMarket.schema.js";
+import { createController } from "../../../../common/controller.js";
+import { DEFAULT_COMPILOT_SIGNER, toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { DeployNftFractionsMarketGatedRequestSchema } from "./deployNftFractionsMarket.schema.js";
 const route = describeRoute({
-    summary: "Deploy an NFT Fractions market",
+    summary: "Deploy a gated 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",
+            description: "Returns transaction data for deploying a gated NFT Fractions market",
             content: {
                 "application/json": {
                     schema: resolver(TransactionSchema),
@@ -22,31 +21,20 @@ const route = describeRoute({
     },
 });
 /**
- * Creates handlers for deploying an NFT Fractions market
+ * Controller for deploying a gated NFT Fractions market (with ComPilot gating)
  */
-export function createDeployNftFractionsMarketTransactionV0(factory) {
-    return factory.createHandlers(route, validator("json", DeployNftFractionsMarketRequestSchema), async (c) => {
+export const DeployNftFractionsMarketGatedV0 = createController({
+    build: (factory) => factory.createApp().post("/", route, validator("json", DeployNftFractionsMarketGatedRequestSchema), async (c) => {
         const { chainId, adminAddress, ownerAddress, compilotSignerAddress, cap, fee, acceptedFundingTokens } = c.req.valid("json");
-        const platformFee = getFeeConfig();
         const tx = createNftFractionsPlatform({
             chainId: chainId,
             adminAddress: adminAddress,
             ownerAddress: ownerAddress ?? adminAddress,
             compilotSignerAddress: compilotSignerAddress ?? DEFAULT_COMPILOT_SIGNER,
-            fee: { ...platformFee, ...fee },
+            fee: fee ?? null,
             maxHardCap: cap ? cap.maxHardCap : null,
             acceptedFundingTokens: acceptedFundingTokens,
         });
         return c.json(toTransaction(tx));
-    });
-}
-/**
- * Gets the default fee configuration from environment variables
- */
-function getFeeConfig() {
-    return {
-        percent: getEnvNumber("PLATFORM_FEE_SIZE_BP", 0),
-        collectorAddress: getEnv("PLATFORM_FEE_COLLECTOR_ADDRESS", zeroAddress),
-        feeAdmin: getEnv("PLATFORM_FEE_ADMIN", zeroAddress),
-    };
-}
+    }),
+});

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

@@ -6,15 +6,9 @@ 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>;
 /**
- * Fee configuration schema for market fees
+ * Request schema for deploying a gated NFT Fractions market (with ComPilot gating)
  */
-export declare const FeeConfigSchema: z.ZodObject<{
-    percent: z.ZodNumber;
-}, z.core.$strip>;
-/**
- * Request schema for deploying an NFT Fractions market
- */
-export declare const DeployNftFractionsMarketRequestSchema: z.ZodObject<{
+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>[]]>>;
     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}`>>>;
@@ -24,6 +18,8 @@ export declare const DeployNftFractionsMarketRequestSchema: z.ZodObject<{
     }, 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>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"deployNftFractionsMarket.schema.d.ts","sourceRoot":"","sources":["../../../../../src/next/fractions/platforms/gated/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,0CAA0C;;;;;;;;;;;;;;iBAcC,CAAC"}

package/dist/{fractions/platforms → next/fractions/platforms/gated}/deployNftFractionsMarket.schema.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
-import { AddressSchema, NextFractionsChainId, PercentageSchema } from "../../common/index.js";
-import { Int256BigInt } from "../../common/int256.js";
+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
  */
@@ -8,15 +9,9 @@ export const CapConfigSchema = z.object({
     maxHardCap: Int256BigInt(z.bigint().min(BigInt(1))).describe("Maximum hard cap for the market"),
 });
 /**
- * Fee configuration schema for market fees
+ * Request schema for deploying a gated NFT Fractions market (with ComPilot gating)
  */
-export const FeeConfigSchema = z.object({
-    percent: PercentageSchema.describe("Fee percentage in basis points"),
-});
-/**
- * Request schema for deploying an NFT Fractions market
- */
-export const DeployNftFractionsMarketRequestSchema = z
+export const DeployNftFractionsMarketGatedRequestSchema = z
     .object({
     chainId: NextFractionsChainId.describe("Chain ID where the market will be deployed"),
     adminAddress: AddressSchema.describe("Address of the market administrator"),
@@ -26,4 +21,4 @@ export const DeployNftFractionsMarketRequestSchema = z
     fee: FeeConfigSchema.optional().describe("Optional fee configuration"),
     acceptedFundingTokens: z.array(AddressSchema).describe("Accepted funding token addresses"),
 })
-    .openapi("DeployNftFractionsMarketRequestSchema");
+    .openapi("DeployNftFractionsMarketGatedRequestSchema");

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

@@ -1,4 +1,37 @@
 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;
+                    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"> | import("hono/types").MergeSchemaPath<{
     "/": {
         $post: {
             input: {
@@ -32,5 +65,5 @@ export declare const PlatformsController: import("../../../common/controller.js"
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/deployNftFractions">, "/", "/">>;
+}, "/deployNftFractionsGated">, "/", "/">>;
 //# sourceMappingURL=index.d.ts.map

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

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

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

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

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { AddressSchema, FractionsChainId } from "../../../common/index.js";
 import { Int256BigInt } from "../../../common/int256.js";
-import { ISODate } from "../../../common/models/date.js";
+import { ISODate } from "../../../common/models/base/date.js";
 /**
  * Time boundary schema for sale period
  */