@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

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

@@ -1,352 +1,76 @@
-import { z } from "../../../common/zod.js";
+import { z } from "zod";
 import { indexerSchemas } from "../../../common/indexer/schemas.js";
 export declare const FractionsSaleSchema: z.ZodObject<{
-    chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
-    platform: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    campaignId: z.ZodNumber;
-    nftId: z.ZodNumber;
-    status: z.ZodEnum<["created", "approved", "rejected", "finalized", "refunded"]>;
-    owner: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 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<{
+        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.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
-            address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+            chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 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;
             name: z.ZodString;
-            tokenId: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+            tokenId: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
             decimals: z.ZodDefault<z.ZodNumber>;
             burnable: z.ZodDefault<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        }, {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals?: number | undefined;
-            burnable?: boolean | undefined;
-        }>;
-        totalFractions: z.ZodString;
-        price: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        totalFractions: string;
-        price: string;
-    }, {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals?: number | undefined;
-            burnable?: boolean | undefined;
-        };
-        totalFractions: string;
-        price: string;
-    }>;
-    capitalization: z.ZodUnion<[z.ZodObject<{
-        hardCap: z.ZodString;
-        hardCapPerAccount: z.ZodString;
-        softCap: z.ZodString;
-        softCapPerAccount: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        softCap: string;
-        hardCap: string;
-        softCapPerAccount: string;
-        hardCapPerAccount: string;
-    }, {
-        softCap: string;
-        hardCap: string;
-        softCapPerAccount: string;
-        hardCapPerAccount: string;
-    }>, z.ZodNull]>;
-    timeline: z.ZodUnion<[z.ZodObject<{
-        startDate: z.ZodString;
-        endDate: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        startDate: string;
-        endDate: string;
-    }, {
-        startDate: string;
-        endDate: string;
-    }>, z.ZodNull]>;
-    vesting: z.ZodUnion<[z.ZodObject<{
-        cliffDate: z.ZodString;
+        }, z.core.$strip>;
+        totalFractions: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        price: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    }, z.core.$strip>;
+    capitalization: z.ZodNullable<z.ZodObject<{
+        hardCap: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Int256", "out">>;
+        hardCapPerAccount: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Int256", "out">>;
+        softCap: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Int256", "out">>;
+        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">>;
+    }, z.core.$strip>>;
+    vesting: z.ZodNullable<z.ZodObject<{
+        cliffDate: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
         totalVestingPeriod: z.ZodNumber;
         portionPeriod: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        cliffDate: string;
-        totalVestingPeriod: number;
-        portionPeriod: number;
-    }, {
-        cliffDate: string;
-        totalVestingPeriod: number;
-        portionPeriod: number;
-    }>, z.ZodNull]>;
+    }, z.core.$strip>>;
     wrappedAssets: z.ZodArray<z.ZodObject<{
         asset: z.ZodObject<{
-            chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
-            address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+            chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 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;
             name: z.ZodString;
-            tokenId: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+            tokenId: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
             decimals: z.ZodDefault<z.ZodNumber>;
             burnable: z.ZodDefault<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        }, {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals?: number | undefined;
-            burnable?: boolean | undefined;
-        }>;
-        wrappedAmount: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
-    }, "strip", z.ZodTypeAny, {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        wrappedAmount: bigint;
-    }, {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals?: number | undefined;
-            burnable?: boolean | undefined;
-        };
-        wrappedAmount: string | number | bigint;
-    }>, "many">;
+        }, z.core.$strip>;
+        wrappedAmount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    }, z.core.$strip>>;
     fundingAssets: z.ZodArray<z.ZodObject<{
         asset: z.ZodObject<{
-            chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
-            address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+            chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 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;
             name: z.ZodString;
-            tokenId: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+            tokenId: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
             decimals: z.ZodDefault<z.ZodNumber>;
             burnable: z.ZodDefault<z.ZodBoolean>;
-        }, "strip", z.ZodTypeAny, {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        }, {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals?: number | undefined;
-            burnable?: boolean | undefined;
-        }>;
-        amountPerPacket: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
-    }, "strip", z.ZodTypeAny, {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        amountPerPacket: bigint;
-    }, {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals?: number | undefined;
-            burnable?: boolean | undefined;
-        };
-        amountPerPacket: string | number | bigint;
-    }>, "many">;
-    transactionHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    status: "created" | "approved" | "rejected" | "finalized" | "refunded";
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    createdAt: string;
-    updatedAt: string;
-    campaignId: number;
-    transactionHash: `0x${string}`;
-    nftId: number;
-    fractions: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        totalFractions: string;
-        price: string;
-    };
-    platform: `0x${string}`;
-    owner: `0x${string}`;
-    vesting: {
-        cliffDate: string;
-        totalVestingPeriod: number;
-        portionPeriod: number;
-    } | null;
-    capitalization: {
-        softCap: string;
-        hardCap: string;
-        softCapPerAccount: string;
-        hardCapPerAccount: string;
-    } | null;
-    timeline: {
-        startDate: string;
-        endDate: string;
-    } | null;
-    wrappedAssets: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        wrappedAmount: bigint;
-    }[];
-    fundingAssets: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        amountPerPacket: bigint;
-    }[];
-}, {
-    status: "created" | "approved" | "rejected" | "finalized" | "refunded";
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    createdAt: string;
-    updatedAt: string;
-    campaignId: number;
-    transactionHash: `0x${string}`;
-    nftId: number;
-    fractions: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals?: number | undefined;
-            burnable?: boolean | undefined;
-        };
-        totalFractions: string;
-        price: string;
-    };
-    platform: `0x${string}`;
-    owner: `0x${string}`;
-    vesting: {
-        cliffDate: string;
-        totalVestingPeriod: number;
-        portionPeriod: number;
-    } | null;
-    capitalization: {
-        softCap: string;
-        hardCap: string;
-        softCapPerAccount: string;
-        hardCapPerAccount: string;
-    } | null;
-    timeline: {
-        startDate: string;
-        endDate: string;
-    } | null;
-    wrappedAssets: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals?: number | undefined;
-            burnable?: boolean | undefined;
-        };
-        wrappedAmount: string | number | bigint;
-    }[];
-    fundingAssets: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals?: number | undefined;
-            burnable?: boolean | undefined;
-        };
-        amountPerPacket: string | number | bigint;
-    }[];
-}>;
-export declare function toFractionsSale(raw: typeof indexerSchemas.fractions.fractionsSales.$inferSelect, fractionsAsset: typeof indexerSchemas.assets.$inferSelect, wrappedAssets: any[], fundingAssets: any[]): z.output<typeof FractionsSaleSchema>;
+        }, z.core.$strip>;
+        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">;
+}, 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,wBAAwB,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAapE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuD5B,CAAC;AAEL,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,cAAc,CAAC,SAAS,CAAC,cAAc,CAAC,YAAY,EAChE,cAAc,EAAE,OAAO,cAAc,CAAC,MAAM,CAAC,YAAY,EACzD,aAAa,EAAE,GAAG,EAAE,EACpB,aAAa,EAAE,GAAG,EAAE,GACnB,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAgCtC"}
+{"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;AAGpE,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,123 +1,108 @@
-import { z } from "../../../common/zod.js";
-import { AddressSchema, HashSchema, PlatformContractAddress, TmiChainIdSchema, AssetSchema, FractionsSaleStatusSchema, } from "../../../common/index.js";
-import { ISOSchema } from "../../../common/models/date.js";
-import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { z } from "zod";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
+import { AddressSchema, AssetSchema, FractionsChainId, FractionsSaleStatusSchema, HashSchema, PlatformContractAddress, } from "../../../common/index.js";
+import { ISOJson, toISOJson } from "../../../common/models/date.js";
 export const FractionsSaleSchema = z
     .object({
-    chainId: TmiChainIdSchema,
+    chainId: FractionsChainId,
     platform: PlatformContractAddress,
-    // campaignId: CampaignIdSchema,
-    campaignId: z.number(),
-    // nftId: Int256Positive,
-    nftId: z.number(),
+    campaignId: Int256Json,
+    nftId: Int256Json,
     status: FractionsSaleStatusSchema,
     owner: AddressSchema.openapi({
         description: "Address role assigned to",
     }),
     fractions: z.object({
         asset: AssetSchema,
-        // totalFractions: Int256Positive,
-        totalFractions: z.string(),
-        // price: Int256Positive,
-        price: z.string(),
+        totalFractions: Int256Json,
+        price: Int256Json,
     }),
-    capitalization: z.union([
-        z.object({
-            // hardCap: Int256Positive,
-            // hardCapPerAccount: Int256Positive,
-            // softCap: Int256Positive,
-            // softCapPerAccount: Int256Positive,
-            hardCap: z.string(),
-            hardCapPerAccount: z.string(),
-            softCap: z.string(),
-            softCapPerAccount: z.string(),
-        }),
-        z.null(),
-    ]),
-    timeline: z.union([
-        z.object({
-            startDate: ISOSchema,
-            endDate: ISOSchema,
-        }),
-        z.null(),
-    ]),
-    vesting: z.union([
-        z.object({
-            cliffDate: ISOSchema,
-            totalVestingPeriod: z.number().nonnegative(),
-            portionPeriod: z.number().nonnegative(),
-        }),
-        z.null(),
-    ]),
-    wrappedAssets: z.array(z.object({ asset: AssetSchema, wrappedAmount: Int256Positive })),
-    fundingAssets: z.array(z.object({ asset: AssetSchema, amountPerPacket: Int256Positive })),
+    capitalization: z.nullable(z.object({
+        hardCap: z.nullable(Int256Json),
+        hardCapPerAccount: z.nullable(Int256Json),
+        softCap: z.nullable(Int256Json),
+        softCapPerAccount: z.nullable(Int256Json),
+    })),
+    timeline: z.nullable(z.object({
+        startDate: ISOJson,
+        endDate: z.nullable(ISOJson),
+    })),
+    vesting: z.nullable(z.object({
+        cliffDate: ISOJson,
+        totalVestingPeriod: z.number().nonnegative(),
+        portionPeriod: z.number().nonnegative(),
+    })),
+    wrappedAssets: z.array(z.object({
+        asset: AssetSchema,
+        wrappedAmount: Int256Json,
+    })),
+    fundingAssets: z.array(z.object({
+        asset: AssetSchema,
+        amountPerPacket: Int256Json,
+    })),
     transactionHash: HashSchema,
-    createdAt: ISOSchema,
-    updatedAt: ISOSchema,
+    createdAt: ISOJson,
+    updatedAt: ISOJson,
 })
-    .openapi({
-    ref: "FractionsSale",
-});
-export function toFractionsSale(raw, fractionsAsset, wrappedAssets, fundingAssets) {
+    .openapi("FractionsSale");
+export function toFractionsSale(raw, fractionsAsset, 
+// @todo fix this any type
+wrappedAssets, fundingAssets) {
     const fractions = toSaleFractions(raw, fractionsAsset);
     const capitalization = toSaleCapitalization(raw);
     const timeline = toSaleTimeline(raw);
     const vesting = toSaleVesting(raw);
     return {
-        chainId: TmiChainIdSchema.parse(raw.chainId),
+        chainId: FractionsChainId.parse(raw.chainId),
         platform: AddressSchema.parse(raw.diamondAddress),
-        campaignId: Number(raw.saleId),
-        nftId: Number(raw.nftId),
+        campaignId: toInt256Json(raw.saleId),
+        nftId: toInt256Json(raw.nftId),
         owner: AddressSchema.parse(raw.creator),
         status: FractionsSaleStatusSchema.parse(raw.status),
-        wrappedAssets: wrappedAssets.map((wrapped) => ({
-            asset: AssetSchema.parse(wrapped.asset),
-            wrappedAmount: wrapped.wrappedAmount.toString(),
+        wrappedAssets: wrappedAssets.map((x) => ({
+            asset: AssetSchema.parse(x.asset),
+            wrappedAmount: toInt256Json(x.wrappedAmount),
         })),
-        fundingAssets: fundingAssets.map((funding) => ({
-            asset: AssetSchema.parse(funding.asset),
-            amountPerPacket: funding.amountPerPacket.toString(),
+        fundingAssets: fundingAssets.map((x) => ({
+            asset: AssetSchema.parse(x.asset),
+            amountPerPacket: toInt256Json(x.amountPerPacket),
         })),
-        fractions,
-        capitalization,
-        timeline,
-        vesting,
+        fractions: fractions,
+        capitalization: capitalization,
+        timeline: timeline,
+        vesting: vesting,
         transactionHash: raw.transactionHash,
-        createdAt: raw.createdAt.toISOString(),
-        updatedAt: raw.updatedAt.toISOString(),
+        createdAt: toISOJson(raw.createdAt),
+        updatedAt: toISOJson(raw.updatedAt),
     };
 }
 function toSaleFractions(raw, fractionsAsset) {
-    //TODO:
     return {
         asset: AssetSchema.parse(fractionsAsset),
-        totalFractions: raw.fractionsCreated.toString(),
-        price: raw.fractionPrice.toString(),
+        totalFractions: toInt256Json(raw.fractionsCreated),
+        price: toInt256Json(raw.fractionPrice),
     };
 }
 function toSaleCapitalization(raw) {
-    //TODO:
     return {
-        softCap: raw.softCap.toString(),
-        hardCap: raw.hardCap.toString(),
-        softCapPerAccount: raw.softCapPerAccount.toString(),
-        hardCapPerAccount: raw.hardCapPerAccount.toString(),
+        softCap: raw.softCap ? toInt256Json(raw.softCap) : null,
+        hardCap: raw.hardCap ? toInt256Json(raw.hardCap) : null,
+        softCapPerAccount: raw.softCapPerAccount ? toInt256Json(raw.softCapPerAccount) : null,
+        hardCapPerAccount: raw.hardCapPerAccount ? toInt256Json(raw.hardCapPerAccount) : null,
     };
 }
 function toSaleTimeline(raw) {
-    //TODO:
     return {
-        startDate: raw.startDate.toISOString(),
-        endDate: raw.endDate.toISOString(),
+        startDate: toISOJson(raw.startDate),
+        endDate: raw.endDate ? toISOJson(raw.endDate) : null,
     };
 }
 function toSaleVesting(raw) {
-    //TODO:
     return raw.cliffDate
         ? {
-            cliffDate: raw.cliffDate.toISOString(),
-            totalVestingPeriod: Number(raw.totalVestingPeriod),
-            portionPeriod: Number(raw.portionPeriod),
+            cliffDate: toISOJson(raw.cliffDate),
+            totalVestingPeriod: raw.totalVestingPeriod ? Number(raw.totalVestingPeriod) : 0,
+            portionPeriod: raw.portionPeriod ? Number(raw.portionPeriod) : 0,
         }
         : null;
 }

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

@@ -0,0 +1,30 @@
+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;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=completeSale.route.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;QAgBzB,CAAC"}