@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/fractions/sales/createNftFractions.schema.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+/**
+ * Time boundary schema for sale period
+ */
+export declare const TimeBoundarySchema: z.ZodObject<{
+    start: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+    end: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+}, z.core.$strip>;
+/**
+ * Capitalization schema for sale limits
+ */
+export declare const CapitalizationSchema: z.ZodObject<{
+    soft: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    hard: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    softPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    hardPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+}, z.core.$strip>;
+/**
+ * NFT details schema for ERC-721 tokens to be wrapped
+ */
+export declare const NftDetailsSchema: z.ZodObject<{
+    contractAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    tokenIds: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+}, z.core.$strip>;
+/**
+ * Fraction configuration schema
+ */
+export declare const FractionSchema: z.ZodObject<{
+    name: z.ZodString;
+    symbol: z.ZodString;
+    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+/**
+ * Funding configuration schema for payment tokens
+ */
+export declare const FundingSchema: z.ZodObject<{
+    token: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    amountPerPacket: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+/**
+ * Vesting configuration schema
+ */
+export declare const VestingSchema: z.ZodObject<{
+    cliff: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+    totalVestingPeriod: z.ZodNumber;
+    portionPeriod: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Request schema for creating NFT fractions
+ */
+export declare const CreateNftFractionsRequestSchema: z.ZodObject<{
+    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>[]]>>;
+    market: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    nft: z.ZodObject<{
+        contractAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        tokenIds: z.ZodArray<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    }, z.core.$strip>;
+    fractions: z.ZodObject<{
+        name: z.ZodString;
+        symbol: z.ZodString;
+        amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    }, z.core.$strip>;
+    timeBoundary: z.ZodObject<{
+        start: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+        end: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+    }, z.core.$strip>;
+    cap: z.ZodObject<{
+        soft: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+        hard: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+        softPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+        hardPerAccount: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>>;
+    }, z.core.$strip>;
+    funding: z.ZodArray<z.ZodObject<{
+        token: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        amountPerPacket: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    }, z.core.$strip>>;
+    amountOfPacketsPerFraction: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    vesting: z.ZodOptional<z.ZodObject<{
+        cliff: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+        totalVestingPeriod: z.ZodNumber;
+        portionPeriod: z.ZodNumber;
+    }, z.core.$strip>>;
+    refundAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
+//# sourceMappingURL=createNftFractions.schema.d.ts.map

package/dist/fractions/sales/createNftFractions.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNftFractions.schema.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/createNftFractions.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;iBAK/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;iBAIzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;iBAGxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;iBAIxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAaC,CAAC"}

package/dist/fractions/sales/createNftFractions.schema.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { AddressSchema, FractionsChainId } from "../../common/index.js";
+import { ISODate } from "../../common/models/date.js";
+import { Int256BigInt } from "../../common/int256.js";
+/**
+ * Time boundary schema for sale period
+ */
+export const TimeBoundarySchema = z.object({
+    start: ISODate().describe("Sale start date"),
+    end: ISODate().describe("Sale end date"),
+});
+/**
+ * Capitalization schema for sale limits
+ */
+export const CapitalizationSchema = z.object({
+    soft: Int256BigInt(z.bigint().positive()).describe("Soft cap - minimum funding target"),
+    hard: Int256BigInt(z.bigint().positive()).describe("Hard cap - maximum funding limit"),
+    softPerAccount: Int256BigInt(z.bigint().positive()).optional().describe("Optional soft cap per account"),
+    hardPerAccount: Int256BigInt(z.bigint().positive()).optional().describe("Optional hard cap per account"),
+});
+/**
+ * NFT details schema for ERC-721 tokens to be wrapped
+ */
+export const NftDetailsSchema = z.object({
+    contractAddress: AddressSchema.describe("ERC-721 contract address"),
+    tokenIds: z.array(Int256BigInt(z.bigint().nonnegative())).nonempty().describe("Token IDs to wrap"),
+});
+/**
+ * Fraction configuration schema
+ */
+export const FractionSchema = z.object({
+    name: z.string().min(1).describe("Fraction token name"),
+    symbol: z.string().min(1).max(11).describe("Fraction token symbol"),
+    amount: Int256BigInt(z.bigint().positive()).describe("Total supply of fractions to mint"),
+});
+/**
+ * Funding configuration schema for payment tokens
+ */
+export const FundingSchema = z.object({
+    token: AddressSchema.describe("Payment token address (e.g., USDC)"),
+    amountPerPacket: Int256BigInt(z.bigint().positive()).describe("Amount of payment token per packet"),
+});
+/**
+ * Vesting configuration schema
+ */
+export const VestingSchema = z.object({
+    cliff: ISODate().describe("Cliff date after which vesting begins"),
+    totalVestingPeriod: z.number().positive().describe("Total vesting period in seconds"),
+    portionPeriod: z.number().positive().describe("Period between vesting portions in seconds"),
+});
+/**
+ * Request schema for creating NFT fractions
+ */
+export const CreateNftFractionsRequestSchema = z
+    .object({
+    chainId: FractionsChainId.describe("Chain ID where the market is deployed"),
+    market: AddressSchema.describe("Address of the NFT Fractions market"),
+    nft: NftDetailsSchema.describe("NFT details to wrap"),
+    fractions: FractionSchema.describe("Fraction token configuration"),
+    timeBoundary: TimeBoundarySchema.describe("Purchase time window"),
+    cap: CapitalizationSchema.describe("Capitalization limits"),
+    funding: z.array(FundingSchema).nonempty().describe("Payment token configuration"),
+    amountOfPacketsPerFraction: Int256BigInt(z.bigint().positive()).describe("Number of funding packets per fraction"),
+    vesting: VestingSchema.optional().describe("Optional vesting configuration"),
+    refundAddress: AddressSchema.describe("Address to receive refunds"),
+})
+    .openapi("CreateNftFractionsRequestSchema");

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

@@ -1,98 +1,37 @@
-import { Factory } from "hono/factory";
-import { z } from "../../common/zod.js";
-import { AppContext } from "../../common/context.js";
+import { z } from "zod";
 export declare const FractionsSaleStatisticSchema: 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.ZodString;
+    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.ZodCoercedString<unknown>;
     statistics: z.ZodArray<z.ZodObject<{
-        priceId: z.ZodString;
-        fractionsSold: z.ZodString;
+        priceId: z.ZodCoercedString<unknown>;
+        fractionsSold: z.ZodCoercedString<unknown>;
         purchases: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        priceId: string;
-        purchases: number;
-        fractionsSold: string;
-    }, {
-        priceId: string;
-        purchases: number;
-        fractionsSold: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    campaignId: string;
-    platform: `0x${string}`;
-    statistics: {
-        priceId: string;
-        purchases: number;
-        fractionsSold: string;
-    }[];
-}, {
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    campaignId: string;
-    platform: `0x${string}`;
-    statistics: {
-        priceId: string;
-        purchases: number;
-        fractionsSold: string;
-    }[];
-}>;
-export declare function createSaleStatisticsV0App(factory: Factory<AppContext>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    campaignId: string;
-    platform: `0x${string}`;
-    statistics: {
-        priceId: string;
-        purchases: number;
-        fractionsSold: string;
-    }[];
-}, 200, "json">>>, import("hono/types").H<import("hono").Env, string, {
-    in: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            campaignId: string | number | bigint;
-            platform: `0x${string}`;
+    }, 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, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    platform: string;
+                    campaignId: string;
+                };
+            };
+            output: {
+                chainId: 1 | 11155111 | 31337 | 72080;
+                platform: `0x${string}`;
+                campaignId: string;
+                statistics: {
+                    priceId: string;
+                    fractionsSold: string;
+                    purchases: number;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
         };
     };
-    out: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            campaignId: bigint;
-            platform: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    campaignId: string;
-    platform: `0x${string}`;
-    statistics: {
-        priceId: string;
-        purchases: number;
-        fractionsSold: string;
-    }[];
-}, 200, "json">>>, import("hono/types").H<AppContext, string, {
-    in: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            campaignId: string | number | bigint;
-            platform: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            campaignId: bigint;
-            platform: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    campaignId: string;
-    platform: `0x${string}`;
-    statistics: {
-        priceId: string;
-        purchases: number;
-        fractionsSold: string;
-    }[];
-}, 200, "json">>>];
+}, "/">>;
 //# sourceMappingURL=getFractionSaleStatistics.route.d.ts.map

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":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,EAAE,CAAC,EAAE,MAAM,qBAAqB,CAAC;AAIxC,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAerC,CAAC;AAEL,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgErE"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;QAkEtC,CAAC"}

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

@@ -1,12 +1,13 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
 import { and, count, eq, sum } from "@ponder/client";
-import { z } from "../../common/zod.js";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { createController } from "../../common/controller.js";
+import { CampaignIdSchema, FractionsChainId, PlatformContractAddress } from "../../common/index.js";
 import { indexerSchemas } from "../../common/indexer/schemas.js";
-import { PlatformContractAddress, CampaignIdSchema, TmiChainIdSchema } from "../../common/index.js";
 export const FractionsSaleStatisticSchema = z
     .object({
-    chainId: TmiChainIdSchema,
+    chainId: FractionsChainId,
     platform: PlatformContractAddress,
     campaignId: z.coerce.string(),
     statistics: z.array(z.object({
@@ -15,11 +16,9 @@ export const FractionsSaleStatisticSchema = z
         purchases: z.number(),
     })),
 })
-    .openapi({
-    ref: "FractionsSaleStatistics",
-});
-export function createSaleStatisticsV0App(factory) {
-    return factory.createHandlers(describeRoute({
+    .openapi("FractionsSaleStatistics");
+export const GetFractionSaleStatisticsV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
         summary: "Aggregate sale statistics",
         description: "",
         tags: ["Fractions"],
@@ -34,7 +33,7 @@ export function createSaleStatisticsV0App(factory) {
             },
         },
     }), validator("json", z.object({
-        chainId: TmiChainIdSchema,
+        chainId: FractionsChainId,
         platform: PlatformContractAddress,
         campaignId: CampaignIdSchema,
     })), async (c) => {
@@ -60,5 +59,5 @@ export function createSaleStatisticsV0App(factory) {
             campaignId: campaignId,
             statistics,
         }), 200);
-    });
-}
+    }),
+});

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

@@ -1,52 +1,34 @@
-import { Factory } from "hono/factory";
-import { AppContext } from "../../common/context.js";
-export declare function createGetVaultAddressRoute(factory: Factory<AppContext>): [import("hono/types").H<any, string, {}, Promise<(Response & import("hono").TypedResponse<{
-    error: string;
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    market: `0x${string}`;
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
-    vaultAddress: `0x${string}`;
-}, 200, "json">)>>, import("hono/types").H<import("hono").Env, string, {
-    in: {
-        query: {
-            chainId: string | string[];
-            platform: string | string[];
-            campaign: string | string[];
+export declare const GetVaultAddressV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    platform: string | string[];
+                    campaign: string | string[];
+                };
+            };
+            output: {
+                error: string;
+                chainId: 1 | 11155111 | 31337 | 72080;
+                market: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    platform: string | string[];
+                    campaign: string | string[];
+                };
+            };
+            output: {
+                vaultAddress: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: 200;
         };
     };
-    out: {
-        query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            platform: `0x${string}`;
-            campaign: bigint;
-        };
-    };
-}, Promise<(Response & import("hono").TypedResponse<{
-    error: string;
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    market: `0x${string}`;
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
-    vaultAddress: `0x${string}`;
-}, 200, "json">)>>, import("hono/types").H<AppContext, string, {
-    in: {
-        query: {
-            chainId: string | string[];
-            platform: string | string[];
-            campaign: string | string[];
-        };
-    };
-    out: {
-        query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            platform: `0x${string}`;
-            campaign: bigint;
-        };
-    };
-}, Promise<(Response & import("hono").TypedResponse<{
-    error: string;
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    market: `0x${string}`;
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
-    vaultAddress: `0x${string}`;
-}, 200, "json">)>>];
+}, "/">>;
 //# sourceMappingURL=getVaultAddress.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getVaultAddress.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getVaultAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAWvC,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAuEtE"}
+{"version":3,"file":"getVaultAddress.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getVaultAddress.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAyE5B,CAAC"}

package/dist/fractions/sales/getVaultAddress.js

@@ -1,14 +1,15 @@
 import { and, eq } from "@ponder/client";
-import { ABIS } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
+import { resolver, validator } from "hono-openapi";
 import { readContract } from "viem/actions";
-import { AddressSchema, CampaignIdSchema, PlatformContractAddress, TmiChainIdSchema } from "../../common/index.js";
+import { z } from "zod";
+import { ABIS } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { getPublicClient } from "../../common/blockchain.js";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, CampaignIdSchema, FractionsChainId, PlatformContractAddress } from "../../common/index.js";
 import { indexerSchemas } from "../../common/indexer/schemas.js";
-import { z } from "../../common/zod.js";
-export function createGetVaultAddressRoute(factory) {
-    return factory.createHandlers(describeRoute({
+export const GetVaultAddressV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get Vault address",
         description: "Returns address of sale's vault",
         tags: ["Fractions"],
@@ -23,12 +24,12 @@ export function createGetVaultAddressRoute(factory) {
             },
         },
     }), validator("query", z.object({
-        chainId: TmiChainIdSchema,
+        chainId: FractionsChainId,
         platform: PlatformContractAddress,
         campaign: CampaignIdSchema,
     })), async (c) => {
         const params = c.req.valid("query");
-        const publicClient = getPublicClient(params.chainId);
+        const publicClient = getPublicClient(params.chainId, c.env.config);
         const [platform] = await c
             .get("indexerClient")
             .db.select()
@@ -56,5 +57,5 @@ export function createGetVaultAddressRoute(factory) {
             address: platform.wrapperAddress,
         });
         return c.json({ vaultAddress: address }, 200);
-    });
-}
+    }),
+});

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

@@ -1,42 +1,20 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare function createGetWithdrawEventRoute<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    campaignId: string;
-    receiver: `0x${string}`;
-    packetsReceived: string;
-}, 200, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        query: {
-            chainId: string | string[];
-            hash: string | string[];
+export declare const GetWithdrawEventV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                campaignId: string;
+                receiver: `0x${string}`;
+                packetsReceived: string;
+            };
+            outputFormat: "json";
+            status: 200;
         };
     };
-    out: {
-        query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            hash: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    campaignId: string;
-    receiver: `0x${string}`;
-    packetsReceived: string;
-}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        query: {
-            chainId: string | string[];
-            hash: string | string[];
-        };
-    };
-    out: {
-        query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            hash: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    campaignId: string;
-    receiver: `0x${string}`;
-    packetsReceived: string;
-}, 200, "json">>>];
+}, "/">>;
 //# sourceMappingURL=getWithdrawEvent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getWithdrawEvent.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getWithdrawEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAUvC,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4C7E"}
+{"version":3,"file":"getWithdrawEvent.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getWithdrawEvent.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;QA8C7B,CAAC"}

package/dist/fractions/sales/getWithdrawEvent.js

@@ -1,13 +1,15 @@
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
+import { resolver, validator } from "hono-openapi";
 import { waitForTransactionReceipt } from "viem/actions";
-import { AddressSchema, CampaignIdSchema, SentTransactionParamsSchema } from "../../common/index.js";
+import { z } from "zod";
+import { parseWithdrawEvent } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { getPublicClient } from "../../common/blockchain.js";
+import { createController } from "../../common/controller.js";
 import { HttpError } from "../../common/http-error.js";
-import { z } from "../../common/zod.js";
-import { parseWithdrawEvent } from "@evergonlabs/tmi-protocol-fractions-sdk";
-export function createGetWithdrawEventRoute(factory) {
-    return factory.createHandlers(describeRoute({
+import { AddressSchema, SentTransactionParamsSchema } from "../../common/index.js";
+export const GetWithdrawEventV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get Withdraw Event",
         description: `Gets the transaction by hash and parses emitted logs.`,
         tags: ["Fractions"],
@@ -17,9 +19,9 @@ export function createGetWithdrawEventRoute(factory) {
                 content: {
                     "application/json": {
                         schema: resolver(z.object({
-                            campaignId: CampaignIdSchema,
+                            campaignId: Int256Json.openapi({ description: "Id of a Sale", example: "1" }),
                             receiver: AddressSchema,
-                            packetsReceived: z.coerce.bigint(),
+                            packetsReceived: Int256Json,
                         })),
                     },
                 },
@@ -27,7 +29,7 @@ export function createGetWithdrawEventRoute(factory) {
         },
     }), validator("query", SentTransactionParamsSchema), async (c) => {
         const params = c.req.valid("query");
-        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId), {
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,
         });
         const result = parseWithdrawEvent(receipt.logs);
@@ -39,8 +41,8 @@ export function createGetWithdrawEventRoute(factory) {
             receiver: result.receiver,
             packetsReceived: result.packetsReceived.toString(),
         }, 200);
-    });
-}
+    }),
+});
 class UnableParseWithdrawEvent extends HttpError {
     constructor() {
         super(500, {