@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

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

@@ -1,75 +1,32 @@
-import { Factory } from "hono/factory";
-import { Env } from "hono";
 import { z } from "zod";
 export declare const SetFeeCapLimitRequestSchema: z.ZodObject<{
-    marketAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    campaignId: z.ZodBigInt;
-    packetsLimit: z.ZodBigInt;
-}, "strip", z.ZodTypeAny, {
-    campaignId: bigint;
-    marketAddress: `0x${string}`;
-    packetsLimit: bigint;
-}, {
-    campaignId: bigint;
-    marketAddress: `0x${string}`;
-    packetsLimit: bigint;
-}>;
-export declare function createSetFeeCapLimitTransactionV0<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            campaignId: bigint;
-            marketAddress: `0x${string}`;
-            packetsLimit: bigint;
-        };
-    };
-    out: {
-        json: {
-            campaignId: bigint;
-            marketAddress: `0x${string}`;
-            packetsLimit: bigint;
+    marketAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    campaignId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    packetsLimit: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const SetFeeCapLimitV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    marketAddress: string;
+                    campaignId: string;
+                    packetsLimit: 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;
         };
     };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        json: {
-            campaignId: bigint;
-            marketAddress: `0x${string}`;
-            packetsLimit: bigint;
-        };
-    };
-    out: {
-        json: {
-            campaignId: bigint;
-            marketAddress: `0x${string}`;
-            packetsLimit: bigint;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+}, "/">>;
 //# sourceMappingURL=setFeeCapLimit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"setFeeCapLimit.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/setFeeCapLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAE3B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EAItC,CAAC;AAkBH,wBAAgB,iCAAiC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAUnF"}
+{"version":3,"file":"setFeeCapLimit.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/setFeeCapLimit.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,2BAA2B;;;;iBAItC,CAAC;AAkBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;QAc3B,CAAC"}

package/dist/fractions/sales/setFeeCapLimit.js

@@ -1,12 +1,14 @@
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { resolver, validator } from "hono-openapi";
 import { z } from "zod";
 import { setFeeCapLimit } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
 export const SetFeeCapLimitRequestSchema = z.object({
     marketAddress: AddressSchema,
-    campaignId: z.coerce.bigint().nonnegative(),
-    packetsLimit: z.coerce.bigint().nonnegative(),
+    campaignId: Int256BigInt(z.bigint().nonnegative()),
+    packetsLimit: Int256BigInt(z.bigint().nonnegative()),
 });
 const route = describeRoute({
     summary: "Set fee cap limit",
@@ -23,10 +25,12 @@ const route = describeRoute({
         },
     },
 });
-export function createSetFeeCapLimitTransactionV0(factory) {
-    return factory.createHandlers(route, validator("json", SetFeeCapLimitRequestSchema.openapi({ ref: "SetFeeCapLimitRequestSchema" })), async (c) => {
+export const SetFeeCapLimitV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", SetFeeCapLimitRequestSchema.openapi("SetFeeCapLimitRequestSchema")), async (c) => {
         const { marketAddress, campaignId, packetsLimit } = c.req.valid("json");
         const tx = setFeeCapLimit(marketAddress, campaignId, packetsLimit);
         return c.json(toTransaction(tx));
-    });
-}
+    }),
+});

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

@@ -1,68 +1,29 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { z } from "zod";
-export declare const UnlockWrappedAssetsRequestSchema: z.ZodObject<{
-    market: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    campaignId: z.ZodBigInt;
-}, "strip", z.ZodTypeAny, {
-    campaignId: bigint;
-    market: `0x${string}`;
-}, {
-    campaignId: bigint;
-    market: `0x${string}`;
-}>;
-export declare function createUnlockWrappedAssetsTransactionV0<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            campaignId: bigint;
-            market: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            campaignId: bigint;
-            market: `0x${string}`;
+export declare const UnlockWrappedAssetsRequestSchema: import("zod").ZodObject<{
+    market: import("zod").ZodPipe<import("zod").ZodString & import("zod").ZodType<`0x${string}`, string, import("zod/v4/core").$ZodTypeInternals<`0x${string}`, string>>, import("zod").ZodTransform<`0x${string}`, `0x${string}`>>;
+    campaignId: import("zod").ZodPipe<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "Int256", "out">, import("zod").ZodTransform<bigint, string & import("zod").$brand<"Int256">>>;
+}, import("zod/v4/core").$strip>;
+export declare const UnlockWrappedAssetsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    market: string;
+                    campaignId: string;
+                };
+            };
+            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;
         };
     };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        json: {
-            campaignId: bigint;
-            market: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            campaignId: bigint;
-            market: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    data: `0x${string}`;
-    to: `0x${string}`;
-    details: {
-        address: `0x${string}`;
-        functionName: string;
-        abi: any[];
-        args: any[];
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+}, "/">>;
 //# sourceMappingURL=unlockWrappedAssets.route.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"unlockWrappedAssets.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/unlockWrappedAssets.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gCAAgC;;;;;;;;;EAG3C,CAAC;AAkBH,wBAAgB,sCAAsC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAUxF"}
+{"version":3,"file":"unlockWrappedAssets.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/unlockWrappedAssets.route.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gCAAgC;;;gCAAe,CAAC;AAkB7D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;QAchC,CAAC"}

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

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

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const ClaimStatisticsRequestSchema: 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>[]]>>;
+    platform: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    campaignId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    walletAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
+export declare const ClaimStatisticsResponseSchema: z.ZodObject<{
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 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>;
+    totalClaims: z.ZodNumber;
+    lastClaimId: z.ZodNullable<z.ZodCoercedString<unknown>>;
+    totalClaimed: z.ZodArray<z.ZodObject<{
+        tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        amount: z.ZodCoercedString<unknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ClaimStatisticsV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    platform: string;
+                    campaignId: string;
+                    walletAddress: string;
+                };
+            };
+            output: never;
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=claimStatistics.route.d.ts.map

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

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

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

@@ -0,0 +1,87 @@
+import { and, count, eq, max, sql } from "@ponder/client";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { toHex } from "viem";
+import { z } from "zod";
+import { createController } from "../../../common/controller.js";
+import { indexerSchemas } from "../../../common/indexer/schemas.js";
+import { FractionsChainId } from "../../../common/models/chainId.js";
+import { CampaignIdSchema, PlatformContractAddress } from "../../../common/models/platform.js";
+import { AddressSchema } from "../../../common/models/viem.js";
+export const ClaimStatisticsRequestSchema = z
+    .object({
+    chainId: FractionsChainId,
+    platform: PlatformContractAddress,
+    campaignId: CampaignIdSchema,
+    walletAddress: AddressSchema,
+})
+    .openapi("ClaimStatisticsRequest");
+export const ClaimStatisticsResponseSchema = z
+    .object({
+    chainId: FractionsChainId,
+    platform: PlatformContractAddress,
+    campaignId: z.coerce.string(),
+    totalClaims: z.number(),
+    lastClaimId: z.coerce.string().nullable(),
+    totalClaimed: z.array(z.object({
+        tokenAddress: AddressSchema,
+        amount: z.coerce.string(),
+    })),
+})
+    .openapi("ClaimStatisticsResponse");
+export const ClaimStatisticsV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Get claim statistics for a vesting campaign",
+        description: "Retrieves the total number of claims made and the last claim ID for a specific vesting campaign and wallet address",
+        tags: ["Fractions Vesting"],
+        responses: {
+            200: {
+                description: "Returns claim statistics for the specified campaign and wallet address",
+                content: {
+                    "application/json": {
+                        schema: resolver(ClaimStatisticsResponseSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", ClaimStatisticsRequestSchema), async (c) => {
+        const { chainId, platform, campaignId, walletAddress } = c.req.valid("json");
+        const { fractions: { fractionsClaims }, } = indexerSchemas;
+        const [claimStats] = await c
+            .get("indexerClient")
+            .db.select({
+            claims: count(fractionsClaims.transactionHash),
+            lastClaimId: max(fractionsClaims.semiFungibleBurntId),
+        })
+            .from(fractionsClaims)
+            .where(and(eq(fractionsClaims.chainId, Number(chainId)), eq(fractionsClaims.diamondAddress, platform), eq(fractionsClaims.saleId, BigInt(campaignId)), eq(fractionsClaims.receiver, walletAddress)));
+        const tokenAmounts = await c
+            .get("indexerClient")
+            .db.select({
+            tokenAddress: sql `jsonb_array_elements(${fractionsClaims.received})->>'tokenAddress'`,
+            amount: sql `sum((jsonb_array_elements(${fractionsClaims.received})->>'amount')::bigint)`,
+        })
+            .from(fractionsClaims)
+            .where(and(eq(fractionsClaims.chainId, Number(chainId)), eq(fractionsClaims.diamondAddress, platform), eq(fractionsClaims.saleId, BigInt(campaignId)), eq(fractionsClaims.receiver, walletAddress)))
+            .groupBy(sql `jsonb_array_elements(${fractionsClaims.received})->>'tokenAddress'`);
+        const totalClaimed = tokenAmounts.map((t) => ({ ...t, amount: toHex(t.amount) }));
+        if (!claimStats) {
+            return c.json({
+                chainId: chainId,
+                platform: platform,
+                campaignId: campaignId,
+                totalClaims: 0,
+                lastClaimId: null,
+                totalClaimed,
+            }, 200);
+        }
+        return c.json({
+            chainId: chainId,
+            platform: platform,
+            campaignId: campaignId,
+            totalClaims: claimStats.claims,
+            lastClaimId: claimStats.lastClaimId,
+            totalClaimed,
+        }, 200);
+    }),
+});

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

@@ -0,0 +1,62 @@
+import { z } from "zod";
+export declare const ClaimVestedTokensRequestSchema: z.ZodObject<{
+    address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    campaignId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    amountOfFractions: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    itToBurn: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const ClaimVestedTokensV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    address: string;
+                    campaignId: string;
+                    amountOfFractions: string;
+                    itToBurn: 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;
+        } | {
+            input: {
+                json: {
+                    address: string;
+                    campaignId: string;
+                    amountOfFractions: string;
+                    itToBurn: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                json: {
+                    address: string;
+                    campaignId: string;
+                    amountOfFractions: string;
+                    itToBurn: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=claimVestedTokens.route.d.ts.map

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

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

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

@@ -0,0 +1,45 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { claimVestedTokens } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+export const ClaimVestedTokensRequestSchema = z.object({
+    address: AddressSchema,
+    campaignId: Int256BigInt(z.bigint().positive()),
+    amountOfFractions: Int256BigInt(z.bigint().positive()),
+    itToBurn: Int256BigInt(z.bigint().nonnegative()),
+});
+const route = describeRoute({
+    summary: "Claim vested tokens",
+    description: "Returns transaction data for claiming vested tokens from a campaign",
+    tags: ["Fractions Vesting"],
+    responses: {
+        200: {
+            description: "Returns transaction data for claiming vested tokens",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const ClaimVestedTokensV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", ClaimVestedTokensRequestSchema.openapi("ClaimVestedTokensRequestSchema")), async (c) => {
+        const request = c.req.valid("json");
+        try {
+            const tx = claimVestedTokens(request);
+            return c.json(toTransaction(tx));
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return c.json({ error: error.message }, 400);
+            }
+            return c.json({ error: "An unknown error occurred" }, 500);
+        }
+    }),
+});

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

@@ -0,0 +1,58 @@
+import { z } from "zod";
+export declare const EditCliffRequestSchema: z.ZodObject<{
+    marketAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    saleId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    newCliffDate: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "ISO", "out">, z.ZodTransform<Date, string & z.core.$brand<"ISO">>>;
+}, z.core.$strip>;
+export declare const EditCliffV0: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    marketAddress: string;
+                    saleId: string;
+                    newCliffDate: 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;
+        } | {
+            input: {
+                json: {
+                    marketAddress: string;
+                    saleId: string;
+                    newCliffDate: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                json: {
+                    marketAddress: string;
+                    saleId: string;
+                    newCliffDate: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=editCliff.route.d.ts.map

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

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

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

@@ -0,0 +1,45 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { buildEditCliffTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { createController } from "../../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+import { ISODate } from "../../../common/models/date.js";
+export const EditCliffRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    saleId: Int256BigInt(z.bigint().positive()),
+    newCliffDate: ISODate(),
+});
+const route = describeRoute({
+    summary: "Edit the cliff of a vesting schedule",
+    description: "Returns transaction data for updating the cliff date in a vesting schedule",
+    tags: ["Fractions Vesting"],
+    responses: {
+        200: {
+            description: "Returns transaction data for editing the cliff date",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const EditCliffV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", EditCliffRequestSchema.openapi("EditCliffRequestSchema")), async (c) => {
+        const { marketAddress, saleId, newCliffDate } = c.req.valid("json");
+        try {
+            const tx = buildEditCliffTx(marketAddress, saleId, newCliffDate);
+            return c.json(toTransaction(tx));
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return c.json({ error: error.message }, 400);
+            }
+            return c.json({ error: "An unknown error occurred" }, 500);
+        }
+    }),
+});

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

@@ -0,0 +1,22 @@
+export declare const ParseClaimVestedTokensEventV0: 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}`;
+                burnId: string;
+                nextBurnId: string | null;
+                amountOfFractionsBurnt: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=parseClaimVestedTokensEvent.d.ts.map