@evergonlabs/tmi-protocol-api 0.1.0

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

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

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

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

package/dist/src/fractions/sales/setFeeCapLimit.js

@@ -0,0 +1,32 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { z } from "zod";
+import { setFeeCapLimit } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export const SetFeeCapLimitRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    campaignId: z.coerce.bigint().nonnegative(),
+    packetsLimit: z.coerce.bigint().nonnegative(),
+});
+const route = describeRoute({
+    summary: "Set fee cap limit",
+    description: "Returns transaction data for setting the fee cap limit",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for setting the fee cap limit",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createSetFeeCapLimitTransactionV0(factory) {
+    return factory.createHandlers(route, validator("json", SetFeeCapLimitRequestSchema.openapi({ ref: "SetFeeCapLimitRequestSchema" })), async (c) => {
+        const { marketAddress, campaignId, packetsLimit } = c.req.valid("json");
+        const tx = setFeeCapLimit(marketAddress, campaignId, packetsLimit);
+        return c.json(toTransaction(tx));
+    });
+}

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

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

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

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

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

@@ -0,0 +1,31 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+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(),
+});
+const route = describeRoute({
+    summary: "Unlock wrapped assets from a non-funded sale",
+    description: "Returns transaction to unlock wrapped assets from a non-funded sale",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction to unlock wrapped assets from a non-funded sale",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createUnlockWrappedAssetsTransactionV0(factory) {
+    return factory.createHandlers(route, validator("json", UnlockWrappedAssetsRequestSchema.openapi({ ref: "UnlockWrappedAssetsRequestSchema" })), async (c) => {
+        const { market, campaignId } = c.req.valid("json");
+        const tx = unlockWrappedAssets(market, campaignId);
+        return c.json(toTransaction(tx));
+    });
+}

package/dist/src/fractions/sales/vesting/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/fractions/sales/vesting/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/sales/vesting/index.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+export declare const ClaimVestedTokensRequestSchema: z.ZodObject<{
+    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    campaignId: z.ZodBigInt;
+    amountOfFractions: z.ZodBigInt;
+    itToBurn: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    address: `0x${string}`;
+    campaignId: bigint;
+    amountOfFractions: bigint;
+    itToBurn: bigint;
+}, {
+    address: `0x${string}`;
+    campaignId: bigint;
+    amountOfFractions: bigint;
+    itToBurn: bigint;
+}>;
+export declare function createClaimVestedTokensTransaction<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<(Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            address: `0x${string}`;
+            campaignId: bigint;
+            amountOfFractions: bigint;
+            itToBurn: bigint;
+        };
+    };
+    out: {
+        json: {
+            address: `0x${string}`;
+            campaignId: bigint;
+            amountOfFractions: bigint;
+            itToBurn: bigint;
+        };
+    };
+}, Promise<(Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            address: `0x${string}`;
+            campaignId: bigint;
+            amountOfFractions: bigint;
+            itToBurn: bigint;
+        };
+    };
+    out: {
+        json: {
+            address: `0x${string}`;
+            campaignId: bigint;
+            amountOfFractions: bigint;
+            itToBurn: bigint;
+        };
+    };
+}, Promise<(Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>>];
+//# sourceMappingURL=claimVestedTokens.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claimVestedTokens.route.d.ts","sourceRoot":"","sources":["../../../../../../src/fractions/sales/vesting/v0/claimVestedTokens.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAG3B,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;EAKzC,CAAC;AAkBH,wBAAgB,kCAAkC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAkBpF"}

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

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { claimVestedTokens } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export const ClaimVestedTokensRequestSchema = z.object({
+    address: AddressSchema,
+    campaignId: z.coerce.bigint().positive(),
+    amountOfFractions: z.coerce.bigint().positive(),
+    itToBurn: z.coerce.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 function createClaimVestedTokensTransaction(factory) {
+    return factory.createHandlers(route, validator("json", ClaimVestedTokensRequestSchema.openapi({ ref: "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/src/fractions/sales/vesting/v0/editCliff.route.d.ts

@@ -0,0 +1,87 @@
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+import { z } from "zod";
+export declare const EditCliffRequestSchema: z.ZodObject<{
+    marketAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    saleId: z.ZodBigInt;
+    newCliffDate: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    saleId: bigint;
+    marketAddress: `0x${string}`;
+    newCliffDate: Date;
+}, {
+    saleId: bigint;
+    marketAddress: `0x${string}`;
+    newCliffDate: Date;
+}>;
+export declare function createEditCliffTransactionApp<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<(Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            saleId: bigint;
+            marketAddress: `0x${string}`;
+            newCliffDate: Date;
+        };
+    };
+    out: {
+        json: {
+            saleId: bigint;
+            marketAddress: `0x${string}`;
+            newCliffDate: Date;
+        };
+    };
+}, Promise<(Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            saleId: bigint;
+            marketAddress: `0x${string}`;
+            newCliffDate: Date;
+        };
+    };
+    out: {
+        json: {
+            saleId: bigint;
+            marketAddress: `0x${string}`;
+            newCliffDate: Date;
+        };
+    };
+}, Promise<(Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>>];
+//# sourceMappingURL=editCliff.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editCliff.route.d.ts","sourceRoot":"","sources":["../../../../../../src/fractions/sales/vesting/v0/editCliff.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAG3B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;EAIjC,CAAC;AAkBH,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAkB/E"}

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

@@ -0,0 +1,40 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { buildEditCliffTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { z } from "zod";
+export const EditCliffRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    saleId: z.coerce.bigint().positive(),
+    newCliffDate: z.coerce.date(),
+});
+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 function createEditCliffTransactionApp(factory) {
+    return factory.createHandlers(route, validator("json", EditCliffRequestSchema.openapi({ ref: "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/src/fractions/sales/vesting/v0/parseClaimVestedTokensEvent.d.ts

@@ -0,0 +1,48 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createGetClaimVestedTokensEventRoute<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    campaignId: string;
+    receiver: `0x${string}`;
+    burnId: string;
+    nextBurnId: string | null;
+    amountOfFractionsBurnt: string;
+}, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        query: {
+            chainId: "11155111" | "31337";
+            hash: `0x${string}`;
+        };
+    };
+    out: {
+        query: {
+            chainId: "11155111" | "31337";
+            hash: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    campaignId: string;
+    receiver: `0x${string}`;
+    burnId: string;
+    nextBurnId: string | null;
+    amountOfFractionsBurnt: string;
+}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        query: {
+            chainId: "11155111" | "31337";
+            hash: `0x${string}`;
+        };
+    };
+    out: {
+        query: {
+            chainId: "11155111" | "31337";
+            hash: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    campaignId: string;
+    receiver: `0x${string}`;
+    burnId: string;
+    nextBurnId: string | null;
+    amountOfFractionsBurnt: string;
+}, 200, "json">>>];
+//# sourceMappingURL=parseClaimVestedTokensEvent.d.ts.map

package/dist/src/fractions/sales/vesting/v0/parseClaimVestedTokensEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseClaimVestedTokensEvent.d.ts","sourceRoot":"","sources":["../../../../../../src/fractions/sales/vesting/v0/parseClaimVestedTokensEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAYvC,wBAAgB,oCAAoC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgDtF"}

package/dist/src/fractions/sales/vesting/v0/parseClaimVestedTokensEvent.js

@@ -0,0 +1,58 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { waitForTransactionReceipt } from "viem/actions";
+import { AddressSchema, SentTransactionParamsSchema } from "../../../../common/index.js";
+import { getPublicClient } from "../../../../common/blockchain.js";
+import { HttpError } from "../../../../common/http-error.js";
+import { z } from "../../../../common/zod.js";
+import { CampaignIdSchema } from "../../../sales/searchSaleEvents/v0/searchSaleEvents.js";
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { parseClaimVestedTokensEvent } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export function createGetClaimVestedTokensEventRoute(factory) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get ClaimVestedTokens Event",
+        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted with corresponding \`claimVestedTokens\` action`,
+        tags: ["Fractions Vesting"],
+        responses: {
+            200: {
+                description: "Returns parsed event log",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            campaignId: CampaignIdSchema,
+                            receiver: AddressSchema,
+                            burnId: Int256Positive,
+                            nextBurnId: z.union([Int256Positive, z.null()]),
+                            amountOfFractionsBurnt: Int256Positive,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", SentTransactionParamsSchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId), {
+            hash: params.hash,
+        });
+        const result = parseClaimVestedTokensEvent(receipt.logs);
+        if (!result) {
+            throw new UnableParseClaimVestedTokensEvent();
+        }
+        const { campaignId, receiver, burnId, nextBurnId, amountOfFractionsBurnt } = result;
+        return c.json({
+            campaignId: campaignId.toString(),
+            receiver: receiver,
+            burnId: burnId.toString(),
+            nextBurnId: nextBurnId !== null ? nextBurnId.toString() : null,
+            amountOfFractionsBurnt: amountOfFractionsBurnt.toString(),
+        }, 200);
+    });
+}
+class UnableParseClaimVestedTokensEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse ClaimVestedTokens transaction. Make sure you're passing transaction that is generated by \`claimVestedTokens\` action`,
+            name: "UnableParseClaimVestedTokensEvent",
+        });
+    }
+}