@evergonlabs/tmi-protocol-api 0.1.0

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

@@ -0,0 +1,52 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createGetVaultAddressRoute<E extends Env>(factory: Factory<E>): [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<Env, 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">)>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, 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

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

package/dist/fractions/sales/getVaultAddress.js

@@ -0,0 +1,60 @@
+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 { readContract } from "viem/actions";
+import { AddressSchema, CampaignIdSchema, PlatformContractAddress, TmiChainIdSchema } from "../../common/index.js";
+import { getPublicClient } from "../../common/blockchain.js";
+import { indexerClient } from "../../common/indexer/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { z } from "../../common/zod.js";
+export function createGetVaultAddressRoute(factory) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get Vault address",
+        description: "Returns address of sale's vault",
+        tags: ["Fractions"],
+        responses: {
+            200: {
+                description: "Returns address of vault",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({ vault: AddressSchema })),
+                    },
+                },
+            },
+        },
+    }), validator("query", z.object({
+        chainId: TmiChainIdSchema,
+        platform: PlatformContractAddress,
+        campaign: CampaignIdSchema,
+    })), async (c) => {
+        const params = c.req.valid("query");
+        const publicClient = getPublicClient(params.chainId);
+        const [platform] = await indexerClient.db
+            .select()
+            .from(indexerSchemas.fractions.fractionsMarkets)
+            .limit(1)
+            .where(and(eq(indexerSchemas.fractions.fractionsMarkets.chainId, params.chainId), eq(indexerSchemas.fractions.fractionsMarkets.contractAddress, params.platform)));
+        if (!platform) {
+            return c.json({
+                error: "Platform not found",
+                chainId: params.chainId,
+                market: params.platform,
+            }, 404);
+        }
+        if (!platform.wrapperAddress) {
+            return c.json({
+                error: "Platform has no wrapper address",
+                chainId: params.chainId,
+                market: params.platform,
+            }, 404);
+        }
+        const address = await readContract(publicClient, {
+            abi: ABIS.wrapperAbi,
+            functionName: "vaults",
+            args: [params.campaign],
+            address: platform.wrapperAddress,
+        });
+        return c.json({ vaultAddress: address }, 200);
+    });
+}

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

@@ -0,0 +1,42 @@
+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[];
+        };
+    };
+    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

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

package/dist/fractions/sales/getWithdrawEvent.js

@@ -0,0 +1,51 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { waitForTransactionReceipt } from "viem/actions";
+import { AddressSchema, CampaignIdSchema, 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 { parseWithdrawEvent } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export function createGetWithdrawEventRoute(factory) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get Withdraw Event",
+        description: `Gets the transaction by hash and parses emitted logs.`,
+        tags: ["Fractions"],
+        responses: {
+            200: {
+                description: "Returns parsed event log",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            campaignId: CampaignIdSchema,
+                            receiver: AddressSchema,
+                            packetsReceived: z.coerce.bigint(),
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", SentTransactionParamsSchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId), {
+            hash: params.hash,
+        });
+        const result = parseWithdrawEvent(receipt.logs);
+        if (!result) {
+            throw new UnableParseWithdrawEvent();
+        }
+        return c.json({
+            campaignId: result.campaignId.toString(),
+            receiver: result.receiver,
+            packetsReceived: result.packetsReceived.toString(),
+        }, 200);
+    });
+}
+class UnableParseWithdrawEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse withdraw transaction.`,
+            name: "UnableParseWithdrawEvent",
+        });
+    }
+}

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

@@ -0,0 +1,144 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { z } from "zod";
+export declare const ReceiveFundsAfterNonFundedRequestSchema: z.ZodObject<z.objectUtil.extendShape<{
+    upperGenesisId: z.ZodOptional<z.ZodBigInt>;
+    amountOfFractions: z.ZodBigInt;
+    isDiscounted: z.ZodBoolean;
+}, {
+    market: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    campaignId: z.ZodBigInt;
+}>, "strip", z.ZodTypeAny, {
+    campaignId: bigint;
+    amountOfFractions: bigint;
+    market: `0x${string}`;
+    isDiscounted: boolean;
+    upperGenesisId?: bigint | undefined;
+}, {
+    campaignId: bigint;
+    amountOfFractions: bigint;
+    market: `0x${string}`;
+    isDiscounted: boolean;
+    upperGenesisId?: bigint | undefined;
+}>;
+export declare function createReceiveFundsAfterNonFundedTransaction<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;
+            amountOfFractions: bigint;
+            market: `0x${string}`;
+            isDiscounted: boolean;
+            upperGenesisId?: bigint | undefined;
+        };
+    };
+    out: {
+        json: {
+            campaignId: bigint;
+            amountOfFractions: bigint;
+            market: `0x${string}`;
+            isDiscounted: boolean;
+            upperGenesisId?: bigint | undefined;
+        };
+    };
+}, 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;
+            amountOfFractions: bigint;
+            market: `0x${string}`;
+            isDiscounted: boolean;
+            upperGenesisId?: bigint | undefined;
+        };
+    };
+    out: {
+        json: {
+            campaignId: bigint;
+            amountOfFractions: bigint;
+            market: `0x${string}`;
+            isDiscounted: boolean;
+            upperGenesisId?: bigint | undefined;
+        };
+    };
+}, 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">>>];
+export declare function createCheckAndJumpToNonFundedTransaction<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=receiveFundsAfterNonFunded.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"receiveFundsAfterNonFunded.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/receiveFundsAfterNonFunded.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;EAMvB,CAAC;AAkB9B,wBAAgB,2CAA2C,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAe7F;AAkBD,wBAAgB,wCAAwC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAM1F"}

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

@@ -0,0 +1,59 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { receiveFundsAfterNonFundedNoDiscount, receiveFundsAfterNonFundedDiscount, checkAndJumpToNonFunded, } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { toTransaction, TransactionSchema } from "../../common/index.js";
+import { z } from "zod";
+import { SaleIdSchema } from "../../common/models/saleId.js";
+export const ReceiveFundsAfterNonFundedRequestSchema = z
+    .object({
+    upperGenesisId: z.coerce.bigint().optional().openapi({ description: "Required if discount was applied" }),
+    amountOfFractions: z.coerce.bigint(),
+    isDiscounted: z.boolean(),
+})
+    .extend(SaleIdSchema.shape);
+const route = describeRoute({
+    summary: "Receive funds after non funded state",
+    description: "Returns transaction to receive funds after a sale enters non funded state",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction to receive funds after non funded state",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createReceiveFundsAfterNonFundedTransaction(factory) {
+    return factory.createHandlers(route, validator("json", ReceiveFundsAfterNonFundedRequestSchema.openapi({ ref: "ReceiveFundsAfterNonFundedRequestSchema" })), async (c) => {
+        const { market, campaignId, amountOfFractions, upperGenesisId, isDiscounted } = c.req.valid("json");
+        const tx = isDiscounted
+            ? receiveFundsAfterNonFundedDiscount(market, campaignId, upperGenesisId, amountOfFractions)
+            : receiveFundsAfterNonFundedNoDiscount(market, campaignId, amountOfFractions);
+        return c.json(toTransaction(tx));
+    });
+}
+const checkAndJumpToNonFundedRoute = describeRoute({
+    summary: "Check and jump to non funded state",
+    description: "Returns transaction to check and jump a sale to non funded state if conditions are met",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction to check and jump to non funded state",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createCheckAndJumpToNonFundedTransaction(factory) {
+    return factory.createHandlers(checkAndJumpToNonFundedRoute, validator("json", SaleIdSchema), async (c) => {
+        const { market, campaignId } = c.req.valid("json");
+        const tx = checkAndJumpToNonFunded(market, campaignId);
+        return c.json(toTransaction(tx));
+    });
+}

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

@@ -0,0 +1,57 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createReceiveNonPurchasedWrappedAssetsTransaction<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=receiveNonPurchasedWrappedAssets.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"receiveNonPurchasedWrappedAssets.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/receiveNonPurchasedWrappedAssets.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAuBvC,wBAAgB,iDAAiD,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAMnG"}

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

@@ -0,0 +1,27 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { receiveNonPurchasedWrappedAssets } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { toTransaction, TransactionSchema } from "../../common/index.js";
+import { SaleIdSchema } from "../../common/models/saleId.js";
+const route = describeRoute({
+    summary: "Receive non-purchased wrapped assets",
+    description: "Returns transaction to receive non-purchased wrapped assets from a sale",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction to receive non-purchased wrapped assets",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createReceiveNonPurchasedWrappedAssetsTransaction(factory) {
+    return factory.createHandlers(route, validator("json", SaleIdSchema), async (c) => {
+        const { market, campaignId } = c.req.valid("json");
+        const tx = receiveNonPurchasedWrappedAssets(market, campaignId);
+        return c.json(toTransaction(tx));
+    });
+}

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

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+export declare const RecoverFractionsRequestSchema: z.ZodObject<{
+    marketAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    campaignId: z.ZodBigInt;
+    lostAccount: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    recoveryAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amountOfFractions: z.ZodBigInt;
+    fractionId: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    campaignId: bigint;
+    amountOfFractions: bigint;
+    marketAddress: `0x${string}`;
+    lostAccount: `0x${string}`;
+    recoveryAddress: `0x${string}`;
+    fractionId: bigint;
+}, {
+    campaignId: bigint;
+    amountOfFractions: bigint;
+    marketAddress: `0x${string}`;
+    lostAccount: `0x${string}`;
+    recoveryAddress: `0x${string}`;
+    fractionId: bigint;
+}>;
+export declare function createRecoverFractionsTransaction<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: {
+            campaignId: bigint;
+            amountOfFractions: bigint;
+            marketAddress: `0x${string}`;
+            lostAccount: `0x${string}`;
+            recoveryAddress: `0x${string}`;
+            fractionId: bigint;
+        };
+    };
+    out: {
+        json: {
+            campaignId: bigint;
+            amountOfFractions: bigint;
+            marketAddress: `0x${string}`;
+            lostAccount: `0x${string}`;
+            recoveryAddress: `0x${string}`;
+            fractionId: 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: {
+            campaignId: bigint;
+            amountOfFractions: bigint;
+            marketAddress: `0x${string}`;
+            lostAccount: `0x${string}`;
+            recoveryAddress: `0x${string}`;
+            fractionId: bigint;
+        };
+    };
+    out: {
+        json: {
+            campaignId: bigint;
+            amountOfFractions: bigint;
+            marketAddress: `0x${string}`;
+            lostAccount: `0x${string}`;
+            recoveryAddress: `0x${string}`;
+            fractionId: 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=recoverFractions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recoverFractions.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/recoverFractions.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,6BAA6B;;;;;;;;;;;;;;;;;;;;;EASU,CAAC;AAkBrD,wBAAgB,iCAAiC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAsBnF"}

package/dist/fractions/sales/recoverFractions.js

@@ -0,0 +1,45 @@
+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 { buildRecoverFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export const RecoverFractionsRequestSchema = z
+    .object({
+    marketAddress: AddressSchema,
+    campaignId: z.coerce.bigint().positive(),
+    lostAccount: AddressSchema,
+    recoveryAddress: AddressSchema,
+    amountOfFractions: z.coerce.bigint().positive(),
+    fractionId: z.coerce.bigint().nonnegative(),
+})
+    .openapi({ ref: "RecoverFractionsRequestSchema" });
+const route = describeRoute({
+    summary: "Recover fractions",
+    description: "Returns transaction data for recovering fractions from a lost account",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for recovering fractions",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createRecoverFractionsTransaction(factory) {
+    return factory.createHandlers(route, validator("json", RecoverFractionsRequestSchema), async (c) => {
+        const { marketAddress, campaignId, lostAccount, recoveryAddress, amountOfFractions, fractionId } = c.req.valid("json");
+        try {
+            const tx = buildRecoverFractionsTx(marketAddress, campaignId, lostAccount, recoveryAddress, amountOfFractions, fractionId);
+            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);
+        }
+    });
+}