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

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

@@ -1,13 +0,0 @@
-import { z } from "zod";
-import { FractionsChainId } from "../../../../common/index.js";
-import { Int256BigInt } from "../../../../common/int256.js";
-import { SaleIdSchema } from "../../../../common/models/saleId.js";
-export const BuybackRequestSchema = z
-    .object({
-    chainId: FractionsChainId,
-    buybackPacketsAmount: Int256BigInt().openapi({
-        description: "Amount of packets to buyback (with interest)",
-    }),
-})
-    .extend(SaleIdSchema.shape)
-    .openapi("BuybackRequestSchema");

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

@@ -1,130 +0,0 @@
-import { z } from "zod";
-export declare const BuyBackConfigSchema: z.ZodObject<{
-    durationSeconds: z.ZodNumber;
-    interestPercentage: z.ZodNumber;
-    liquidationLimitPercentage: z.ZodNumber;
-    marginCallLimitPercentage: z.ZodNumber;
-}, z.core.$strip>;
-export declare const CreateLendingFractionsRequestSchema: z.ZodObject<{
-    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 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}`>>>;
-        symbol: z.ZodString;
-        name: z.ZodString;
-        amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    }, z.core.$strip>;
-    timeBoundary: z.ZodObject<{
-        start: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
-        end: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
-    }, z.core.$strip>;
-    cap: z.ZodObject<{
-        soft: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-        hard: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-        softPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
-        hardPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
-    }, z.core.$strip>;
-    wrapped: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        type: z.ZodLiteral<"ERC20">;
-        address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        values: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"ERC721">;
-        address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        tokenIds: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"ERC1155">;
-        address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        tokenIds: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
-        values: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
-    }, z.core.$strip>]>>;
-    funding: z.ZodArray<z.ZodObject<{
-        token: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        amountPerPacket: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    }, z.core.$strip>>;
-    discounts: z.ZodOptional<z.ZodObject<{
-        burnableTokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-        amountToBurn: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-        percentDiscount: z.ZodNumber;
-    }, z.core.$strip>>;
-    refundAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    amountOfPacketsPerFraction: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    buyback: z.ZodObject<{
-        durationSeconds: z.ZodNumber;
-        interestPercentage: z.ZodNumber;
-        liquidationLimitPercentage: z.ZodNumber;
-        marginCallLimitPercentage: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const CreateLendingSaleController: 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;
-                    buyback: {
-                        durationSeconds: number;
-                        interestPercentage: number;
-                        liquidationLimitPercentage: number;
-                        marginCallLimitPercentage: number;
-                    };
-                    discounts?: {
-                        burnableTokenAddress: string;
-                        amountToBurn: string;
-                        percentDiscount: 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=createLendingSale.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"createLendingSale.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/lending/createLendingSale.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoBxB,eAAO,MAAM,mBAAmB;;;;;iBAK9B,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY9C,CAAC;AAkBH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAmDtC,CAAC"}

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

@@ -1,82 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
-import { buildCreateLendingFractionsTx, createWrappedErc20, createWrappedErc721, createWrappedErc1155, } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { createController } from "../../../common/controller.js";
-import { AddressSchema, FractionsChainId, toTransaction, TransactionSchema } from "../../../common/index.js";
-import { Int256BigInt } from "../../../common/int256.js";
-import { BurnForDiscountSchema, CapitalizationSchema, FractionSchema, FundingSchema, TimeBoundarySchema, WrappedTokenTypeSchema, } from "../../../fractions/sales/createFractions.schema.js";
-export const BuyBackConfigSchema = z.object({
-    durationSeconds: z.number().int().positive(),
-    interestPercentage: z.number().int().min(0).max(10000),
-    liquidationLimitPercentage: z.number().int().min(0).max(10000),
-    marginCallLimitPercentage: z.number().int().min(0).max(10000),
-});
-export const CreateLendingFractionsRequestSchema = z.object({
-    chainId: FractionsChainId,
-    market: AddressSchema,
-    fractions: FractionSchema,
-    timeBoundary: TimeBoundarySchema,
-    cap: CapitalizationSchema,
-    wrapped: z.array(WrappedTokenTypeSchema).nonempty(),
-    funding: z.array(FundingSchema).nonempty(),
-    discounts: BurnForDiscountSchema.optional(),
-    refundAddress: AddressSchema,
-    amountOfPacketsPerFraction: Int256BigInt(z.bigint().positive()),
-    buyback: BuyBackConfigSchema,
-});
-const route = describeRoute({
-    summary: "Create financing sale fractions",
-    description: "Returns transaction data for creating financing sale fractions",
-    tags: ["Financing"],
-    responses: {
-        200: {
-            description: "Returns transaction data for creating financing sale fractions",
-            content: {
-                "application/json": {
-                    schema: resolver(TransactionSchema),
-                },
-            },
-        },
-    },
-});
-export const CreateLendingSaleController = createController({
-    build: (factory) => factory
-        .createApp()
-        .post("/", route, validator("json", CreateLendingFractionsRequestSchema.openapi("CreateLendingFractionsRequestSchema")), async (c) => {
-        const { chainId, market, wrapped, funding, fractions, timeBoundary, cap, amountOfPacketsPerFraction, refundAddress, discounts, buyback, } = c.req.valid("json");
-        const wrappedTokens = wrapped.map(createWrapped);
-        const lendingFractionsConfig = {
-            chainId: chainId,
-            market: market,
-            wrapped: wrappedTokens,
-            funding: funding,
-            fractions: {
-                name: fractions.name,
-                symbol: fractions.symbol,
-                amount: fractions.amount,
-            },
-            timeBoundary: {
-                start: new Date(timeBoundary.start),
-                end: new Date(timeBoundary.end),
-            },
-            discounts: discounts,
-            cap: cap,
-            amountOfPacketsPerFraction: amountOfPacketsPerFraction,
-            refundAddress: refundAddress,
-            buyback: buyback,
-        };
-        const tx = buildCreateLendingFractionsTx(lendingFractionsConfig);
-        return c.json(toTransaction(tx));
-    }),
-});
-function createWrapped(token) {
-    switch (token.type) {
-        case "ERC20":
-            return createWrappedErc20(token.address, token.values[0]);
-        case "ERC721":
-            return createWrappedErc721(token.address, token.tokenIds);
-        case "ERC1155":
-            return createWrappedErc1155(token.address, token.tokenIds, token.values);
-    }
-}

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

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

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

@@ -1,15 +0,0 @@
-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 { SetCollateralPriceV0 } from "./setCollateralPrice/setCollateralPrice.routes.js";
-import { CreateLendingSaleController } from "./createLendingSale.js";
-export const LendingController = createController({
-    build: (factory) => factory
-        .createApp()
-        .route("/deploy", DeployLendingMarketV0.build(factory))
-        .route("/createSale", CreateLendingSaleController.build(factory))
-        .route("/purchase", PurchaseV0.build(factory))
-        .route("/setCollateralPrice", SetCollateralPriceV0.build(factory))
-        .route("/buyback", BuybackV0.build(factory)),
-});

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

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

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

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

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

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

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

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

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

@@ -1,7 +0,0 @@
-import { z } from "zod";
-export declare const SetCollateralPriceRequestSchema: z.ZodObject<{
-    collateralPriceInFundingPackets: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    campaignId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-}, z.core.$strip>;
-//# sourceMappingURL=setCollateralPrice.schema.d.ts.map

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

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

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

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

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

@@ -1 +0,0 @@
-{"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.schema.d.ts

@@ -1,25 +0,0 @@
-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 | 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<{
-        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

@@ -1 +0,0 @@
-{"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/next/fractions/platforms/default/deployNftFractionsMarket.schema.js

@@ -1,23 +0,0 @@
-import { z } from "zod";
-import { AddressSchema, NextFractionsChainId } from "../../../../common/index.js";
-import { Int256BigInt } from "../../../../common/int256.js";
-import { FeeConfigSchema } from "../../../../fractions/markets/deployMarket.schema.js";
-/**
- * Cap configuration schema for market limits
- */
-export const CapConfigSchema = z.object({
-    maxHardCap: Int256BigInt(z.bigint().min(BigInt(1))).describe("Maximum hard cap for the market"),
-});
-/**
- * Request schema for deploying an NFT Fractions market (non-gated)
- */
-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"),
-    cap: CapConfigSchema.optional().describe("Optional cap configuration"),
-    fee: FeeConfigSchema.optional().describe("Optional fee configuration"),
-    acceptedFundingTokens: z.array(AddressSchema).describe("Accepted funding token addresses"),
-})
-    .openapi("DeployNftFractionsMarketDefaultRequestSchema");

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

@@ -1 +0,0 @@
-{"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/next/fractions/platforms/gated/deployNftFractionsMarket.schema.d.ts

@@ -1,26 +0,0 @@
-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 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 | 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}`>>>;
-    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/gated/deployNftFractionsMarket.schema.d.ts.map

@@ -1 +0,0 @@
-{"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/next/fractions/platforms/gated/deployNftFractionsMarket.schema.js

@@ -1,24 +0,0 @@
-import { z } from "zod";
-import { AddressSchema, NextFractionsChainId } from "../../../../common/index.js";
-import { Int256BigInt } from "../../../../common/int256.js";
-import { FeeConfigSchema } from "../../../../fractions/markets/deployMarket.schema.js";
-/**
- * Cap configuration schema for market limits
- */
-export const CapConfigSchema = z.object({
-    maxHardCap: Int256BigInt(z.bigint().min(BigInt(1))).describe("Maximum hard cap for the market"),
-});
-/**
- * Request schema for deploying a gated NFT Fractions market (with ComPilot gating)
- */
-export const DeployNftFractionsMarketGatedRequestSchema = 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("DeployNftFractionsMarketGatedRequestSchema");

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

@@ -1,69 +0,0 @@
-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: {
-                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;
-        };
-    };
-}, "/deployNftFractionsGated">, "/", "/">>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"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,9 +0,0 @@
-import { createController } from "../../../common/controller.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", DeployNftFractionsMarketDefaultV0.build(factory))
-        .route("/deployNftFractionsGated", DeployNftFractionsMarketGatedV0.build(factory)),
-});

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

@@ -1 +0,0 @@
-{"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"}