@evergonlabs/tmi-protocol-api 0.11.0-rc.3 → 0.11.0

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

@@ -1,16 +1,47 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const SearchMarketsResponse: z.ZodArray<z.ZodObject<{
+    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";
+        default: "default";
+        compilot: "compilot";
+        "continuous-withdrawal": "continuous-withdrawal";
+        "continuous-withdrawal-nid": "continuous-withdrawal-nid";
+        lending: "lending";
+    }>;
+    contractAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    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.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;
+        name: z.ZodString;
+        tokenId: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+        decimals: z.ZodDefault<z.ZodNumber>;
+        burnable: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    feesBps: z.ZodNullable<z.ZodNumber>;
+    createdAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+    updatedAt: z.core.$ZodBranded<z.ZodString, "IsoDateString", "out">;
+}, z.core.$strip>>;
+export declare const SearchMarketsQuery: z.ZodObject<{
+    skip: z.ZodNumber;
+    limit: z.ZodNumber;
+    chainId: z.ZodOptional<z.ZodUnion<z.ZodLiteral<"1" | "31337" | "11155111" | "84532" | "72080">[]>>;
+    owner: z.ZodOptional<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 SearchMarketsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
-                    page: {
-                        skip: number;
-                        limit: number;
-                    };
-                    filter: {
-                        chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
-                        owner?: string | undefined;
-                    };
+                query: {
+                    skip: string | string[];
+                    limit: string | string[];
+                    chainId?: string | string[] | undefined;
+                    owner?: string | string[] | undefined;
                 };
             };
             output: {
@@ -35,7 +66,7 @@ export declare const SearchMarketsV0: import("../../common/controller.js").ICont
                 updatedAt: string;
             }[];
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/", "/">>;

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

@@ -1 +1 @@
-{"version":3,"file":"searchMarkets.d.ts","sourceRoot":"","sources":["../../../src/fractions/markets/searchMarkets.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAqD1B,CAAC"}
+{"version":3,"file":"searchMarkets.d.ts","sourceRoot":"","sources":["../../../src/fractions/markets/searchMarkets.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAkE,CAAC;AAErG,eAAO,MAAM,kBAAkB;;;;;iBAOC,CAAC;AAEjC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA2C1B,CAAC"}

package/dist/fractions/markets/searchMarkets.js

@@ -7,8 +7,17 @@ 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 SearchMarketsResponse = z.array(FractionsMarketSchema).openapi("SearchMarketsResponse");
+export const SearchMarketsQuery = z
+    .object({
+    skip: PageSchema.shape.skip.openapi({ param: { name: "skip", in: "query" } }),
+    limit: PageSchema.shape.limit.openapi({ param: { name: "limit", in: "query" } }),
+    chainId: FractionsChainId.optional().openapi({ param: { name: "chainId", in: "query" } }),
+    owner: AddressSchema.optional().openapi({ param: { name: "owner", in: "query" } }),
+})
+    .openapi("SearchMarketsQuery");
 export const SearchMarketsV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Search markets",
         description: "Retrieve a list of markets with filtering and sorting",
         tags: [marketsTag.tag],
@@ -17,19 +26,15 @@ export const SearchMarketsV0 = createController({
                 description: "Returns list of platforms by specified filter",
                 content: {
                     "application/json": {
-                        schema: resolver(z.array(FractionsMarketSchema)),
+                        schema: resolver(SearchMarketsResponse),
                     },
                 },
             },
         },
-    }), validator("json", z.object({
-        page: PageSchema,
-        filter: z.object({
-            chainId: FractionsChainId.optional(),
-            owner: AddressSchema.optional(),
-        }),
-    })), async (c) => {
-        const { page, filter } = c.req.valid("json");
+    }), validator("query", SearchMarketsQuery), async (c) => {
+        const { skip, limit, chainId, owner } = c.req.valid("query");
+        const page = { skip, limit };
+        const filter = { chainId, owner };
         const { fractions: { fractionsMarkets }, } = indexerSchemas;
         const result = await c.get("indexerClient").db.query.fractionsMarkets.findMany({
             with: { burnAsset: true },
@@ -38,6 +43,6 @@ export const SearchMarketsV0 = createController({
             offset: page.skip,
             orderBy: fractionsMarkets.createdAt,
         });
-        return c.json(result.map((x) => mapToFractionsMarket(x, x.burnAsset)), 200);
+        return c.json(result.map((x) => mapToFractionsMarket(x, x.burnAsset)));
     }),
 });

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

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

package/dist/fractions/roles/grantRole.js

@@ -1,7 +1,7 @@
 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 { GrantMarketRoleRequestSchema } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({

package/dist/fractions/sales/{approveSale.route.d.ts → approveSale.d.ts}

@@ -1,4 +1,4 @@
-export declare const ApproveSaleV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+export declare const ApproveSaleV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
     "/": {
         $post: {
             input: {
@@ -24,4 +24,4 @@ export declare const ApproveSaleV0: import("../../common/controller.js").IContro
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=approveSale.route.d.ts.map
+//# sourceMappingURL=approveSale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"approveSale.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/approveSale.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;aASxB,CAAC"}

package/dist/fractions/sales/{approveSale.route.js → approveSale.js}

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { buildApproveSaleTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
-import { ApproveSaleRequestSchema } from "../schemas.js";
+import { ApproveSaleRequestSchema } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({

package/dist/fractions/sales/{approveWrapper.route.d.ts → approveWrapper.d.ts}

@@ -1,4 +1,4 @@
-export declare const ApproveWrapperV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+export declare const ApproveWrapperV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
     "/": {
         $post: {
             input: {
@@ -22,4 +22,4 @@ export declare const ApproveWrapperV0: import("../../common/controller.js").ICon
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=approveWrapper.route.d.ts.map
+//# sourceMappingURL=approveWrapper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"approveWrapper.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/approveWrapper.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}

package/dist/fractions/sales/{approveWrapper.route.js → approveWrapper.js}

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { buildApproveWrapperTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
-import { ApproveWrapperConfigSchema } from "../schemas.js";
+import { ApproveWrapperConfigSchema } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({

package/dist/fractions/sales/{completeSale.route.d.ts → completeSale.d.ts}

@@ -1,4 +1,4 @@
-export declare const CompleteSaleV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+export declare const CompleteSaleV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
     "/": {
         $post: {
             input: {
@@ -24,4 +24,4 @@ export declare const CompleteSaleV0: import("../../common/controller.js").IContr
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=completeSale.route.d.ts.map
+//# sourceMappingURL=completeSale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"completeSale.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/completeSale.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;aAUzB,CAAC"}

package/dist/fractions/sales/{completeSale.route.js → completeSale.js}

@@ -1,7 +1,7 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { buildFinishSaleTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
-import { FinishSaleRequestSchema } from "../schemas.js";
+import { FinishSaleRequestSchema } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({

package/dist/fractions/sales/{createFractions.route.d.ts → createFractions.d.ts}

@@ -1,4 +1,4 @@
-export declare const CreateFractionsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+export declare const CreateFractionsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
     "/": {
         $post: {
             input: {
@@ -67,4 +67,4 @@ export declare const CreateFractionsV0: import("../../common/controller.js").ICo
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=createFractions.route.d.ts.map
+//# sourceMappingURL=createFractions.d.ts.map

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

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

package/dist/fractions/sales/{createFractions.route.js → createFractions.js}

@@ -1,7 +1,7 @@
 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 { CreateFractionsRequestSchema } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { createController } from "../../common/controller.js";
 import { toTransaction, TransactionSchema } from "../../common/index.js";
 const route = describeRoute({

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

@@ -0,0 +1,47 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const FractionsSaleStatisticsEntry: z.ZodObject<{
+    priceId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    fractionsSold: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    purchases: z.ZodNumber;
+}, z.core.$strip>;
+export declare const FractionsSaleStatisticResponse: z.ZodObject<{
+    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">;
+    statistics: z.ZodArray<z.ZodObject<{
+        priceId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        fractionsSold: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        purchases: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const FractionsSaleStatisticsQuery: z.ZodObject<{
+    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">;
+}, z.core.$strip>;
+export declare const GetFractionSaleStatisticsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                    platform: string;
+                    campaignId: string;
+                };
+            };
+            output: {
+                chainId: "1" | "31337" | "11155111" | "84532" | "72080";
+                platform: `0x${string}`;
+                campaignId: string & z.core.$brand<"Int256">;
+                statistics: {
+                    priceId: string & z.core.$brand<"Int256">;
+                    fractionsSold: string & z.core.$brand<"Int256">;
+                    purchases: number;
+                }[];
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=getFractionSaleStatistics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getFractionSaleStatistics.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getFractionSaleStatistics.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,4BAA4B;;;;iBAMC,CAAC;AAE3C,eAAO,MAAM,8BAA8B;;;;;;;;;iBAON,CAAC;AAEtC,eAAO,MAAM,4BAA4B;;;;iBAYC,CAAC;AAE3C,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;aAyDtC,CAAC"}

package/dist/fractions/sales/{getFractionSaleStatistics.route.js → getFractionSaleStatistics.js}

@@ -2,23 +2,40 @@ import { and, count, eq, sum } from "@ponder/client";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { createController } from "../../common/controller.js";
 import { CampaignIdSchema, FractionsChainId, PlatformContractAddress } from "../../common/index.js";
 import { indexerSchemas } from "../../common/indexer/schemas.js";
-export const FractionsSaleStatisticSchema = z
+export const FractionsSaleStatisticsEntry = z
+    .object({
+    priceId: Int256Json,
+    fractionsSold: Int256Json,
+    purchases: z.number(),
+})
+    .openapi("FractionsSaleStatisticsEntry");
+export const FractionsSaleStatisticResponse = z
     .object({
     chainId: FractionsChainId,
     platform: PlatformContractAddress,
-    campaignId: z.coerce.string(),
-    statistics: z.array(z.object({
-        priceId: z.coerce.string(),
-        fractionsSold: z.coerce.string(),
-        purchases: z.number(),
-    })),
+    campaignId: Int256Json,
+    statistics: z.array(FractionsSaleStatisticsEntry),
 })
     .openapi("FractionsSaleStatistics");
+export const FractionsSaleStatisticsQuery = z
+    .object({
+    chainId: FractionsChainId.openapi({
+        param: { name: "chainId", in: "query" },
+    }),
+    platform: PlatformContractAddress.openapi({
+        param: { name: "platform", in: "query" },
+    }),
+    campaignId: CampaignIdSchema.openapi({
+        param: { name: "campaignId", in: "query" },
+    }),
+})
+    .openapi("FractionsSaleStatisticsQuery");
 export const GetFractionSaleStatisticsV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+    build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Aggregate sale statistics",
         description: "",
         tags: ["Statistics"],
@@ -27,17 +44,13 @@ export const GetFractionSaleStatisticsV0 = createController({
                 description: "",
                 content: {
                     "application/json": {
-                        schema: resolver(FractionsSaleStatisticSchema),
+                        schema: resolver(FractionsSaleStatisticResponse),
                     },
                 },
             },
         },
-    }), validator("json", z.object({
-        chainId: FractionsChainId,
-        platform: PlatformContractAddress,
-        campaignId: CampaignIdSchema,
-    })), async (c) => {
-        const { chainId, platform, campaignId } = c.req.valid("json");
+    }), validator("query", FractionsSaleStatisticsQuery), async (c) => {
+        const { chainId, platform, campaignId } = c.req.valid("query");
         const { fractions: { fractionsPurchases }, } = indexerSchemas;
         const rows = await c
             .get("indexerClient")
@@ -51,13 +64,14 @@ export const GetFractionSaleStatisticsV0 = createController({
             .groupBy(fractionsPurchases.priceId);
         const statistics = rows.map((r) => ({
             ...r,
-            fractionsSold: r.fractionsSold || "0",
+            priceId: toInt256Json(r.priceId),
+            fractionsSold: toInt256Json(r.fractionsSold || "0"),
         }));
-        return c.json(FractionsSaleStatisticSchema.parse({
+        return c.json({
             chainId: chainId,
             platform: platform,
             campaignId: campaignId,
             statistics,
-        }), 200);
+        });
     }),
 });

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

@@ -1,3 +1,12 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetVaultAddressResponse: z.ZodObject<{
+    vaultAddress: 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 GetVaultAddressQuery: z.ZodObject<{
+    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}`>>;
+    campaign: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
 export declare const GetVaultAddressV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
     "/": {
         $get: {
@@ -27,7 +36,7 @@ export declare const GetVaultAddressV0: import("../../common/controller.js").ICo
                 vaultAddress: `0x${string}`;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/", "/">>;

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":"AAYA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAyE5B,CAAC"}
+{"version":3,"file":"getVaultAddress.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getVaultAddress.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,uBAAuB;;iBAA+E,CAAC;AAEpH,eAAO,MAAM,oBAAoB;;;;iBAMC,CAAC;AAEnC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkE5B,CAAC"}

package/dist/fractions/sales/getVaultAddress.js

@@ -8,6 +8,14 @@ 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";
+export const GetVaultAddressResponse = z.object({ vaultAddress: AddressSchema }).openapi("GetVaultAddressResponse");
+export const GetVaultAddressQuery = z
+    .object({
+    chainId: FractionsChainId.openapi({ param: { name: "chainId", in: "query" } }),
+    platform: PlatformContractAddress.openapi({ param: { name: "platform", in: "query" } }),
+    campaign: CampaignIdSchema.openapi({ param: { name: "campaign", in: "query" } }),
+})
+    .openapi("GetVaultAddressQuery");
 export const GetVaultAddressV0 = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get vault address",
@@ -18,16 +26,12 @@ export const GetVaultAddressV0 = createController({
                 description: "Returns address of vault",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({ vault: AddressSchema })),
+                        schema: resolver(GetVaultAddressResponse),
                     },
                 },
             },
         },
-    }), validator("query", z.object({
-        chainId: FractionsChainId,
-        platform: PlatformContractAddress,
-        campaign: CampaignIdSchema,
-    })), async (c) => {
+    }), validator("query", GetVaultAddressQuery), async (c) => {
         const params = c.req.valid("query");
         const publicClient = getPublicClient(params.chainId, c.env.config);
         const [platform] = await c
@@ -56,6 +60,6 @@ export const GetVaultAddressV0 = createController({
             args: [BigInt(params.campaign)],
             address: platform.wrapperAddress,
         });
-        return c.json({ vaultAddress: address }, 200);
+        return c.json({ vaultAddress: address });
     }),
 });

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

@@ -1,3 +1,4 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const GetWithdrawEventV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context").AppContext, {
     "/": {
         $get: {
@@ -8,12 +9,12 @@ export declare const GetWithdrawEventV0: import("../../common/controller.js").IC
                 };
             };
             output: {
-                campaignId: string;
+                campaignId: string & z.core.$brand<"Int256">;
                 receiver: `0x${string}`;
-                packetsReceived: string;
+                packetsReceived: string & z.core.$brand<"Int256">;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/", "/">>;

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":"AAYA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;aA8C7B,CAAC"}
+{"version":3,"file":"getWithdrawEvent.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getWithdrawEvent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;aA8C7B,CAAC"}

package/dist/fractions/sales/getWithdrawEvent.js

@@ -3,7 +3,7 @@ import { resolver, validator } from "hono-openapi";
 import { waitForTransactionReceipt } from "viem/actions";
 import { parseWithdrawEvent } from "@evergonlabs/tmi-protocol-fractions-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { getPublicClient } from "../../common/blockchain.js";
 import { createController } from "../../common/controller.js";
 import { HttpError } from "../../common/http-error.js";
@@ -34,20 +34,15 @@ export const GetWithdrawEventV0 = createController({
         });
         const result = parseWithdrawEvent(receipt.logs);
         if (!result) {
-            throw new UnableParseWithdrawEvent();
+            throw new HttpError(500, {
+                message: `Can't parse withdraw transaction.`,
+                name: "UnableParseWithdrawEvent",
+            });
         }
         return c.json({
-            campaignId: result.campaignId.toString(),
+            campaignId: toInt256Json(result.campaignId),
             receiver: result.receiver,
-            packetsReceived: result.packetsReceived.toString(),
-        }, 200);
+            packetsReceived: toInt256Json(result.packetsReceived),
+        });
     }),
 });
-class UnableParseWithdrawEvent extends HttpError {
-    constructor() {
-        super(500, {
-            message: `Can't parse withdraw transaction.`,
-            name: "UnableParseWithdrawEvent",
-        });
-    }
-}