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

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

@@ -1 +1 @@
-{"version":3,"file":"deployNftFractionsMarket.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/deployNftFractionsMarket.ts"],"names":[],"mappings":"AA2BA;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAgB5C,CAAC"}
+{"version":3,"file":"deployNftFractionsMarket.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/deployNftFractionsMarket.ts"],"names":[],"mappings":"AA4BA;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA0B5C,CAAC"}

package/dist/next/nftFractions/deployNftFractionsMarket.js

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { createNftFractionsPlatformNoNid } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { DeployNftFractionsMarketDefaultRequestSchema } from "./schemas.js";
+import { DeployNftFractionsMarketDefaultRequestSchema } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
 import { nftFractionsTag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";
@@ -25,7 +25,9 @@ const route = describeRoute({
  * Controller for deploying an NFT Fractions market (non-gated)
  */
 export const DeployNftFractionsMarketDefaultV0 = createController({
-    build: (factory) => factory.createApp().post("/", route, validator("json", DeployNftFractionsMarketDefaultRequestSchema), async (c) => {
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", DeployNftFractionsMarketDefaultRequestSchema.openapi("DeployNftFractionsMarketDefaultRequestSchema")), async (c) => {
         const { chainId, adminAddress, ownerAddress, cap, fee, acceptedFundingTokens } = c.req.valid("json");
         const tx = createNftFractionsPlatformNoNid({
             chainId: chainId,

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

@@ -1 +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"}
+{"version":3,"file":"deployNftFractionsMarketGated.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/deployNftFractionsMarketGated.ts"],"names":[],"mappings":"AA4BA;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA4B1C,CAAC"}

package/dist/next/nftFractions/deployNftFractionsMarketGated.js

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { createNftFractionsPlatform } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { DeployNftFractionsMarketGatedRequestSchema } from "./schemas.js";
+import { DeployNftFractionsMarketGatedRequestSchema } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
 import { nftFractionsTag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { DEFAULT_COMPILOT_SIGNER, toTransaction, TransactionSchema } from "../../common/index.js";
@@ -25,7 +25,9 @@ const route = describeRoute({
  * Controller for deploying a gated NFT Fractions market (with ComPilot gating)
  */
 export const DeployNftFractionsMarketGatedV0 = createController({
-    build: (factory) => factory.createApp().post("/", route, validator("json", DeployNftFractionsMarketGatedRequestSchema), async (c) => {
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", DeployNftFractionsMarketGatedRequestSchema.openapi("DeployNftFractionsMarketGatedRequestSchema")), async (c) => {
         const { chainId, adminAddress, ownerAddress, compilotSignerAddress, cap, fee, acceptedFundingTokens } = c.req.valid("json");
         const tx = createNftFractionsPlatform({
             chainId: chainId,

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

@@ -92,18 +92,18 @@ export declare const NftFractionsApi: import("../../common/controller.js").IApi<
     };
 }, "/createFractions"> | import("hono/types").MergeSchemaPath<{
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId: "31337" | "11155111" | "84532" | "72080";
                     hash: string;
                 };
             };
             output: {
-                campaignId: string;
+                campaignId: string & import("zod").$brand<"Int256">;
                 creator: `0x${string}`;
-                nftId: string;
-                fractionsCreated: string;
+                nftId: string & import("zod").$brand<"Int256">;
+                fractionsCreated: string & import("zod").$brand<"Int256">;
                 fractionsAddress: `0x${string}`;
                 vaultAddress: `0x${string}` | undefined;
             };

package/dist/next/nftFractions/index.js

@@ -3,7 +3,7 @@ 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";
+import { PurchaseV0 } from "../../fractions/sales/purchase.js";
 export const NftFractionsApi = createApi({
     title: "NFT Fractions API",
     description: "NFT Fractions API",

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

@@ -1,17 +1,30 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const ParseNftFractionsCreatedEventResponse: z.ZodObject<{
+    creator: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    nftId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    campaignId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    fractionsCreated: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    fractionsAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    vaultAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
+export declare const ParseNftFractionsCreatedEventRequest: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532" | "72080">[]>;
+    hash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
 export declare const ParseNftFractionsCreatedEventV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId: "31337" | "11155111" | "84532" | "72080";
                     hash: string;
                 };
             };
             output: {
-                campaignId: string;
+                campaignId: string & z.core.$brand<"Int256">;
                 creator: `0x${string}`;
-                nftId: string;
-                fractionsCreated: string;
+                nftId: string & z.core.$brand<"Int256">;
+                fractionsCreated: string & z.core.$brand<"Int256">;
                 fractionsAddress: `0x${string}`;
                 vaultAddress: `0x${string}` | undefined;
             };

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

@@ -1 +1 @@
-{"version":3,"file":"parseNftFractionsCreatedEvent.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/parseNftFractionsCreatedEvent.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;aAiD1C,CAAC"}
+{"version":3,"file":"parseNftFractionsCreatedEvent.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/parseNftFractionsCreatedEvent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,qCAAqC;;;;;;;iBASC,CAAC;AAEpD,eAAO,MAAM,oCAAoC;;;iBASC,CAAC;AAEnD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;aA4C1C,CAAC"}

package/dist/next/nftFractions/parseNftFractionsCreatedEvent.js

@@ -3,18 +3,34 @@ import { resolver, validator } from "hono-openapi";
 import { waitForTransactionReceipt } from "viem/actions";
 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 { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 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 ParseNftFractionsCreatedEventResponse = z
+    .object({
+    creator: AddressSchema,
+    nftId: Int256Json,
+    campaignId: Int256Json.openapi({ description: "Id of a Sale", example: "1" }),
+    fractionsCreated: Int256Json,
+    fractionsAddress: AddressSchema,
+    vaultAddress: AddressSchema,
+})
+    .openapi("ParseNftFractionsCreatedEventResponse");
+export const ParseNftFractionsCreatedEventRequest = z
+    .object({
+    chainId: NextFractionsChainId.openapi({
+        param: { name: "chainId", in: "query" },
+    }),
+    hash: HashSchema.openapi({
+        param: { name: "hash", in: "query" },
+    }),
+})
+    .openapi("ParseNftFractionsCreatedEventRequest");
 export const ParseNftFractionsCreatedEventV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+    build: (factory) => factory.createApp().get("/", 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: [nftFractionsTag.tag],
@@ -23,42 +39,30 @@ export const ParseNftFractionsCreatedEventV0 = createController({
                 description: "Returns parsed event log",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            creator: AddressSchema,
-                            nftId: Int256Json,
-                            campaignId: Int256Json.openapi({ description: "Id of a Sale", example: "1" }),
-                            fractionsCreated: Int256Json,
-                            fractionsAddress: AddressSchema,
-                            vaultAddress: AddressSchema,
-                        })),
+                        schema: resolver(ParseNftFractionsCreatedEventResponse),
                     },
                 },
             },
         },
-    }), validator("json", SentTransactionParamsSchema), async (c) => {
-        const params = c.req.valid("json");
+    }), validator("query", ParseNftFractionsCreatedEventRequest), async (c) => {
+        const params = c.req.valid("query");
         const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,
         });
         const result = parseFractionsCreatedEvent(receipt.logs);
         if (!result) {
-            throw new UnableParseFractionsCreatedEvent();
+            throw new HttpError(500, {
+                message: "Can't parse FractionsCreated transaction. Make sure you're passing transaction that is generated by `createFractions` action",
+                name: "UnableParseFractionsCreatedEvent",
+            });
         }
         return c.json({
-            campaignId: result.campaignId.toString(),
+            campaignId: toInt256Json(result.campaignId),
             creator: result.creator,
-            nftId: result.wrapperNftId.toString(),
-            fractionsCreated: result.fractionsCreated.toString(),
+            nftId: toInt256Json(result.wrapperNftId),
+            fractionsCreated: toInt256Json(result.fractionsCreated),
             fractionsAddress: result.fractionsAddress,
             vaultAddress: result.vaultAddress,
         });
     }),
 });
-class UnableParseFractionsCreatedEvent extends HttpError {
-    constructor() {
-        super(500, {
-            message: "Can't parse FractionsCreated transaction. Make sure you're passing transaction that is generated by `createFractions` action",
-            name: "UnableParseFractionsCreatedEvent",
-        });
-    }
-}

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

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

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

@@ -1 +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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/next/nftFractions/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oCAAoC,EACpC,qCAAqC,GACtC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,8BAA8B,EAAE,MAAM,8CAA8C,CAAC;AAC9F,OAAO,EAAE,4CAA4C,EAAE,MAAM,8CAA8C,CAAC;AAC5G,OAAO,EAAE,0CAA0C,EAAE,MAAM,8CAA8C,CAAC"}

package/dist/next/nftFractions/schemas.js

@@ -1 +1,4 @@
-export { CreateNftFractionsConfigSchema, DeployNftFractionsMarketDefaultRequestSchema, DeployNftFractionsMarketGatedRequestSchema, } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+export { ParseNftFractionsCreatedEventRequest, ParseNftFractionsCreatedEventResponse, } from "./parseNftFractionsCreatedEvent.js";
+export { CreateNftFractionsConfigSchema } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+export { DeployNftFractionsMarketDefaultRequestSchema } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+export { DeployNftFractionsMarketGatedRequestSchema } from "@evergonlabs/tmi-protocol-fractions-sdk/next";

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

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

package/dist/next/vestingRedemptionDynamic/approveCampaign.js

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { buildApproveCampaignTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { ApproveCampaignConfigSchema } from "./schemas.js";
+import { ApproveCampaignConfigSchema } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
 import { vrdTag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";

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

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

package/dist/next/vestingRedemptionDynamic/createCampaign.js

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { buildCreateVestingRedemptionDynamicFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { CreateVestingRedemptionDynamicFractionsConfigSchema } from "./schemas.js";
+import { CreateVestingRedemptionDynamicFractionsConfigSchema } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
 import { vrdTag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";

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

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

package/dist/next/vestingRedemptionDynamic/deployMarket.js

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { createVestingRedemptionDynamicMarket } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { DeployVestingRedemptionDynamicMarketRequestSchema } from "./schemas.js";
+import { DeployVestingRedemptionDynamicMarketRequestSchema } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
 import { vrdTag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";

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

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

package/dist/next/vestingRedemptionDynamic/epochPurchase.js

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { buildEpochPurchaseTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { EpochPurchaseConfigSchema } from "./schemas.js";
+import { EpochPurchaseConfigSchema } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
 import { vrdTag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";

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

@@ -1 +1 @@
-{"version":3,"file":"exchangeNftForFractions.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/exchangeNftForFractions.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;aAcpC,CAAC"}
+{"version":3,"file":"exchangeNftForFractions.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/exchangeNftForFractions.ts"],"names":[],"mappings":"AA8BA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;aAcpC,CAAC"}

package/dist/next/vestingRedemptionDynamic/exchangeNftForFractions.js

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { buildExchangeNftForFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
-import { ExchangeNftForFractionsConfigSchema } from "./schemas.js";
+import { ExchangeNftForFractionsConfigSchema } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
 import { vrdTag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";

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

@@ -1,13 +1,20 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetCurrentEpochQuery: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532" | "72080">[]>;
+    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    campaignId: z.ZodCoercedBigInt<unknown>;
+}, z.core.$strip>;
+export declare const GetCurrentEpochResponse: z.ZodObject<{
+    currentEpoch: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
 export declare const GetCurrentEpochV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
-                    campaign: {
-                        market: string;
-                        campaignId: string;
-                    };
-                    chainId: "31337" | "11155111" | "84532" | "72080";
+                query: {
+                    chainId: string | string[];
+                    market: string | string[];
+                    campaignId: string | string[];
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"getCurrentEpoch.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/getCurrentEpoch.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;aAoC5B,CAAC"}
+{"version":3,"file":"getCurrentEpoch.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/getCurrentEpoch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,oBAAoB;;;;iBAMC,CAAC;AAEnC,eAAO,MAAM,uBAAuB;;iBAIC,CAAC;AAEtC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;aAiC5B,CAAC"}

package/dist/next/vestingRedemptionDynamic/getCurrentEpoch.js

@@ -4,16 +4,24 @@ import { readContract } from "viem/actions";
 import { buildGetCurrentEpochCall } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Int256Json } from "@evergonlabs/tmi-utils/models";
-import { GetCurrentEpochSchema as _GetCurrentEpochSchema } from "./schemas.js";
 import { vrdTag } from "./tag.js";
 import { getPublicClient } from "../../common/blockchain.js";
 import { createController } from "../../common/controller.js";
-import { NextFractionsChainId } from "../../common/index.js";
-const GetCurrentEpochSchema = _GetCurrentEpochSchema
-    .extend({ chainId: NextFractionsChainId })
-    .openapi("GetCurrentEpochSchema");
+import { AddressSchema, NextFractionsChainId } from "../../common/index.js";
+export const GetCurrentEpochQuery = z
+    .object({
+    chainId: NextFractionsChainId,
+    market: AddressSchema,
+    campaignId: z.coerce.bigint(),
+})
+    .openapi("GetCurrentEpochQuery");
+export const GetCurrentEpochResponse = z
+    .object({
+    currentEpoch: Int256Json.openapi({ description: "Current epoch number", example: "1" }),
+})
+    .openapi("GetCurrentEpochResponse");
 export const GetCurrentEpochV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get current epoch",
         description: "Returns the current epoch number for a Vesting & Redemption Dynamic campaign.",
         tags: [vrdTag.tag],
@@ -22,15 +30,14 @@ export const GetCurrentEpochV0 = createController({
                 description: "Returns the current epoch number",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            currentEpoch: Int256Json.openapi({ description: "Current epoch number", example: "1" }),
-                        })),
+                        schema: resolver(GetCurrentEpochResponse),
                     },
                 },
             },
         },
-    }), validator("json", GetCurrentEpochSchema), async (c) => {
-        const { chainId, campaign } = c.req.valid("json");
+    }), validator("query", GetCurrentEpochQuery), async (c) => {
+        const { chainId, market, campaignId } = c.req.valid("query");
+        const campaign = { market, campaignId };
         const publicClient = getPublicClient(chainId, c.env.config);
         // account must be the diamond address itself so msg.sender == address(this),
         // satisfying the OnlyInternalDelegateCall modifier on the facet.

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

@@ -1,9 +1,13 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetEpochPurchaseEventQuery: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532" | "72080">[]>;
+    hash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
 export declare const GetEpochPurchaseEventV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId: "31337" | "11155111" | "84532" | "72080";
                     hash: string;
                 };

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

@@ -1 +1 @@
-{"version":3,"file":"getEpochPurchaseEvent.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/getEpochPurchaseEvent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAgBxD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;aAiDlC,CAAC"}
+{"version":3,"file":"getEpochPurchaseEvent.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/getEpochPurchaseEvent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,0BAA0B;;;iBAKC,CAAC;AAEzC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;aAiDlC,CAAC"}

package/dist/next/vestingRedemptionDynamic/getEpochPurchaseEvent.js

@@ -9,14 +9,14 @@ 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 GetEpochPurchaseEventSchema = z
+export const GetEpochPurchaseEventQuery = z
     .object({
     chainId: NextFractionsChainId,
     hash: HashSchema,
 })
-    .openapi("GetEpochPurchaseEventSchema");
+    .openapi("GetEpochPurchaseEventQuery");
 export const GetEpochPurchaseEventV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get NftPurchased event",
         description: "Gets the transaction by hash and parses the `NftPurchased` event emitted during step 1 of the two-click epoch purchase flow.",
         tags: [vrdTag.tag],
@@ -37,8 +37,8 @@ export const GetEpochPurchaseEventV0 = createController({
                 },
             },
         },
-    }), validator("json", GetEpochPurchaseEventSchema), async (c) => {
-        const params = c.req.valid("json");
+    }), validator("query", GetEpochPurchaseEventQuery), async (c) => {
+        const params = c.req.valid("query");
         const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,
         });

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

@@ -1,18 +1,26 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetPurchasePriceForEpochQuery: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532" | "72080">[]>;
+    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    campaignId: z.ZodCoercedBigInt<unknown>;
+    epoch: z.ZodCoercedBigInt<unknown>;
+}, z.core.$strip>;
+export declare const GetPurchasePriceForEpochResponse: z.ZodObject<{
+    price: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
 export declare const GetPurchasePriceForEpochV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
-                    campaign: {
-                        market: string;
-                        campaignId: string;
-                    };
-                    epoch: string;
-                    chainId: "31337" | "11155111" | "84532" | "72080";
+                query: {
+                    chainId: string | string[];
+                    market: string | string[];
+                    campaignId: string | string[];
+                    epoch: string | string[];
                 };
             };
             output: {
-                price: string;
+                price: string & z.core.$brand<"Int256">;
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;

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

@@ -1 +1 @@
-{"version":3,"file":"getPurchasePriceForEpoch.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/getPurchasePriceForEpoch.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;aAwCrC,CAAC"}
+{"version":3,"file":"getPurchasePriceForEpoch.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/getPurchasePriceForEpoch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,6BAA6B;;;;;iBAOC,CAAC;AAE5C,eAAO,MAAM,gCAAgC;;iBAOC,CAAC;AAE/C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;aAkCrC,CAAC"}

package/dist/next/vestingRedemptionDynamic/getPurchasePriceForEpoch.js

@@ -1,18 +1,31 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { readContract } from "viem/actions";
-import { buildGetPurchasePriceForEpochCall, GetPurchasePriceForEpochSchema as _GetPurchasePriceForEpochSchema, } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
+import { buildGetPurchasePriceForEpochCall } from "@evergonlabs/tmi-protocol-fractions-sdk/next";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { vrdTag } from "./tag.js";
 import { getPublicClient } from "../../common/blockchain.js";
 import { createController } from "../../common/controller.js";
-import { NextFractionsChainId } from "../../common/index.js";
-const GetPurchasePriceForEpochSchema = _GetPurchasePriceForEpochSchema
-    .extend({ chainId: NextFractionsChainId })
-    .openapi("GetPurchasePriceForEpochSchema");
+import { AddressSchema, NextFractionsChainId } from "../../common/index.js";
+export const GetPurchasePriceForEpochQuery = z
+    .object({
+    chainId: NextFractionsChainId,
+    market: AddressSchema,
+    campaignId: z.coerce.bigint(),
+    epoch: z.coerce.bigint(),
+})
+    .openapi("GetPurchasePriceForEpochQuery");
+export const GetPurchasePriceForEpochResponse = z
+    .object({
+    price: Int256Json.openapi({
+        description: "Price in funding packets per 10^18 fraction token units",
+        example: "1000000000000000000",
+    }),
+})
+    .openapi("GetPurchasePriceForEpochResponse");
 export const GetPurchasePriceForEpochV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get purchase price for epoch",
         description: "Returns the purchase price (in funding packets per 10^18 fraction token units) recorded for a specific epoch in a Vesting & Redemption Dynamic campaign.",
         tags: [vrdTag.tag],
@@ -21,18 +34,14 @@ export const GetPurchasePriceForEpochV0 = createController({
                 description: "Returns the epoch price",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            price: Int256Json.openapi({
-                                description: "Price in funding packets per 10^18 fraction token units",
-                                example: "1000000000000000000",
-                            }),
-                        })),
+                        schema: resolver(GetPurchasePriceForEpochResponse),
                     },
                 },
             },
         },
-    }), validator("json", GetPurchasePriceForEpochSchema), async (c) => {
-        const { chainId, campaign, epoch } = c.req.valid("json");
+    }), validator("query", GetPurchasePriceForEpochQuery), async (c) => {
+        const { chainId, market, campaignId, epoch } = c.req.valid("query");
+        const campaign = { market, campaignId };
         const publicClient = getPublicClient(chainId, c.env.config);
         // account must be the diamond address itself so msg.sender == address(this),
         // satisfying the OnlyInternalDelegateCall modifier on the facet.
@@ -40,6 +49,6 @@ export const GetPurchasePriceForEpochV0 = createController({
             ...buildGetPurchasePriceForEpochCall({ campaign, epoch }),
             account: campaign.market,
         });
-        return c.json({ price: result.toString() });
+        return c.json({ price: toInt256Json(result) });
     }),
 });

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

@@ -1,9 +1,13 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetWithdrawalRequestedEventQuery: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532" | "72080">[]>;
+    hash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
 export declare const GetWithdrawalRequestedEventV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId: "31337" | "11155111" | "84532" | "72080";
                     hash: string;
                 };

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

@@ -1 +1 @@
-{"version":3,"file":"getWithdrawalRequestedEvent.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/getWithdrawalRequestedEvent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAgBxD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;aA6CxC,CAAC"}
+{"version":3,"file":"getWithdrawalRequestedEvent.d.ts","sourceRoot":"","sources":["../../../src/next/vestingRedemptionDynamic/getWithdrawalRequestedEvent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,gCAAgC;;;iBAKC,CAAC;AAE/C,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;aA6CxC,CAAC"}