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

package/dist/fractions/sales/purchase.route.js

@@ -1,15 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { buildPurchaseTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { PurchaseRequestSchema } from "../schemas.js";
 import { createController } from "../../common/controller.js";
-import { FractionsChainId, SaleIdSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-import { Int256BigInt } from "../../common/int256.js";
-export const PurchaseRequestSchema = SaleIdSchema.extend({
-    chainId: FractionsChainId,
-    amountToBuy: Int256BigInt(),
-    applyDiscount: z.boolean(),
-});
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Make a purchase",
     description: "Returns transaction data for making a purchase",
@@ -29,14 +23,8 @@ export const PurchaseV0 = createController({
     build: (factory) => factory
         .createApp()
         .post("/", route, validator("json", PurchaseRequestSchema.openapi("PurchaseRequestSchema")), async (c) => {
-        const { chainId, market, campaignId, amountToBuy, applyDiscount } = c.req.valid("json");
-        const tx = buildPurchaseTx(chainId, {
-            market: market,
-            campaignId: campaignId,
-            amountToBuy: amountToBuy,
-            //todo burn for discount will be changed when multiple discount options becomes available in smart contract
-            discount: applyDiscount ? { burnForDiscount: BigInt(1) } : undefined,
-        });
+        const request = c.req.valid("json");
+        const tx = buildPurchaseTx(request);
         return c.json(toTransaction(tx));
     }),
 });

package/dist/fractions/sales/purchaseStatistics.route.d.ts

@@ -6,11 +6,11 @@ export declare const PurchaseStatisticsV0: import("../../common/controller.js").
                     platform: string;
                     campaignId: string;
                     walletAddress: string;
-                    chainId?: unknown;
+                    chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
                 };
             };
             output: {
-                chainId: 1 | 11155111 | 31337 | 72080;
+                chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                 platform: `0x${string}`;
                 campaignId: string;
                 statistics: {

package/dist/fractions/sales/purchaseStatistics.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"purchaseStatistics.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/purchaseStatistics.route.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;aAqE/B,CAAC"}
+{"version":3,"file":"purchaseStatistics.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/purchaseStatistics.route.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;aAqE/B,CAAC"}

package/dist/fractions/sales/purchaseStatistics.route.js

@@ -1,16 +1,16 @@
 import { and, count, eq, sum } from "@ponder/client";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { FractionsSaleStatisticSchema } from "./getFractionSaleStatistics.route.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, CampaignIdSchema, FractionsChainId, PlatformContractAddress } from "../../common/index.js";
 import { indexerSchemas } from "../../common/indexer/schemas.js";
-import { FractionsSaleStatisticSchema } from "./getFractionSaleStatistics.route.js";
 export const PurchaseStatisticsV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Aggregate investor statistics for certain campaign",
         description: "Returns aggregated statistics about investor purchases for a specific campaign, grouped by price ID. Statistics include the number of purchases and the total number of fractions sold.",
-        tags: ["Sales"],
+        tags: ["Statistics"],
         responses: {
             200: {
                 description: "Aggregated purchase statistics for the specified campaign and investor.",

package/dist/fractions/sales/receiveFundsAfterNonFunded.route.d.ts

@@ -1,21 +1,41 @@
-import { z } from "zod";
-export declare const ReceiveFundsAfterNonFundedRequestSchema: z.ZodObject<{
-    upperGenesisId: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
-    amountOfFractions: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    isDiscounted: z.ZodBoolean;
-    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>;
 export declare const ReceiveFundsAfterNonFundedV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
+                    amountOfFractions: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+export declare const ReceiveFundsAfterNonFundedDiscountV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
+                    upperGenesisId: string;
                     amountOfFractions: string;
-                    isDiscounted: boolean;
-                    market: string;
-                    campaignId: string;
-                    upperGenesisId?: string | undefined;
                 };
             };
             output: {
@@ -38,8 +58,10 @@ export declare const CheckAndJumpToNonFundedV0: import("../../common/controller.
         $post: {
             input: {
                 json: {
-                    market: string;
-                    campaignId: string;
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
                 };
             };
             output: {

package/dist/fractions/sales/receiveFundsAfterNonFunded.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"receiveFundsAfterNonFunded.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/receiveFundsAfterNonFunded.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,uCAAuC;;;;;;iBAMvB,CAAC;AAkB9B,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;aAgBvC,CAAC;AAkBH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;aAOpC,CAAC"}
+{"version":3,"file":"receiveFundsAfterNonFunded.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/receiveFundsAfterNonFunded.route.ts"],"names":[],"mappings":"AAgCA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;aASvC,CAAC;AAkBH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;aAc/C,CAAC;AAkBH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;aASpC,CAAC"}

package/dist/fractions/sales/receiveFundsAfterNonFunded.route.js

@@ -1,21 +1,12 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { checkAndJumpToNonFunded, receiveFundsAfterNonFundedDiscount, receiveFundsAfterNonFundedNoDiscount, } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { CheckAndJumpToNonFundedConfigSchema, ReceiveFundsAfterNonFundedDiscountConfigSchema, ReceiveFundsAfterNonFundedNoDiscountConfigSchema, } from "../schemas.js";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";
-import { Int256BigInt } from "../../common/int256.js";
-import { SaleIdSchema } from "../../common/models/saleId.js";
-export const ReceiveFundsAfterNonFundedRequestSchema = z
-    .object({
-    upperGenesisId: Int256BigInt().optional().openapi({ description: "Required if discount was applied" }),
-    amountOfFractions: Int256BigInt(),
-    isDiscounted: z.boolean(),
-})
-    .extend(SaleIdSchema.shape);
-const route = describeRoute({
+const receiveFundsRoute = describeRoute({
     summary: "Receive funds after non funded state",
-    description: "Returns transaction to receive funds after a sale enters non funded state",
+    description: "Returns transaction to receive funds after a sale enters non funded state (no discount)",
     tags: ["Sales"],
     responses: {
         200: {
@@ -31,11 +22,33 @@ const route = describeRoute({
 export const ReceiveFundsAfterNonFundedV0 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", route, validator("json", ReceiveFundsAfterNonFundedRequestSchema.openapi("ReceiveFundsAfterNonFundedRequestSchema")), async (c) => {
-        const { market, campaignId, amountOfFractions, upperGenesisId, isDiscounted } = c.req.valid("json");
-        const tx = isDiscounted
-            ? receiveFundsAfterNonFundedDiscount(market, BigInt(campaignId), upperGenesisId, amountOfFractions)
-            : receiveFundsAfterNonFundedNoDiscount(market, BigInt(campaignId), amountOfFractions);
+        .post("/", receiveFundsRoute, validator("json", ReceiveFundsAfterNonFundedNoDiscountConfigSchema), async (c) => {
+        const config = c.req.valid("json");
+        const tx = receiveFundsAfterNonFundedNoDiscount(config);
+        return c.json(toTransaction(tx));
+    }),
+});
+const receiveFundsDiscountRoute = describeRoute({
+    summary: "Receive funds after non funded state (with discount)",
+    description: "Returns transaction to receive funds after a sale enters non funded state, applying a discount",
+    tags: ["Sales"],
+    responses: {
+        200: {
+            description: "Returns transaction to receive funds after non funded state with discount",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const ReceiveFundsAfterNonFundedDiscountV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", receiveFundsDiscountRoute, validator("json", ReceiveFundsAfterNonFundedDiscountConfigSchema), async (c) => {
+        const config = c.req.valid("json");
+        const tx = receiveFundsAfterNonFundedDiscount(config);
         return c.json(toTransaction(tx));
     }),
 });
@@ -55,9 +68,11 @@ const checkAndJumpToNonFundedRoute = describeRoute({
     },
 });
 export const CheckAndJumpToNonFundedV0 = createController({
-    build: (factory) => factory.createApp().post("/", checkAndJumpToNonFundedRoute, validator("json", SaleIdSchema), async (c) => {
-        const { market, campaignId } = c.req.valid("json");
-        const tx = checkAndJumpToNonFunded(market, campaignId);
+    build: (factory) => factory
+        .createApp()
+        .post("/", checkAndJumpToNonFundedRoute, validator("json", CheckAndJumpToNonFundedConfigSchema), async (c) => {
+        const config = c.req.valid("json");
+        const tx = checkAndJumpToNonFunded(config);
         return c.json(toTransaction(tx));
     }),
 });

package/dist/fractions/sales/receiveNonPurchasedWrappedAssets.route.d.ts

@@ -1,10 +1,12 @@
-export declare const ReceiveNonPurchasedWrappedAssetsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+export declare const ReceiveNonPurchasedWrappedAssetsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    market: string;
-                    campaignId: string;
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
                 };
             };
             output: {

package/dist/fractions/sales/receiveNonPurchasedWrappedAssets.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"receiveNonPurchasedWrappedAssets.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/receiveNonPurchasedWrappedAssets.route.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;aAO7C,CAAC"}
+{"version":3,"file":"receiveNonPurchasedWrappedAssets.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/receiveNonPurchasedWrappedAssets.route.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;aAc7C,CAAC"}

package/dist/fractions/sales/receiveNonPurchasedWrappedAssets.route.js

@@ -1,9 +1,8 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { receiveNonPurchasedWrappedAssets } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { ReceiveNonPurchasedConfigSchema, receiveNonPurchasedWrappedAssets, } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";
-import { SaleIdSchema } from "../../common/models/saleId.js";
 const route = describeRoute({
     summary: "Receive non-purchased wrapped assets",
     description: "Returns transaction to receive non-purchased wrapped assets from a sale",
@@ -20,9 +19,11 @@ const route = describeRoute({
     },
 });
 export const ReceiveNonPurchasedWrappedAssetsV0 = createController({
-    build: (factory) => factory.createApp().post("/", route, validator("json", SaleIdSchema), async (c) => {
-        const { market, campaignId } = c.req.valid("json");
-        const tx = receiveNonPurchasedWrappedAssets(market, campaignId);
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", ReceiveNonPurchasedConfigSchema.openapi("ReceiveNonPurchasedWrappedAssetsRequestSchema")), async (c) => {
+        const config = c.req.valid("json");
+        const tx = receiveNonPurchasedWrappedAssets(config);
         return c.json(toTransaction(tx));
     }),
 });

package/dist/fractions/sales/recoverFractions.d.ts

@@ -1,19 +1,12 @@
-import { z } from "zod";
-export declare const RecoverFractionsRequestSchema: z.ZodObject<{
-    marketAddress: 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">>>;
-    lostAccount: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    recoveryAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    amountOfFractions: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    fractionId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-}, z.core.$strip>;
 export declare const RecoverFractionsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    marketAddress: string;
-                    campaignId: string;
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
                     lostAccount: string;
                     recoveryAddress: string;
                     amountOfFractions: string;
@@ -35,8 +28,10 @@ export declare const RecoverFractionsV0: import("../../common/controller.js").IC
         } | {
             input: {
                 json: {
-                    marketAddress: string;
-                    campaignId: string;
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
                     lostAccount: string;
                     recoveryAddress: string;
                     amountOfFractions: string;
@@ -51,8 +46,10 @@ export declare const RecoverFractionsV0: import("../../common/controller.js").IC
         } | {
             input: {
                 json: {
-                    marketAddress: string;
-                    campaignId: string;
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
                     lostAccount: string;
                     recoveryAddress: string;
                     amountOfFractions: string;

package/dist/fractions/sales/recoverFractions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recoverFractions.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/recoverFractions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,6BAA6B;;;;;;;iBASC,CAAC;AAkB5C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuB7B,CAAC"}
+{"version":3,"file":"recoverFractions.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/recoverFractions.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAe7B,CAAC"}

package/dist/fractions/sales/recoverFractions.js

@@ -1,20 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { buildRecoverFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { RecoverFractionsConfigSchema } from "../schemas.js";
 import { createController } from "../../common/controller.js";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-import { Int256BigInt } from "../../common/int256.js";
-export const RecoverFractionsRequestSchema = z
-    .object({
-    marketAddress: AddressSchema,
-    campaignId: Int256BigInt(z.bigint().positive()),
-    lostAccount: AddressSchema,
-    recoveryAddress: AddressSchema,
-    amountOfFractions: Int256BigInt(z.bigint().positive()),
-    fractionId: Int256BigInt(z.bigint().nonnegative()),
-})
-    .openapi("RecoverFractionsRequestSchema");
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Recover fractions",
     description: "Returns transaction data for recovering fractions from a lost account",
@@ -31,10 +20,10 @@ const route = describeRoute({
     },
 });
 export const RecoverFractionsV0 = createController({
-    build: (factory) => factory.createApp().post("/", route, validator("json", RecoverFractionsRequestSchema), async (c) => {
-        const { marketAddress, campaignId, lostAccount, recoveryAddress, amountOfFractions, fractionId } = c.req.valid("json");
+    build: (factory) => factory.createApp().post("/", route, validator("json", RecoverFractionsConfigSchema), async (c) => {
+        const config = c.req.valid("json");
         try {
-            const tx = buildRecoverFractionsTx(marketAddress, campaignId, lostAccount, recoveryAddress, amountOfFractions, fractionId);
+            const tx = buildRecoverFractionsTx(config);
             return c.json(toTransaction(tx));
         }
         catch (error) {

package/dist/fractions/sales/rejectFractions.d.ts

@@ -1,14 +1,9 @@
-import { z } from "zod";
-export declare const RejectFractionsRequestSchema: z.ZodObject<{
-    marketAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    saleId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-}, z.core.$strip>;
 export declare const RejectFractionsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    marketAddress: string;
+                    market: string;
                     saleId: string;
                 };
             };
@@ -27,7 +22,7 @@ export declare const RejectFractionsV0: import("../../common/controller.js").ICo
         } | {
             input: {
                 json: {
-                    marketAddress: string;
+                    market: string;
                     saleId: string;
                 };
             };
@@ -39,7 +34,7 @@ export declare const RejectFractionsV0: import("../../common/controller.js").ICo
         } | {
             input: {
                 json: {
-                    marketAddress: string;
+                    market: string;
                     saleId: string;
                 };
             };

package/dist/fractions/sales/rejectFractions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rejectFractions.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/rejectFractions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAsB5B,CAAC"}
+{"version":3,"file":"rejectFractions.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/rejectFractions.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAsB5B,CAAC"}

package/dist/fractions/sales/rejectFractions.js

@@ -1,14 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { builtRejectFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { RejectFractionsConfigSchema } from "../schemas.js";
 import { createController } from "../../common/controller.js";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-import { Int256BigInt } from "../../common/int256.js";
-export const RejectFractionsRequestSchema = z.object({
-    marketAddress: AddressSchema,
-    saleId: Int256BigInt(z.bigint().nonnegative()),
-});
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Reject fractions",
     description: "Returns transaction data for rejecting fractions in a sale",
@@ -27,10 +22,10 @@ const route = describeRoute({
 export const RejectFractionsV0 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", route, validator("json", RejectFractionsRequestSchema.openapi("RejectFractionsRequestSchema")), async (c) => {
-        const { marketAddress, saleId } = c.req.valid("json");
+        .post("/", route, validator("json", RejectFractionsConfigSchema.openapi("RejectFractionsConfigSchema")), async (c) => {
+        const config = c.req.valid("json");
         try {
-            const tx = builtRejectFractionsTx(marketAddress, saleId);
+            const tx = builtRejectFractionsTx(config);
             return c.json(toTransaction(tx));
         }
         catch (error) {

package/dist/fractions/sales/searchActivity.route.d.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
 import { FractionSaleEventEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const SearchActivityV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
@@ -10,7 +10,7 @@ export declare const SearchActivityV0: import("../../common/controller.js").ICon
                         limit: number;
                     };
                     filter: {
-                        chainId?: unknown;
+                        chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
                         platform?: string | undefined;
                         campaignId?: string | undefined;
                         operationType?: FractionSaleEventEnum | undefined;
@@ -18,13 +18,13 @@ export declare const SearchActivityV0: import("../../common/controller.js").ICon
                 };
             };
             output: {
-                chainId: 1 | 11155111 | 31337 | 72080;
+                chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                 platform: `0x${string}`;
                 campaignId: string & z.core.$brand<"Int256">;
                 transactionHash: `0x${string}`;
                 from: `0x${string}`;
-                createdAt: string & z.core.$brand<"ISO">;
-                updatedAt: string & z.core.$brand<"ISO">;
+                createdAt: string & z.core.$brand<"IsoDateString">;
+                updatedAt: string & z.core.$brand<"IsoDateString">;
                 metadata: {
                     type: FractionSaleEventEnum.CREATED;
                 } | {

package/dist/fractions/sales/searchActivity.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"searchActivity.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/searchActivity.route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAQjF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAmE3B,CAAC"}
+{"version":3,"file":"searchActivity.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/searchActivity.route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAmE3B,CAAC"}

package/dist/fractions/sales/searchActivity.route.js

@@ -1,14 +1,14 @@
 import { and, desc, eq, sql } from "@ponder/client";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { FractionSaleEventEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { toInt256Json } from "@evergonlabs/tmi-utils/models";
+import { FractionActivityEntrySchema } from "./activityUtils.js";
 import { createController } from "../../common/controller.js";
 import { CampaignIdSchema, FractionsChainId, PlatformContractAddress } from "../../common/index.js";
 import { indexerSchemas } from "../../common/indexer/schemas.js";
 import { PageSchema } from "../../common/models/page.js";
-import { FractionActivityEntrySchema } from "./activityUtils.js";
 export const SearchActivityV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Search activity events",

package/dist/fractions/sales/searchSales/searchSales.d.ts

@@ -8,7 +8,7 @@ export declare const SearchSalesV0: import("../../../common/controller.js").ICon
                         limit: number;
                     };
                     filter: {
-                        chainId?: unknown;
+                        chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
                         owner?: string | undefined;
                         platform?: string | undefined;
                         campaignId?: string | undefined;
@@ -16,15 +16,15 @@ export declare const SearchSalesV0: import("../../../common/controller.js").ICon
                 };
             };
             output: {
-                chainId: import("hono/utils/types").JSONValue;
+                chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                 platform: string;
                 campaignId: string;
                 nftId: string;
-                status: "finalized" | "created" | "approved" | "rejected" | "refunded";
+                status: "created" | "approved" | "rejected" | "finalized" | "refunded";
                 owner: string;
                 fractions: {
                     asset: {
-                        chainId: import("hono/utils/types").JSONValue;
+                        chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                         address: string;
                         type: string;
                         symbol: string;
@@ -53,7 +53,7 @@ export declare const SearchSalesV0: import("../../../common/controller.js").ICon
                 } | null;
                 wrappedAssets: {
                     asset: {
-                        chainId: import("hono/utils/types").JSONValue;
+                        chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                         address: string;
                         type: string;
                         symbol: string;
@@ -66,7 +66,7 @@ export declare const SearchSalesV0: import("../../../common/controller.js").ICon
                 }[];
                 fundingAssets: {
                     asset: {
-                        chainId: import("hono/utils/types").JSONValue;
+                        chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                         address: string;
                         type: string;
                         symbol: string;

package/dist/fractions/sales/searchSales/searchSales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"searchSales.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/searchSales/searchSales.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA0DxB,CAAC"}
+{"version":3,"file":"searchSales.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/searchSales/searchSales.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA0DxB,CAAC"}

package/dist/fractions/sales/searchSales/searchSales.js

@@ -1,12 +1,12 @@
 import { and, eq } from "@ponder/client";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { FractionsSaleSchema, toFractionsSale } from "../common/fractionsSale.js";
 import { createController } from "../../../common/controller.js";
 import { AddressSchema, CampaignIdSchema, FractionsChainId, PlatformContractAddress } from "../../../common/index.js";
 import { indexerSchemas } from "../../../common/indexer/schemas.js";
 import { PageSchema } from "../../../common/models/page.js";
-import { FractionsSaleSchema, toFractionsSale } from "../common/fractionsSale.js";
 export const SearchSalesV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Search sale events",

package/dist/fractions/sales/searchWithdrawal.route.d.ts

@@ -8,7 +8,7 @@ export declare const SearchWithdrawalV0: import("../../common/controller.js").IC
                         limit: number;
                     };
                     filter: {
-                        chainId?: unknown;
+                        chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
                         platform?: string | undefined;
                         campaignId?: string | undefined;
                     };

package/dist/fractions/sales/searchWithdrawal.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"searchWithdrawal.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/searchWithdrawal.route.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuD7B,CAAC"}
+{"version":3,"file":"searchWithdrawal.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/searchWithdrawal.route.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuD7B,CAAC"}

package/dist/fractions/sales/searchWithdrawal.route.js

@@ -1,12 +1,12 @@
 import { and, eq } from "@ponder/client";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { FractionsSaleSchema } from "./common/fractionsSale.js";
 import { createController } from "../../common/controller.js";
 import { CampaignIdSchema, FractionsChainId, PlatformContractAddress } from "../../common/index.js";
 import { indexerSchemas } from "../../common/indexer/schemas.js";
 import { PageSchema } from "../../common/models/page.js";
-import { FractionsSaleSchema } from "./common/fractionsSale.js";
 export const SearchWithdrawalV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Search withdrawal events",

package/dist/fractions/sales/setFeeCapLimit.d.ts

@@ -1,16 +1,12 @@
-import { z } from "zod";
-export declare const SetFeeCapLimitRequestSchema: z.ZodObject<{
-    marketAddress: 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">>>;
-    packetsLimit: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-}, z.core.$strip>;
 export declare const SetFeeCapLimitV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    marketAddress: string;
-                    campaignId: string;
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
                     packetsLimit: string;
                 };
             };

package/dist/fractions/sales/setFeeCapLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setFeeCapLimit.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/setFeeCapLimit.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,2BAA2B;;;;iBAItC,CAAC;AAkBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}
+{"version":3,"file":"setFeeCapLimit.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/setFeeCapLimit.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}