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

package/dist/next/{fractions/platforms/gated/deployNftFractionsMarket.routes.d.ts → nftFractions/deployNftFractionsMarketGated.d.ts}

@@ -1,24 +1,24 @@
 /**
  * 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, {
+export declare const DeployNftFractionsMarketGatedV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    chainId: unknown;
+                    chainId: "31337" | "11155111" | "84532" | "72080";
                     adminAddress: string;
                     acceptedFundingTokens: string[];
                     ownerAddress?: string | undefined;
-                    compilotSignerAddress?: string | undefined;
                     cap?: {
                         maxHardCap: string;
                     } | undefined;
                     fee?: {
-                        percent: number;
+                        percent: string;
                         collectorAddress: string;
                         feeAdmin: string;
                     } | undefined;
+                    compilotSignerAddress?: string | undefined;
                 };
             };
             output: {
@@ -36,4 +36,4 @@ export declare const DeployNftFractionsMarketGatedV0: import("../../../../common
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=deployNftFractionsMarket.routes.d.ts.map
+//# sourceMappingURL=deployNftFractionsMarketGated.d.ts.map

package/dist/next/nftFractions/deployNftFractionsMarketGated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployNftFractionsMarketGated.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/deployNftFractionsMarketGated.ts"],"names":[],"mappings":"AA2BA;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkB1C,CAAC"}

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

@@ -1,14 +1,15 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { createNftFractionsPlatform } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { createController } from "../../../../common/controller.js";
-import { DEFAULT_COMPILOT_SIGNER, toTransaction, TransactionSchema } from "../../../../common/index.js";
-import { DeployNftFractionsMarketGatedRequestSchema } from "./deployNftFractionsMarket.schema.js";
+import { DeployNftFractionsMarketGatedRequestSchema } from "./schemas.js";
+import { nftFractionsTag } from "./tag.js";
+import { createController } from "../../common/controller.js";
+import { DEFAULT_COMPILOT_SIGNER, toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     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"],
+    tags: [nftFractionsTag.tag],
     responses: {
         200: {
             description: "Returns transaction data for deploying a gated NFT Fractions market",

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

@@ -0,0 +1,182 @@
+export declare const NftFractionsApi: import("../../common/controller.js").IApi<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                    amountToBuy: string;
+                    tokenId?: string | undefined;
+                    burnForDiscount?: 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;
+        };
+    };
+}, "/purchase"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                    market: 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;
+                        amount: string;
+                    };
+                    timeBoundary: {
+                        start: string;
+                        end: string;
+                    };
+                    cap: {
+                        soft: string;
+                        hard: string;
+                        softPerAccount?: string | undefined;
+                        hardPerAccount?: string | undefined;
+                    };
+                    funding: {
+                        token: string;
+                        amountPerPacket: string;
+                    }[];
+                    amountOfPacketsPerFraction: string;
+                    refundAddress: string;
+                    vesting?: {
+                        cliff: string;
+                        totalVestingPeriod: number;
+                        portionPeriod: number;
+                    } | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/createFractions"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: "31337" | "11155111" | "84532" | "72080";
+                    hash: string;
+                };
+            };
+            output: {
+                campaignId: string;
+                creator: `0x${string}`;
+                nftId: string;
+                fractionsCreated: string;
+                fractionsAddress: `0x${string}`;
+                vaultAddress: `0x${string}` | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/getFractionsCreatedEvent"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: "31337" | "11155111" | "84532" | "72080";
+                    adminAddress: string;
+                    acceptedFundingTokens: string[];
+                    ownerAddress?: string | undefined;
+                    cap?: {
+                        maxHardCap: string;
+                    } | undefined;
+                    fee?: {
+                        percent: string;
+                        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: "31337" | "11155111" | "84532" | "72080";
+                    adminAddress: string;
+                    acceptedFundingTokens: string[];
+                    ownerAddress?: string | undefined;
+                    cap?: {
+                        maxHardCap: string;
+                    } | undefined;
+                    fee?: {
+                        percent: string;
+                        collectorAddress: string;
+                        feeAdmin: string;
+                    } | undefined;
+                    compilotSignerAddress?: 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/{fractions/platforms → next/nftFractions}/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fractions/platforms/index.ts"],"names":[],"mappings":"AAQA,cAAc,mCAAmC,CAAC;AAElD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAS9B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/index.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAW1B,CAAC"}

package/dist/next/nftFractions/index.js

@@ -0,0 +1,17 @@
+import { CreateNftFractionsV0 } from "./createNftFractions.js";
+import { DeployNftFractionsMarketDefaultV0 } from "./deployNftFractionsMarket.js";
+import { DeployNftFractionsMarketGatedV0 } from "./deployNftFractionsMarketGated.js";
+import { ParseNftFractionsCreatedEventV0 } from "./parseNftFractionsCreatedEvent.js";
+import { createApi } from "../../common/controller.js";
+import { PurchaseV0 } from "../../fractions/sales/purchase.route.js";
+export const NftFractionsApi = createApi({
+    title: "NFT Fractions API",
+    description: "NFT Fractions API",
+    build: (factory) => factory
+        .createApp()
+        .route("/createFractions", CreateNftFractionsV0.build(factory))
+        .route("/getFractionsCreatedEvent", ParseNftFractionsCreatedEventV0.build(factory))
+        .route("/purchase", PurchaseV0.build(factory))
+        .route("/deployNftFractions", DeployNftFractionsMarketDefaultV0.build(factory))
+        .route("/deployNftFractionsGated", DeployNftFractionsMarketGatedV0.build(factory)),
+});

package/dist/next/nftFractions/parseNftFractionsCreatedEvent.d.ts

@@ -0,0 +1,23 @@
+export declare const ParseNftFractionsCreatedEventV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: "31337" | "11155111" | "84532" | "72080";
+                    hash: string;
+                };
+            };
+            output: {
+                campaignId: string;
+                creator: `0x${string}`;
+                nftId: string;
+                fractionsCreated: string;
+                fractionsAddress: `0x${string}`;
+                vaultAddress: `0x${string}` | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=parseNftFractionsCreatedEvent.d.ts.map

package/dist/next/nftFractions/parseNftFractionsCreatedEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseNftFractionsCreatedEvent.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/parseNftFractionsCreatedEvent.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;aAiD1C,CAAC"}

package/dist/next/{fractions/sales/parseFractionsCreatedEvent.js → nftFractions/parseNftFractionsCreatedEvent.js}

@@ -1,26 +1,23 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { waitForTransactionReceipt } from "viem/actions";
-import { z } from "zod";
 import { parseFractionsCreatedEvent } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Int256Json } from "@evergonlabs/tmi-utils/models";
-import { getPublicClient } from "../../../common/blockchain.js";
-import { createController } from "../../../common/controller.js";
-import { HttpError } from "../../../common/http-error.js";
-import { AddressSchema, HashSchema, NextFractionsChainId } from "../../../common/index.js";
-const NextSentTransactionParamsSchema = z.object({
-    chainId: NextFractionsChainId.openapi({
-        param: { name: "chainId", in: "query" },
-    }),
-    hash: HashSchema.openapi({
-        param: { name: "hash", in: "query" },
-    }),
+import { nftFractionsTag } from "./tag.js";
+import { getPublicClient } from "../../common/blockchain.js";
+import { createController } from "../../common/controller.js";
+import { HttpError } from "../../common/http-error.js";
+import { AddressSchema, HashSchema, NextFractionsChainId } from "../../common/index.js";
+const SentTransactionParamsSchema = z.object({
+    chainId: NextFractionsChainId,
+    hash: HashSchema,
 });
-export const ParseNextFractionsCreatedEventV0 = createController({
-    build: (factory) => factory.createApp().get("/", describeRoute({
+export const ParseNftFractionsCreatedEventV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Get FractionsCreated event (next)",
         description: "Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted with corresponding `createFractions` action from the next SDK.",
-        tags: ["NFT Fractions"],
+        tags: [nftFractionsTag.tag],
         responses: {
             200: {
                 description: "Returns parsed event log",
@@ -38,8 +35,8 @@ export const ParseNextFractionsCreatedEventV0 = createController({
                 },
             },
         },
-    }), validator("query", NextSentTransactionParamsSchema), async (c) => {
-        const params = c.req.valid("query");
+    }), validator("json", SentTransactionParamsSchema), async (c) => {
+        const params = c.req.valid("json");
         const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,
         });
@@ -54,7 +51,7 @@ export const ParseNextFractionsCreatedEventV0 = createController({
             fractionsCreated: result.fractionsCreated.toString(),
             fractionsAddress: result.fractionsAddress,
             vaultAddress: result.vaultAddress,
-        }, 200);
+        });
     }),
 });
 class UnableParseFractionsCreatedEvent extends HttpError {

package/dist/next/nftFractions/schemas.d.ts

@@ -0,0 +1,2 @@
+export { CreateNftFractionsConfigSchema, DeployNftFractionsMarketDefaultRequestSchema, DeployNftFractionsMarketGatedRequestSchema, } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+//# sourceMappingURL=schemas.d.ts.map

package/dist/next/nftFractions/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,4CAA4C,EAC5C,0CAA0C,GAC3C,MAAM,8CAA8C,CAAC"}

package/dist/next/nftFractions/schemas.js

@@ -0,0 +1 @@
+export { CreateNftFractionsConfigSchema, DeployNftFractionsMarketDefaultRequestSchema, DeployNftFractionsMarketGatedRequestSchema, } from "@evergonlabs/tmi-protocol-fractions-sdk/next";

package/dist/next/nftFractions/tag.d.ts

@@ -0,0 +1,4 @@
+export declare const nftFractionsTag: {
+    tag: "NFT Fractions";
+};
+//# sourceMappingURL=tag.d.ts.map

package/dist/next/nftFractions/tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/tag.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;CAA6B,CAAC"}

package/dist/next/nftFractions/tag.js

@@ -0,0 +1,2 @@
+import { createTag } from "../../common/tag.js";
+export const nftFractionsTag = createTag("NFT Fractions");

package/dist/next/schemas.d.ts

@@ -0,0 +1,4 @@
+export * from "./lending/schemas.js";
+export * from "./nftFractions/schemas.js";
+export * from "./vestingRedemptionDynamic/schemas.js";
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/next/schemas.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uCAAuC,CAAC"}

package/dist/next/schemas.js

@@ -0,0 +1,3 @@
+export * from "./lending/schemas.js";
+export * from "./nftFractions/schemas.js";
+export * from "./vestingRedemptionDynamic/schemas.js";

package/dist/next/{fractions/vestingRedemptionDynamic/setEpochPrice.routes.d.ts → vestingRedemptionDynamic/approveCampaign.d.ts}

@@ -1,11 +1,12 @@
-export declare const SetEpochPriceV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+export declare const ApproveCampaignV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    market: string;
-                    campaignId: string;
-                    price: string;
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
                 };
             };
             output: {
@@ -23,4 +24,4 @@ export declare const SetEpochPriceV0: import("../../../common/controller.js").IC
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=setEpochPrice.routes.d.ts.map
+//# sourceMappingURL=approveCampaign.d.ts.map

package/dist/next/vestingRedemptionDynamic/approveCampaign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approveCampaign.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/approveCampaign.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;aAa5B,CAAC"}

package/dist/next/{fractions/vestingRedemptionDynamic/approveCampaign.routes.js → vestingRedemptionDynamic/approveCampaign.js}

@@ -1,21 +1,15 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { buildApproveCampaignTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { createController } from "../../../common/controller.js";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
-import { Int256BigInt } from "../../../common/int256.js";
-const ApproveCampaignRequestSchema = z
-    .object({
-    market: AddressSchema.describe("Address of the Vesting & Redemption Dynamic market"),
-    campaignId: Int256BigInt(z.bigint().nonnegative()).describe("Campaign ID to approve"),
-})
-    .openapi("ApproveCampaignRequestSchema");
+import { ApproveCampaignConfigSchema } from "./schemas.js";
+import { vrdTag } from "./tag.js";
+import { createController } from "../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const approveCampaignRoute = describeRoute({
     summary: "Approve a Vesting & Redemption Dynamic campaign",
     description: "Returns transaction data for the market admin to approve a campaign after it has been created. " +
         "Once approved the campaign transitions to the STARTED state and investors can begin purchasing.",
-    tags: ["Vesting & Redemption Dynamic"],
+    tags: [vrdTag.tag],
     responses: {
         200: {
             description: "Returns transaction data for approving the campaign",
@@ -28,8 +22,10 @@ const approveCampaignRoute = describeRoute({
     },
 });
 export const ApproveCampaignV0 = createController({
-    build: (factory) => factory.createApp().post("/", approveCampaignRoute, validator("json", ApproveCampaignRequestSchema), async (c) => {
-        const { market, campaignId } = c.req.valid("json");
-        return c.json(toTransaction(buildApproveCampaignTx({ market, campaignId })));
+    build: (factory) => factory
+        .createApp()
+        .post("/", approveCampaignRoute, validator("json", ApproveCampaignConfigSchema.openapi("ApproveCampaignConfigSchema")), async (c) => {
+        const config = c.req.valid("json");
+        return c.json(toTransaction(buildApproveCampaignTx(config)));
     }),
 });

package/dist/next/{fractions/vestingRedemptionDynamic/createCampaign.routes.d.ts → vestingRedemptionDynamic/createCampaign.d.ts}

@@ -1,9 +1,9 @@
-export declare const CreateVestingRedemptionDynamicCampaignV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+export declare const CreateVestingRedemptionDynamicCampaignV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    chainId: unknown;
+                    chainId: "31337" | "11155111" | "84532" | "72080";
                     market: string;
                     nft: {
                         contractAddress: string;
@@ -49,4 +49,4 @@ export declare const CreateVestingRedemptionDynamicCampaignV0: import("../../../
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=createCampaign.routes.d.ts.map
+//# sourceMappingURL=createCampaign.d.ts.map

package/dist/next/vestingRedemptionDynamic/createCampaign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCampaign.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/createCampaign.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAmBnD,CAAC"}

package/dist/next/{fractions/vestingRedemptionDynamic/createCampaign.routes.js → vestingRedemptionDynamic/createCampaign.js}

@@ -1,15 +1,16 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { buildCreateVestingRedemptionDynamicFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { createController } from "../../../common/controller.js";
-import { toTransaction, TransactionSchema } from "../../../common/index.js";
-import { CreateVestingRedemptionDynamicCampaignRequestSchema } from "./createCampaign.schema.js";
+import { CreateVestingRedemptionDynamicFractionsConfigSchema } from "./schemas.js";
+import { vrdTag } from "./tag.js";
+import { createController } from "../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Create a Vesting & Redemption Dynamic campaign",
     description: "Returns transaction data for wrapping an ERC-721 NFT and creating an on-demand ERC-20 fraction campaign. " +
         "The issuer must first approve the market's wrapper contract to transfer their NFT. " +
         "After creation the campaign must be approved by the market admin before investors can participate.",
-    tags: ["Vesting & Redemption Dynamic"],
+    tags: [vrdTag.tag],
     responses: {
         200: {
             description: "Returns transaction data for creating the campaign",
@@ -24,27 +25,9 @@ const route = describeRoute({
 export const CreateVestingRedemptionDynamicCampaignV0 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", route, validator("json", CreateVestingRedemptionDynamicCampaignRequestSchema), async (c) => {
-        const { chainId, market, nft, fractions, refundAddress, funding, startDate, softCapPerPurchase, hardCapPerAccount, fundsReceiver, priceSetter, fundsProvider, issuerEntryFee, issuerExitFee, } = c.req.valid("json");
-        const tx = buildCreateVestingRedemptionDynamicFractionsTx({
-            chainId,
-            market,
-            nft: {
-                contractAddress: nft.contractAddress,
-                tokenId: nft.tokenId,
-            },
-            fractions,
-            refundAddress,
-            funding,
-            startTimestamp: startDate,
-            softCapPerPurchase,
-            hardCapPerAccount,
-            fundsReceiver,
-            priceSetter,
-            fundsProvider,
-            issuerEntryFee,
-            issuerExitFee,
-        });
+        .post("/", route, validator("json", CreateVestingRedemptionDynamicFractionsConfigSchema.openapi("CreateVestingRedemptionDynamicFractionsConfigSchema")), async (c) => {
+        const request = c.req.valid("json");
+        const tx = buildCreateVestingRedemptionDynamicFractionsTx(request);
         return c.json(toTransaction(tx));
     }),
 });

package/dist/next/{fractions/vestingRedemptionDynamic/deployMarket.routes.d.ts → vestingRedemptionDynamic/deployMarket.d.ts}

@@ -1,9 +1,9 @@
-export declare const DeployVestingRedemptionDynamicMarketV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+export declare const DeployVestingRedemptionDynamicMarketV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    chainId: unknown;
+                    chainId: "31337" | "11155111" | "84532" | "72080";
                     adminAddress: string;
                     acceptedFundingTokens: string[];
                     ownerAddress?: string | undefined;
@@ -36,4 +36,4 @@ export declare const DeployVestingRedemptionDynamicMarketV0: import("../../../co
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=deployMarket.routes.d.ts.map
+//# sourceMappingURL=deployMarket.d.ts.map

package/dist/next/vestingRedemptionDynamic/deployMarket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployMarket.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/deployMarket.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAsBjD,CAAC"}

package/dist/next/{fractions/vestingRedemptionDynamic/deployMarket.routes.js → vestingRedemptionDynamic/deployMarket.js}

@@ -1,14 +1,15 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { createVestingRedemptionDynamicMarket } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { createController } from "../../../common/controller.js";
-import { toTransaction, TransactionSchema } from "../../../common/index.js";
-import { DeployVestingRedemptionDynamicMarketRequestSchema } from "./deployMarket.schema.js";
+import { DeployVestingRedemptionDynamicMarketRequestSchema } from "./schemas.js";
+import { vrdTag } from "./tag.js";
+import { createController } from "../../common/controller.js";
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Deploy a Vesting & Redemption Dynamic market",
     description: "Returns transaction data for deploying a Vesting & Redemption Dynamic market. " +
         "This market type supports perpetual epoch-based investments with two-click purchase and withdrawal flows.",
-    tags: ["Vesting & Redemption Dynamic"],
+    tags: [vrdTag.tag],
     responses: {
         200: {
             description: "Returns transaction data for deploying the market diamond",
@@ -23,16 +24,11 @@ const route = describeRoute({
 export const DeployVestingRedemptionDynamicMarketV0 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", route, validator("json", DeployVestingRedemptionDynamicMarketRequestSchema), async (c) => {
-        const { chainId, adminAddress, ownerAddress, acceptedFundingTokens, platformEntryFee, platformExitFee, receiptNft, } = c.req.valid("json");
+        .post("/", route, validator("json", DeployVestingRedemptionDynamicMarketRequestSchema.openapi("DeployVestingRedemptionDynamicMarketRequestSchema")), async (c) => {
+        const request = c.req.valid("json");
         const tx = createVestingRedemptionDynamicMarket({
-            chainId,
-            adminAddress,
-            ownerAddress: ownerAddress ?? adminAddress,
-            acceptedFundingTokens,
-            platformEntryFee,
-            platformExitFee,
-            receiptNft,
+            ...request,
+            ownerAddress: request.ownerAddress ?? request.adminAddress,
         });
         return c.json(toTransaction(tx));
     }),

package/dist/next/vestingRedemptionDynamic/epochPurchase.d.ts

@@ -0,0 +1,28 @@
+export declare const EpochPurchaseV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    campaign: {
+                        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;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=epochPurchase.d.ts.map

package/dist/next/vestingRedemptionDynamic/epochPurchase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epochPurchase.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/epochPurchase.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;aAc1B,CAAC"}