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

package/dist/fractions/markets/{searchMarkets/searchMarkets.d.ts → searchMarkets.d.ts}

@@ -1,4 +1,4 @@
-export declare const SearchMarketsV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+export declare const SearchMarketsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
@@ -8,20 +8,20 @@ export declare const SearchMarketsV0: import("../../../common/controller.js").IC
                         limit: number;
                     };
                     filter: {
-                        chainId?: unknown;
+                        chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
                         owner?: string | undefined;
                     };
                 };
             };
             output: {
-                chainId: import("hono/utils/types").JSONValue;
+                chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                 transactionHash: string;
                 template: "unknown" | "default" | "compilot" | "continuous-withdrawal" | "continuous-withdrawal-nid" | "lending";
                 contractAddress: string;
                 adminAddress: string;
                 wrapperAddress: string | null;
                 burnAsset: {
-                    chainId: import("hono/utils/types").JSONValue;
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                     address: string;
                     type: string;
                     symbol: string;

package/dist/fractions/markets/searchMarkets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchMarkets.d.ts","sourceRoot":"","sources":["../../../src/fractions/markets/searchMarkets.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAqD1B,CAAC"}

package/dist/fractions/markets/{searchMarkets/searchMarkets.js → searchMarkets.js}

@@ -1,19 +1,17 @@
 import { and, eq } from "@ponder/client";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
-import { createController } from "../../../common/controller.js";
-import { AddressSchema, FractionsChainId } from "../../../common/index.js";
-import { indexerSchemas } from "../../../common/indexer/schemas.js";
-import { PageSchema } from "../../../common/models/page.js";
-import { createTag } from "../../../common/tag.js";
-import { FractionsMarketSchema, mapToFractionsMarket } from "../common/platform.js";
-const tag = createTag("Markets");
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { FractionsMarketSchema, mapToFractionsMarket, marketsTag } from "./utils.js";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, FractionsChainId } from "../../common/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { PageSchema } from "../../common/models/page.js";
 export const SearchMarketsV0 = createController({
     build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Search markets",
         description: "Retrieve a list of markets with filtering and sorting",
-        tags: [tag.tag],
+        tags: [marketsTag.tag],
         responses: {
             200: {
                 description: "Returns list of platforms by specified filter",

package/dist/fractions/markets/{common/platform.d.ts → utils.d.ts}

@@ -1,7 +1,7 @@
-import { z } from "zod";
-import { indexerSchemas } from "../../../common/indexer/schemas.js";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
 export declare const FractionsMarketSchema: 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">[]>;
     transactionHash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     template: z.ZodEnum<{
         unknown: "unknown";
@@ -15,7 +15,7 @@ export declare const FractionsMarketSchema: z.ZodObject<{
     adminAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     wrapperAddress: z.ZodNullable<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
     burnAsset: z.ZodNullable<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">[]>;
         address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
         type: z.ZodString;
         symbol: z.ZodString;
@@ -25,8 +25,11 @@ export declare const FractionsMarketSchema: z.ZodObject<{
         burnable: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     feesBps: z.ZodNullable<z.ZodNumber>;
-    createdAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
-    updatedAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+    createdAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+    updatedAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
 }, z.core.$strip>;
 export declare function mapToFractionsMarket(diamond: typeof indexerSchemas.fractions.fractionsMarkets.$inferSelect, burnAsset: typeof indexerSchemas.assets.$inferSelect | null): z.input<typeof FractionsMarketSchema>;
-//# sourceMappingURL=platform.d.ts.map
+export declare const marketsTag: {
+    tag: "Markets";
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/fractions/markets/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/fractions/markets/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAWxD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAG7D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAaL,CAAC;AAE9B,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,cAAc,CAAC,SAAS,CAAC,gBAAgB,CAAC,YAAY,EACtE,SAAS,EAAE,OAAO,cAAc,CAAC,MAAM,CAAC,YAAY,GAAG,IAAI,GAC1D,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAavC;AAED,eAAO,MAAM,UAAU;;CAAuB,CAAC"}

package/dist/fractions/markets/{common/platform.js → utils.js}

@@ -1,7 +1,8 @@
-import { z } from "zod";
-import { AddressSchema, AssetSchema, FractionsChainId, FractionsMarketTemplateSchema, HashSchema, } from "../../../common/index.js";
-import { toISOJson } from "../../../common/models/base/date.js";
-import { ISOJson } from "../../../common/models/date.js";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { toISOJson } from "@evergonlabs/tmi-protocol-utils/zod";
+import { ISOJson } from "@evergonlabs/tmi-protocol-utils/zod";
+import { AddressSchema, AssetSchema, FractionsChainId, FractionsMarketTemplateSchema, HashSchema, } from "../../common/index.js";
+import { createTag } from "../../common/tag.js";
 export const FractionsMarketSchema = z
     .object({
     chainId: FractionsChainId,
@@ -18,7 +19,7 @@ export const FractionsMarketSchema = z
     .openapi("FractionsMarket");
 export function mapToFractionsMarket(diamond, burnAsset) {
     return {
-        chainId: diamond.chainId,
+        chainId: `${diamond.chainId}`,
         transactionHash: diamond.transactionHash,
         template: FractionsMarketTemplateSchema.parse(diamond.template),
         contractAddress: diamond.contractAddress,
@@ -30,3 +31,4 @@ export function mapToFractionsMarket(diamond, burnAsset) {
         updatedAt: toISOJson(diamond.updatedAt),
     };
 }
+export const marketsTag = createTag("Markets");

package/dist/fractions/roles/getRoles.d.ts

@@ -1,4 +1,4 @@
-export declare const GetFractionsRolesV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+export declare const GetFractionsRolesV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
     "/": {
         $get: {
             input: {};

package/dist/fractions/roles/getRoles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getRoles.d.ts","sourceRoot":"","sources":["../../../src/fractions/roles/getRoles.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;aAqB9B,CAAC"}
+{"version":3,"file":"getRoles.d.ts","sourceRoot":"","sources":["../../../src/fractions/roles/getRoles.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;aAqB9B,CAAC"}

package/dist/fractions/roles/getRoles.js

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver } from "hono-openapi";
-import { z } from "zod";
 import { FractionsRole, getFractionsRole } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { createController } from "../../common/controller.js";
 import { RoleSchema } from "../../staking/roles/common/role.js";
 export const GetFractionsRolesV0 = createController({

package/dist/fractions/roles/{grantRole.route.d.ts → grantRole.d.ts}

@@ -3,7 +3,6 @@ export declare const GrantFractionsRoleV0: import("../../common/controller.js").
         $post: {
             input: {
                 json: {
-                    chainId: unknown;
                     marketAddress: string;
                     users: string[];
                     role: import("@evergonlabs/tmi-protocol-fractions-sdk").RoleTypeEnum;
@@ -24,4 +23,4 @@ export declare const GrantFractionsRoleV0: import("../../common/controller.js").
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=grantRole.route.d.ts.map
+//# sourceMappingURL=grantRole.d.ts.map

package/dist/fractions/roles/grantRole.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/fractions/roles/grantRole.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;aAmB/B,CAAC"}

package/dist/fractions/roles/{grantRole.route.js → grantRole.js}

@@ -1,9 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { buildGrantRoleTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { GrantMarketRoleRequestSchema } from "../schemas.js";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";
-import { GrantMarketRoleRequestSchema } from "./grantRole.schema.js";
 const route = describeRoute({
     summary: "Grant a role",
     description: "Returns transaction data for granting a role in a market",

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

@@ -24,7 +24,6 @@ export declare const RolesController: import("../../common/controller.js").ICont
         $post: {
             input: {
                 json: {
-                    chainId: unknown;
                     marketAddress: string;
                     users: string[];
                     role: import("@evergonlabs/tmi-protocol-fractions-sdk").RoleTypeEnum;

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

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

package/dist/fractions/roles/index.js

@@ -1,6 +1,6 @@
-import { createController } from "../../common/controller.js";
 import { GetFractionsRolesV0 } from "./getRoles.js";
-import { GrantFractionsRoleV0 } from "./grantRole.route.js";
+import { GrantFractionsRoleV0 } from "./grantRole.js";
+import { createController } from "../../common/controller.js";
 export const RolesController = createController({
     build: (factory) => factory
         .createApp()

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

@@ -1,13 +1,13 @@
-import { z } from "zod";
 import { FractionSaleEventEnum, FractionSaleStatusEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const FractionActivityEntrySchema: 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.core.$ZodBranded<z.ZodString, "Int256", "out">;
     transactionHash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     from: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    createdAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
-    updatedAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+    createdAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+    updatedAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
     metadata: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<FractionSaleEventEnum.CREATED>;
     }, z.core.$strip>, z.ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"activityUtils.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/activityUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAgEzG,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYT,CAAC"}
+{"version":3,"file":"activityUtils.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/activityUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AACzG,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAiExD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYT,CAAC"}

package/dist/fractions/sales/activityUtils.js

@@ -1,9 +1,9 @@
-import { z } from "zod";
 import { FractionSaleEventEnum, FractionSaleStatusEnum } from "@evergonlabs/tmi-protocol-indexer/schema";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { ISOJson } from "@evergonlabs/tmi-protocol-utils/zod";
 import { AddressSchema, TransactionHashSchema } from "@evergonlabs/tmi-utils/models";
 import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { FractionsChainId, PlatformContractAddress } from "../../common/index.js";
-import { ISOJson } from "../../common/models/date.js";
 const baseSchema = z.object({
     chainId: FractionsChainId,
     platform: PlatformContractAddress,

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

@@ -1,15 +1,12 @@
-import { z } from "zod";
-export declare const ApproveSaleRequestSchema: 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">>>;
-}, z.core.$strip>;
 export declare const ApproveSaleV0: 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;
+                    };
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"approveSale.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/approveSale.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;aASxB,CAAC"}
+{"version":3,"file":"approveSale.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/approveSale.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;aASxB,CAAC"}

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

@@ -1,14 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { buildApproveSaleTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { ApproveSaleRequestSchema } 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 ApproveSaleRequestSchema = z.object({
-    marketAddress: AddressSchema,
-    campaignId: Int256BigInt(z.bigint().nonnegative()),
-});
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Approve a sale",
     description: "Returns transaction data for approving a sale",
@@ -28,8 +23,8 @@ export const ApproveSaleV0 = createController({
     build: (factory) => factory
         .createApp()
         .post("/", route, validator("json", ApproveSaleRequestSchema.openapi("ApproveSaleRequestSchema")), async (c) => {
-        const { marketAddress, campaignId } = c.req.valid("json");
-        const tx = buildApproveSaleTx({ market: marketAddress, campaignId: campaignId });
+        const config = c.req.valid("json");
+        const tx = buildApproveSaleTx(config);
         return c.json(toTransaction(tx));
     }),
 });

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

@@ -1,15 +1,10 @@
-import { z } from "zod";
-export declare const ApproveWrapperRequestSchema: z.ZodObject<{
-    marketAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    wrapperAddress: 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 ApproveWrapperV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $post: {
             input: {
                 json: {
-                    marketAddress: string;
-                    wrapperAddress: string;
+                    market: string;
+                    wrapper: string;
                 };
             };
             output: {

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

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

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

@@ -1,13 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { buildApproveWrapperTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { ApproveWrapperConfigSchema } from "../schemas.js";
 import { createController } from "../../common/controller.js";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const ApproveWrapperRequestSchema = z.object({
-    marketAddress: AddressSchema,
-    wrapperAddress: AddressSchema,
-});
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Approve a wrapper",
     description: "Returns transaction data for approving a wrapper",
@@ -26,9 +22,9 @@ const route = describeRoute({
 export const ApproveWrapperV0 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", route, validator("json", ApproveWrapperRequestSchema.openapi("ApproveWrapperRequestSchema")), async (c) => {
-        const { marketAddress, wrapperAddress } = c.req.valid("json");
-        const tx = buildApproveWrapperTx(marketAddress, wrapperAddress);
+        .post("/", route, validator("json", ApproveWrapperConfigSchema.openapi("ApproveWrapperConfigSchema")), async (c) => {
+        const config = c.req.valid("json");
+        const tx = buildApproveWrapperTx(config);
         return c.json(toTransaction(tx));
     }),
 });

package/dist/fractions/sales/common/fractionsSale.d.ts

@@ -1,21 +1,21 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { indexerSchemas } from "../../../common/indexer/schemas.js";
 export declare const FractionsSaleSchema: 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.core.$ZodBranded<z.ZodString, "Int256", "out">;
     nftId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     status: z.ZodEnum<{
-        finalized: "finalized";
         created: "created";
         approved: "approved";
         rejected: "rejected";
+        finalized: "finalized";
         refunded: "refunded";
     }>;
     owner: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     fractions: z.ZodObject<{
         asset: 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">[]>;
             address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
             type: z.ZodString;
             symbol: z.ZodString;
@@ -34,17 +34,17 @@ export declare const FractionsSaleSchema: z.ZodObject<{
         softCapPerAccount: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Int256", "out">>;
     }, z.core.$strip>>;
     timeline: z.ZodNullable<z.ZodObject<{
-        startDate: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
-        endDate: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "ISO", "out">>;
+        startDate: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+        endDate: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">>;
     }, z.core.$strip>>;
     vesting: z.ZodNullable<z.ZodObject<{
-        cliffDate: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+        cliffDate: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
         totalVestingPeriod: z.ZodNumber;
         portionPeriod: z.ZodNumber;
     }, z.core.$strip>>;
     wrappedAssets: z.ZodArray<z.ZodObject<{
         asset: 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">[]>;
             address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
             type: z.ZodString;
             symbol: z.ZodString;
@@ -57,7 +57,7 @@ export declare const FractionsSaleSchema: z.ZodObject<{
     }, z.core.$strip>>;
     fundingAssets: z.ZodArray<z.ZodObject<{
         asset: 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">[]>;
             address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
             type: z.ZodString;
             symbol: z.ZodString;
@@ -69,8 +69,8 @@ export declare const FractionsSaleSchema: z.ZodObject<{
         amountPerPacket: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     }, z.core.$strip>>;
     transactionHash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    createdAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
-    updatedAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+    createdAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+    updatedAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
 }, z.core.$strip>;
 export declare function toFractionsSale(raw: typeof indexerSchemas.fractions.fractionsSales.$inferSelect, fractionsAsset: typeof indexerSchemas.assets.$inferSelect, wrappedAssets: any[], fundingAssets: any[]): z.input<typeof FractionsSaleSchema>;
 //# sourceMappingURL=fractionsSale.d.ts.map

package/dist/fractions/sales/common/fractionsSale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionsSale.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/common/fractionsSale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAIpE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDL,CAAC;AAE5B,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,cAAc,CAAC,SAAS,CAAC,cAAc,CAAC,YAAY,EAChE,cAAc,EAAE,OAAO,cAAc,CAAC,MAAM,CAAC,YAAY,EAEzD,aAAa,EAAE,GAAG,EAAE,EACpB,aAAa,EAAE,GAAG,EAAE,GACnB,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CA6BrC"}
+{"version":3,"file":"fractionsSale.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/common/fractionsSale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAaxD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDL,CAAC;AAE5B,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,cAAc,CAAC,SAAS,CAAC,cAAc,CAAC,YAAY,EAChE,cAAc,EAAE,OAAO,cAAc,CAAC,MAAM,CAAC,YAAY,EAEzD,aAAa,EAAE,GAAG,EAAE,EACpB,aAAa,EAAE,GAAG,EAAE,GACnB,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CA6BrC"}

package/dist/fractions/sales/common/fractionsSale.js

@@ -1,8 +1,8 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { toISOJson } from "@evergonlabs/tmi-protocol-utils/zod";
+import { ISOJson } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { AddressSchema, AssetSchema, FractionsChainId, FractionsSaleStatusSchema, HashSchema, PlatformContractAddress, } from "../../../common/index.js";
-import { toISOJson } from "../../../common/models/base/date.js";
-import { ISOJson } from "../../../common/models/date.js";
 export const FractionsSaleSchema = z
     .object({
     chainId: FractionsChainId,

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

@@ -1,15 +1,12 @@
-import { z } from "zod";
-export declare const CompleteSaleRequestSchema: 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">>>;
-}, z.core.$strip>;
 export declare const CompleteSaleV0: 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;
+                    };
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"completeSale.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/completeSale.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;aAgBzB,CAAC"}
+{"version":3,"file":"completeSale.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/completeSale.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;aAUzB,CAAC"}

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

@@ -1,14 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { buildFinishSaleTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { FinishSaleRequestSchema } 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 CompleteSaleRequestSchema = z.object({
-    marketAddress: AddressSchema,
-    campaignId: Int256BigInt(z.bigint().nonnegative()),
-});
+import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({
     summary: "Complete a sale",
     description: "Returns transaction data for completing a sale",
@@ -27,9 +22,9 @@ const route = describeRoute({
 export const CompleteSaleV0 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", route, validator("json", CompleteSaleRequestSchema.openapi("CompleteSaleRequestSchema")), async (c) => {
-        const { marketAddress, campaignId } = c.req.valid("json");
-        const tx = buildFinishSaleTx({ market: marketAddress, campaignId: campaignId });
+        .post("/", route, validator("json", FinishSaleRequestSchema.openapi("FinishSaleRequestSchema")), async (c) => {
+        const config = c.req.valid("json");
+        const tx = buildFinishSaleTx(config);
         return c.json(toTransaction(tx));
     }),
 });

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

@@ -3,13 +3,12 @@ export declare const CreateFractionsV0: import("../../common/controller.js").ICo
         $post: {
             input: {
                 json: {
-                    chainId: unknown;
+                    chainId: number;
                     market: string;
                     fractions: {
                         symbol: string;
                         name: string;
                         amount: string;
-                        token?: string | undefined;
                     };
                     timeBoundary: {
                         start: string;
@@ -44,7 +43,7 @@ export declare const CreateFractionsV0: import("../../common/controller.js").ICo
                     discounts?: {
                         burnableTokenAddress: string;
                         amountToBurn: string;
-                        percentDiscount: number;
+                        percentDiscount: string;
                     } | undefined;
                     vesting?: {
                         cliff: string;

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

@@ -1 +1 @@
-{"version":3,"file":"createFractions.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/createFractions.route.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAmD5B,CAAC"}
+{"version":3,"file":"createFractions.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/createFractions.route.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAiD5B,CAAC"}

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

@@ -1,9 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { buildCreateFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { CreateFractionsRequestSchema } from "../schemas.js";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";
-import { CreateFractionsRequestSchema, createWrapped } from "./createFractions.schema.js";
 const route = describeRoute({
     summary: "Create fractions",
     description: "Returns transaction data for creating fractions",
@@ -24,11 +24,10 @@ export const CreateFractionsV0 = createController({
         .createApp()
         .post("/", route, validator("json", CreateFractionsRequestSchema.openapi("CreateFractionsRequestSchema")), async (c) => {
         const { chainId, market, wrapped, funding, fractions, timeBoundary, cap, vesting, amountOfPacketsPerFraction, refundAddress, discounts, } = c.req.valid("json");
-        const wrappedTokens = wrapped.map(createWrapped);
         const fractionsConfig = {
             chainId: chainId,
             market: market,
-            wrapped: wrappedTokens,
+            wrapped: wrapped,
             funding: funding,
             fractions: {
                 name: fractions.name,

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

@@ -1,6 +1,6 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const FractionsSaleStatisticSchema: 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>;
     statistics: z.ZodArray<z.ZodObject<{
@@ -9,18 +9,18 @@ export declare const FractionsSaleStatisticSchema: z.ZodObject<{
         purchases: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const GetFractionSaleStatisticsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+export declare const GetFractionSaleStatisticsV0: 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;
                 };
             };
             output: {
-                chainId: 1 | 11155111 | 31337 | 84532 | 72080;
+                chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                 platform: `0x${string}`;
                 campaignId: string;
                 statistics: {

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

@@ -1 +1 @@
-{"version":3,"file":"getFractionSaleStatistics.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getFractionSaleStatistics.route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,4BAA4B;;;;;;;;;iBAaJ,CAAC;AAEtC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;aAkEtC,CAAC"}
+{"version":3,"file":"getFractionSaleStatistics.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getFractionSaleStatistics.route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,4BAA4B;;;;;;;;;iBAaJ,CAAC;AAEtC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;aAkEtC,CAAC"}

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

@@ -1,7 +1,7 @@
 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 { createController } from "../../common/controller.js";
 import { CampaignIdSchema, FractionsChainId, PlatformContractAddress } from "../../common/index.js";
 import { indexerSchemas } from "../../common/indexer/schemas.js";