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

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"}

package/dist/fractions/sales/setFeeCapLimit.js

@@ -1,15 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { setFeeCapLimit } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { SetFeeCapLimitConfigSchema } 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 SetFeeCapLimitRequestSchema = z.object({
-    marketAddress: AddressSchema,
-    campaignId: Int256BigInt(z.bigint().nonnegative()),
-    packetsLimit: Int256BigInt(z.bigint().nonnegative()),
-});
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Set fee cap limit",
     description: "Returns transaction data for setting the fee cap limit",
@@ -28,9 +22,9 @@ const route = describeRoute({
 export const SetFeeCapLimitV0 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", route, validator("json", SetFeeCapLimitRequestSchema.openapi("SetFeeCapLimitRequestSchema")), async (c) => {
-        const { marketAddress, campaignId, packetsLimit } = c.req.valid("json");
-        const tx = setFeeCapLimit(marketAddress, campaignId, packetsLimit);
+        .post("/", route, validator("json", SetFeeCapLimitConfigSchema.openapi("SetFeeCapLimitRequestSchema")), async (c) => {
+        const config = c.req.valid("json");
+        const tx = setFeeCapLimit(config);
         return c.json(toTransaction(tx));
     }),
 });

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

@@ -1,14 +1,12 @@
-export declare const UnlockWrappedAssetsRequestSchema: import("zod").ZodObject<{
-    market: import("zod").ZodPipe<import("zod").ZodString & import("zod").ZodType<`0x${string}`, string, import("zod/v4/core").$ZodTypeInternals<`0x${string}`, string>>, import("zod").ZodTransform<`0x${string}`, `0x${string}`>>;
-    campaignId: import("zod").ZodPipe<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "Int256", "out">, import("zod").ZodTransform<bigint, string & import("zod").$brand<"Int256">>>;
-}, import("zod/v4/core").$strip>;
 export declare const UnlockWrappedAssetsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    market: string;
-                    campaignId: string;
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"unlockWrappedAssets.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/unlockWrappedAssets.route.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gCAAgC;;;gCAAe,CAAC;AAkB7D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;aAchC,CAAC"}
+{"version":3,"file":"unlockWrappedAssets.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/unlockWrappedAssets.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;aAchC,CAAC"}

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

@@ -1,9 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { unlockWrappedAssets } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { UnlockWrappedAssetsConfigSchema } from "../schemas.js";
 import { createController } from "../../common/controller.js";
-import { SaleIdSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const UnlockWrappedAssetsRequestSchema = SaleIdSchema;
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Unlock wrapped assets from a non-funded sale",
     description: "Returns transaction to unlock wrapped assets from a non-funded sale",
@@ -22,9 +22,9 @@ const route = describeRoute({
 export const UnlockWrappedAssetsV0 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", route, validator("json", UnlockWrappedAssetsRequestSchema.openapi("UnlockWrappedAssetsRequestSchema")), async (c) => {
-        const { market, campaignId } = c.req.valid("json");
-        const tx = unlockWrappedAssets(market, campaignId);
+        .post("/", route, validator("json", UnlockWrappedAssetsConfigSchema.openapi("UnlockWrappedAssetsConfigSchema")), async (c) => {
+        const config = c.req.valid("json");
+        const tx = unlockWrappedAssets(config);
         return c.json(toTransaction(tx));
     }),
 });

package/dist/fractions/sales/vesting/claimStatistics.route.d.ts

@@ -1,12 +1,12 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const ClaimStatisticsRequestSchema: z.ZodObject<{
-    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>[]]>>;
+    chainId: z.ZodUnion<z.ZodLiteral<"1" | "31337" | "11155111" | "84532" | "72080">[]>;
     platform: 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">>>;
+    campaignId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     walletAddress: 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 ClaimStatisticsResponseSchema: z.ZodObject<{
-    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>[]]>>;
+    chainId: z.ZodUnion<z.ZodLiteral<"1" | "31337" | "11155111" | "84532" | "72080">[]>;
     platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     campaignId: z.ZodCoercedString<unknown>;
     totalClaims: z.ZodNumber;
@@ -16,21 +16,21 @@ export declare const ClaimStatisticsResponseSchema: z.ZodObject<{
         amount: z.ZodCoercedString<unknown>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const ClaimStatisticsV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+export declare const ClaimStatisticsV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    chainId: unknown;
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                     platform: string;
                     campaignId: string;
                     walletAddress: string;
                 };
             };
             output: {
-                chainId: 1 | 11155111 | 31337 | 84532 | 72080;
+                chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                 platform: `0x${string}`;
-                campaignId: never;
+                campaignId: string & z.core.$brand<"Int256">;
                 totalClaims: number;
                 lastClaimId: null;
                 totalClaimed: {

package/dist/fractions/sales/vesting/claimStatistics.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claimStatistics.route.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/vesting/claimStatistics.route.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,4BAA4B;;;;;iBAOL,CAAC;AAErC,eAAO,MAAM,6BAA6B;;;;;;;;;;iBAcL,CAAC;AAEtC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;aAyF5B,CAAC"}
+{"version":3,"file":"claimStatistics.route.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/vesting/claimStatistics.route.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,4BAA4B;;;;;iBAOL,CAAC;AAErC,eAAO,MAAM,6BAA6B;;;;;;;;;;iBAcL,CAAC;AAEtC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;aAyF5B,CAAC"}

package/dist/fractions/sales/vesting/claimStatistics.route.js

@@ -2,12 +2,12 @@ import { and, count, eq, max, sql } from "@ponder/client";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { toHex } from "viem";
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { AddressSchema } from "@evergonlabs/tmi-protocol-utils/zod";
 import { createController } from "../../../common/controller.js";
 import { indexerSchemas } from "../../../common/indexer/schemas.js";
 import { FractionsChainId } from "../../../common/models/chainId.js";
 import { CampaignIdSchema, PlatformContractAddress } from "../../../common/models/platform.js";
-import { AddressSchema } from "../../../common/models/viem.js";
 export const ClaimStatisticsRequestSchema = z
     .object({
     chainId: FractionsChainId,

package/dist/fractions/sales/vesting/claimVestedTokens.route.d.ts

@@ -1,11 +1,4 @@
-import { z } from "zod";
-export declare const ClaimVestedTokensRequestSchema: z.ZodObject<{
-    address: 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">>>;
-    amountOfFractions: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    itToBurn: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-}, z.core.$strip>;
-export declare const ClaimVestedTokensV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+export declare const ClaimVestedTokensV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context").AppContext, {
     "/": {
         $post: {
             input: {

package/dist/fractions/sales/vesting/claimVestedTokens.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claimVestedTokens.route.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/vesting/claimVestedTokens.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,8BAA8B;;;;;iBAKzC,CAAC;AAkBH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAsB9B,CAAC"}
+{"version":3,"file":"claimVestedTokens.route.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/vesting/claimVestedTokens.route.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAsB9B,CAAC"}

package/dist/fractions/sales/vesting/claimVestedTokens.route.js

@@ -1,16 +1,8 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
-import { claimVestedTokens } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { claimVestedTokens, ClaimVestedTokensRequestSchema } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { createController } from "../../../common/controller.js";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
-import { Int256BigInt } from "../../../common/int256.js";
-export const ClaimVestedTokensRequestSchema = z.object({
-    address: AddressSchema,
-    campaignId: Int256BigInt(z.bigint().positive()),
-    amountOfFractions: Int256BigInt(z.bigint().positive()),
-    itToBurn: Int256BigInt(z.bigint().nonnegative()),
-});
+import { toTransaction, TransactionSchema } from "../../../common/index.js";
 const route = describeRoute({
     summary: "Claim vested tokens",
     description: "Returns transaction data for claiming vested tokens from a campaign",

package/dist/fractions/sales/vesting/editCliff.route.d.ts

@@ -1,15 +1,9 @@
-import { z } from "zod";
-export declare const EditCliffRequestSchema: 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">>>;
-    newCliffDate: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
-}, z.core.$strip>;
-export declare const EditCliffV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+export declare const EditCliffV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    marketAddress: string;
+                    market: string;
                     saleId: string;
                     newCliffDate: string;
                 };
@@ -29,7 +23,7 @@ export declare const EditCliffV0: import("../../../common/controller.js").IContr
         } | {
             input: {
                 json: {
-                    marketAddress: string;
+                    market: string;
                     saleId: string;
                     newCliffDate: string;
                 };
@@ -42,7 +36,7 @@ export declare const EditCliffV0: import("../../../common/controller.js").IContr
         } | {
             input: {
                 json: {
-                    marketAddress: string;
+                    market: string;
                     saleId: string;
                     newCliffDate: string;
                 };

package/dist/fractions/sales/vesting/editCliff.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editCliff.route.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/vesting/editCliff.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAkBH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAiBtB,CAAC"}
+{"version":3,"file":"editCliff.route.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/vesting/editCliff.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAiBtB,CAAC"}

package/dist/fractions/sales/vesting/editCliff.route.js

@@ -1,16 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { buildEditCliffTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { createController } from "../../../common/controller.js";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
-import { Int256BigInt } from "../../../common/int256.js";
-import { ISODate } from "../../../common/models/base/date.js";
-export const EditCliffRequestSchema = z.object({
-    marketAddress: AddressSchema,
-    saleId: Int256BigInt(z.bigint().positive()),
-    newCliffDate: ISODate(),
-});
+import { toTransaction, TransactionSchema } from "../../../common/index.js";
+import { EditCliffConfigSchema } from "../../../fractions/schemas.js";
 const route = describeRoute({
     summary: "Edit the cliff of a vesting schedule",
     description: "Returns transaction data for updating the cliff date in a vesting schedule",
@@ -29,10 +22,10 @@ const route = describeRoute({
 export const EditCliffV0 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", route, validator("json", EditCliffRequestSchema.openapi("EditCliffRequestSchema")), async (c) => {
-        const { marketAddress, saleId, newCliffDate } = c.req.valid("json");
+        .post("/", route, validator("json", EditCliffConfigSchema.openapi("EditCliffConfigSchema")), async (c) => {
+        const config = c.req.valid("json");
         try {
-            const tx = buildEditCliffTx(marketAddress, saleId, newCliffDate);
+            const tx = buildEditCliffTx(config);
             return c.json(toTransaction(tx));
         }
         catch (error) {

package/dist/fractions/sales/vesting/parseClaimVestedTokensEvent.d.ts

@@ -1,10 +1,10 @@
-export declare const ParseClaimVestedTokensEventV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+export declare const ParseClaimVestedTokensEventV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context").AppContext, {
     "/": {
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {

package/dist/fractions/sales/vesting/parseClaimVestedTokensEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseClaimVestedTokensEvent.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/vesting/parseClaimVestedTokensEvent.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;aAkDxC,CAAC"}
+{"version":3,"file":"parseClaimVestedTokensEvent.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/vesting/parseClaimVestedTokensEvent.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;aAkDxC,CAAC"}

package/dist/fractions/sales/vesting/parseClaimVestedTokensEvent.js

@@ -1,8 +1,8 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { waitForTransactionReceipt } from "viem/actions";
-import { z } from "zod";
 import { parseClaimVestedTokensEvent } from "@evergonlabs/tmi-protocol-fractions-sdk";
+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";

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

@@ -1,14 +1,12 @@
-export declare const WithdrawRequestSchema: import("zod").ZodObject<{
-    market: import("zod").ZodPipe<import("zod").ZodString & import("zod").ZodType<`0x${string}`, string, import("zod/v4/core").$ZodTypeInternals<`0x${string}`, string>>, import("zod").ZodTransform<`0x${string}`, `0x${string}`>>;
-    campaignId: import("zod").ZodPipe<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "Int256", "out">, import("zod").ZodTransform<bigint, string & import("zod").$brand<"Int256">>>;
-}, import("zod/v4/core").$strip>;
 export declare const WithdrawV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    market: string;
-                    campaignId: string;
+                    campaign: {
+                        market: string;
+                        campaignId: string;
+                    };
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"withdraw.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/withdraw.route.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,qBAAqB;;;gCAAe,CAAC;AAkBlD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;aASrB,CAAC"}
+{"version":3,"file":"withdraw.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/withdraw.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;aASrB,CAAC"}

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

@@ -1,9 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { builtWithdrawTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { WithdrawConfigSchema } from "../schemas.js";
 import { createController } from "../../common/controller.js";
-import { SaleIdSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const WithdrawRequestSchema = SaleIdSchema;
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Withdraw payment tokens from a sale",
     description: "Returns transaction to withdraw payment tokens from a sale",
@@ -22,9 +22,9 @@ const route = describeRoute({
 export const WithdrawV0 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", route, validator("json", WithdrawRequestSchema.openapi("WithdrawRequestSchema")), async (c) => {
-        const { market, campaignId } = c.req.valid("json");
-        const tx = builtWithdrawTx(market, campaignId);
+        .post("/", route, validator("json", WithdrawConfigSchema.openapi("WithdrawConfigSchema")), async (c) => {
+        const config = c.req.valid("json");
+        const tx = builtWithdrawTx(config);
         return c.json(toTransaction(tx));
     }),
 });

package/dist/fractions/schemas.d.ts

@@ -0,0 +1,6 @@
+export { ApproveSaleRequestSchema, ApproveWrapperConfigSchema, BurnForDiscountSchema, CapConfigSchema, CapitalizationSchema, CheckAndJumpToNonFundedConfigSchema, CreateFractionsRequestSchema, DeployMarketRequestSchema, DiscountConfigSchema, EditCliffConfigSchema, ERC20TokenSchema, ERC721TokenSchema, ERC1155TokenSchema, FeeConfigSchema, FinishSaleRequestSchema, FractionSchema, FundingSchema, GrantMarketRoleRequestSchema, InitCompilotSignerConfigSchema, PurchaseRequestSchema, ReceiveFundsAfterNonFundedDiscountConfigSchema, ReceiveFundsAfterNonFundedNoDiscountConfigSchema, RecoverFractionsConfigSchema, RejectFractionsConfigSchema, RoleTypeEnumSchema, SetFeeCapLimitConfigSchema, TimeBoundarySchema, UnlockWrappedAssetsConfigSchema, VestingSchema, WithdrawConfigSchema, WrappedTokenTypeSchema, } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export declare const InitNftFractionsCompilotRequestSchema: import("zod").ZodObject<{
+    market: import("zod").ZodPipe<import("zod").ZodString & import("zod").ZodType<`0x${string}`, string, import("zod/v4/core").$ZodTypeInternals<`0x${string}`, string>>, import("zod").ZodTransform<`0x${string}`, `0x${string}`>>;
+    compilotSigner: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString & import("zod").ZodType<`0x${string}`, string, import("zod/v4/core").$ZodTypeInternals<`0x${string}`, string>>, import("zod").ZodTransform<`0x${string}`, `0x${string}`>>>;
+}, import("zod/v4/core").$strip>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/fractions/schemas.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,wBAAwB,EACxB,0BAA0B,EAC1B,qBAAqB,EACrB,eAAe,EACf,oBAAoB,EACpB,mCAAmC,EACnC,4BAA4B,EAC5B,yBAAyB,EACzB,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,uBAAuB,EACvB,cAAc,EACd,aAAa,EACb,4BAA4B,EAC5B,8BAA8B,EAC9B,qBAAqB,EACrB,8CAA8C,EAC9C,gDAAgD,EAChD,4BAA4B,EAC5B,2BAA2B,EAC3B,kBAAkB,EAClB,0BAA0B,EAC1B,kBAAkB,EAClB,+BAA+B,EAC/B,aAAa,EACb,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,yCAAyC,CAAC;AAEjD,eAAO,MAAM,qCAAqC;;;gCAEhD,CAAC"}

package/dist/fractions/schemas.js

@@ -0,0 +1,6 @@
+import { InitCompilotSignerConfigSchema } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { AddressSchema } from "../common/index.js";
+export { ApproveSaleRequestSchema, ApproveWrapperConfigSchema, BurnForDiscountSchema, CapConfigSchema, CapitalizationSchema, CheckAndJumpToNonFundedConfigSchema, CreateFractionsRequestSchema, DeployMarketRequestSchema, DiscountConfigSchema, EditCliffConfigSchema, ERC20TokenSchema, ERC721TokenSchema, ERC1155TokenSchema, FeeConfigSchema, FinishSaleRequestSchema, FractionSchema, FundingSchema, GrantMarketRoleRequestSchema, InitCompilotSignerConfigSchema, PurchaseRequestSchema, ReceiveFundsAfterNonFundedDiscountConfigSchema, ReceiveFundsAfterNonFundedNoDiscountConfigSchema, RecoverFractionsConfigSchema, RejectFractionsConfigSchema, RoleTypeEnumSchema, SetFeeCapLimitConfigSchema, TimeBoundarySchema, UnlockWrappedAssetsConfigSchema, VestingSchema, WithdrawConfigSchema, WrappedTokenTypeSchema, } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export const InitNftFractionsCompilotRequestSchema = InitCompilotSignerConfigSchema.extend({
+    compilotSigner: AddressSchema.optional().describe("Optional: Override default ComPilot signer address"),
+});

package/dist/fractions/sig/getAuthData.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 /**
  * functionCallData: functionCallData as `0x${string}`,
  *     contractAddress: diamondAddress_ as string,
@@ -10,19 +10,19 @@ import { z } from "zod";
 export declare const TxAuthDataRequestSchema: z.ZodObject<{
     marketAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     userAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 84532 | 72080>[]]>>;
-    nonce: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    blockExpiration: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    chainId: z.ZodUnion<z.ZodLiteral<"1" | "31337" | "11155111" | "84532" | "72080">[]>;
+    nonce: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    blockExpiration: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     callData: 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 GetAuthDataV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+export declare const GetAuthDataV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
                     marketAddress: string;
                     userAddress: string;
-                    chainId: unknown;
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                     nonce: string;
                     blockExpiration: string;
                     callData: string;

package/dist/fractions/sig/getAuthData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getAuthData.d.ts","sourceRoot":"","sources":["../../../src/fractions/sig/getAuthData.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;;;;;;GAOG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;iBAOlC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;aAoBxB,CAAC"}
+{"version":3,"file":"getAuthData.d.ts","sourceRoot":"","sources":["../../../src/fractions/sig/getAuthData.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD;;;;;;;GAOG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;iBAOlC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;aAoBxB,CAAC"}

package/dist/fractions/sig/getAuthData.js

@@ -1,11 +1,10 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { encodePacked, keccak256, padHex, toHex } from "viem";
-import { z } from "zod";
-import { HexStringSchema } from "@evergonlabs/tmi-utils/models";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { HexStringSchema, Int256Json } from "@evergonlabs/tmi-utils/models";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, FractionsChainId } from "../../common/index.js";
-import { Int256BigInt } from "../../common/int256.js";
 /**
  * functionCallData: functionCallData as `0x${string}`,
  *     contractAddress: diamondAddress_ as string,
@@ -18,8 +17,8 @@ export const TxAuthDataRequestSchema = z.object({
     marketAddress: AddressSchema,
     userAddress: AddressSchema,
     chainId: FractionsChainId,
-    nonce: Int256BigInt(),
-    blockExpiration: Int256BigInt(),
+    nonce: Int256Json,
+    blockExpiration: Int256Json,
     callData: HexStringSchema,
 });
 const route = describeRoute({

package/dist/fractions/sig/getNonce.route.d.ts

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

package/dist/fractions/sig/getNonce.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNonce.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sig/getNonce.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AAkBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;aAiBrB,CAAC"}
+{"version":3,"file":"getNonce.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sig/getNonce.route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AAkBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;aAiBrB,CAAC"}

package/dist/fractions/sig/getNonce.route.js

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { ABIS } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { getPublicClient } from "../../common/blockchain.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, FractionsChainId } from "../../common/index.js";

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

@@ -5,7 +5,7 @@ export declare const SigController: import("../../common/controller.js").IContro
                 json: {
                     marketAddress: string;
                     userAddress: string;
-                    chainId: unknown;
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                 };
             };
             output: {
@@ -22,7 +22,7 @@ export declare const SigController: import("../../common/controller.js").IContro
                 json: {
                     marketAddress: string;
                     userAddress: string;
-                    chainId: unknown;
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                     nonce: string;
                     blockExpiration: string;
                     callData: string;

package/dist/fractions/sig/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fractions/sig/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGxB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fractions/sig/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAGxB,CAAC"}

package/dist/fractions/sig/index.js

@@ -1,6 +1,6 @@
-import { createController } from "../../common/controller.js";
 import { GetAuthDataV0 } from "./getAuthData.js";
 import { GetNonceV0 } from "./getNonce.route.js";
+import { createController } from "../../common/controller.js";
 export const SigController = createController({
     build: (factory) => factory.createApp().route("/nonce", GetNonceV0.build(factory)).route("/authData", GetAuthDataV0.build(factory)),
 });