@evergonlabs/tmi-protocol-api 0.1.4 → 0.2.0

package/dist/lending/index.d.ts

@@ -0,0 +1,226 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare const lendingApi: {
+    name: string;
+    createApp: <E extends Env>(factory: Factory<E>) => import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/deploy": {
+            $post: {
+                input: {
+                    json: {
+                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+                        adminAddress: `0x${string}`;
+                        lending: {
+                            minInterest: number;
+                            maxInterest: number;
+                            minDuration: bigint;
+                            maxDuration: bigint;
+                            minimumProportionOverObligation: bigint;
+                        };
+                        discount?: {
+                            burnForDiscount: {
+                                burnableTokenAddress: `0x${string}`;
+                            };
+                        } | undefined;
+                    };
+                };
+                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;
+            };
+        };
+    } & {
+        "/createSale": {
+            $post: {
+                input: {
+                    json: {
+                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+                        fractions: {
+                            symbol: string;
+                            name: string;
+                            amount: bigint;
+                            token?: `0x${string}` | undefined;
+                        };
+                        cap: {
+                            soft: bigint;
+                            hard: bigint;
+                            softPerAccount?: bigint | undefined;
+                            hardPerAccount?: bigint | undefined;
+                        };
+                        market: `0x${string}`;
+                        timeBoundary: {
+                            start: Date;
+                            end: Date;
+                        };
+                        wrapped: [{
+                            values: [bigint, ...bigint[]];
+                            type: "ERC20";
+                            address: `0x${string}`;
+                        } | {
+                            type: "ERC721";
+                            address: `0x${string}`;
+                            tokenIds: [bigint, ...bigint[]];
+                        } | {
+                            values: [bigint, ...bigint[]];
+                            type: "ERC1155";
+                            address: `0x${string}`;
+                            tokenIds: [bigint, ...bigint[]];
+                        }, ...({
+                            values: [bigint, ...bigint[]];
+                            type: "ERC20";
+                            address: `0x${string}`;
+                        } | {
+                            type: "ERC721";
+                            address: `0x${string}`;
+                            tokenIds: [bigint, ...bigint[]];
+                        } | {
+                            values: [bigint, ...bigint[]];
+                            type: "ERC1155";
+                            address: `0x${string}`;
+                            tokenIds: [bigint, ...bigint[]];
+                        })[]];
+                        funding: [{
+                            amountPerPacket: bigint;
+                            token: `0x${string}`;
+                        }, ...{
+                            amountPerPacket: bigint;
+                            token: `0x${string}`;
+                        }[]];
+                        refundAddress: `0x${string}`;
+                        amountOfPacketsPerFraction: bigint;
+                        buyback: {
+                            durationSeconds: number;
+                            interestPercentage: number;
+                            liquidationLimitPercentage: number;
+                            marginCallLimitPercentage: number;
+                        };
+                        discounts?: {
+                            burnableTokenAddress: `0x${string}`;
+                            amountToBurn: bigint;
+                            percentDiscount: number;
+                        } | undefined;
+                    };
+                };
+                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;
+            };
+        };
+    } & {
+        "/buyback": {
+            $post: {
+                input: {
+                    json: {
+                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+                        campaignId: bigint;
+                        buybackPacketsAmount: bigint;
+                    };
+                };
+                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;
+            };
+        };
+    } & {
+        "/setCollateralPrice": {
+            $post: {
+                input: {
+                    json: {
+                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+                        campaignId: bigint;
+                        collateralPriceInFundingPackets: bigint;
+                    };
+                };
+                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;
+            };
+        };
+    } & {
+        "/forcefullyUnlockWrappersNft": {
+            $post: {
+                input: {
+                    json: {
+                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+                        campaignId: bigint;
+                    };
+                };
+                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;
+            };
+        };
+    } & {
+        "/buyBackAfterLiquidation": {
+            $post: {
+                input: {
+                    json: {
+                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+                        campaignId: bigint;
+                    };
+                };
+                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;
+            };
+        };
+    }, "/markets">, "/v0/lending">, "/">;
+    config: {
+        title: string;
+        description: string;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/lending/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lending/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAmBvC,eAAO,MAAM,UAAU;;gBAET,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM/C,CAAC"}

package/dist/lending/index.js

@@ -0,0 +1,24 @@
+import { createDeployLendingMarketTransactionV0 } from "./deployMarket/v0/lending.routes.js";
+import { createBuybackTransactionV0 } from "./buyback/v0/buyback.routes.js";
+import { createSetCollateralPriceTransactionV0 } from "./setCollateralPrice/v0/setCollateralPrice.routes.js";
+import { createForcefullyUnlockWrappersNftTransactionV0 } from "./forcefullyUnlockWrappersNft/v0/forcefullyUnlockWrappersNft.routes.js";
+import { createBuyBackAfterLiquidationTransactionV0 } from "./buyBackAfterLiquidation/v0/buyBackAfterLiquidation.routes.js";
+import { createLendingSale } from "./createLendingSale.js";
+function createLendingMarketsApp(factory) {
+    return factory
+        .createApp()
+        .post("/deploy", ...createDeployLendingMarketTransactionV0(factory))
+        .post("/createSale", ...createLendingSale(factory))
+        .post("/buyback", ...createBuybackTransactionV0(factory))
+        .post("/setCollateralPrice", ...createSetCollateralPriceTransactionV0(factory))
+        .post("/forcefullyUnlockWrappersNft", ...createForcefullyUnlockWrappersNftTransactionV0(factory))
+        .post("/buyBackAfterLiquidation", ...createBuyBackAfterLiquidationTransactionV0(factory));
+}
+export const lendingApi = {
+    name: "Lending API",
+    createApp: (factory) => factory.createApp().route("/v0/lending", factory.createApp().route("/markets", createLendingMarketsApp(factory))),
+    config: {
+        title: "Lending API",
+        description: "Create and manage lending markets with collateral",
+    },
+};

package/dist/lending/setCollateralPrice/v0/setCollateralPrice.routes.d.ts

@@ -0,0 +1,61 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createSetCollateralPriceTransactionV0<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: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+            collateralPriceInFundingPackets: bigint;
+        };
+    };
+    out: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+            collateralPriceInFundingPackets: 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: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+            collateralPriceInFundingPackets: bigint;
+        };
+    };
+    out: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+            collateralPriceInFundingPackets: 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=setCollateralPrice.routes.d.ts.map

package/dist/lending/setCollateralPrice/v0/setCollateralPrice.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setCollateralPrice.routes.d.ts","sourceRoot":"","sources":["../../../../src/lending/setCollateralPrice/v0/setCollateralPrice.routes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAqBvC,wBAAgB,qCAAqC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAevF"}

package/dist/lending/setCollateralPrice/v0/setCollateralPrice.routes.js

@@ -0,0 +1,33 @@
+import { SetCollateralPriceRequestSchema } from "./setCollateralPrice.schema.js";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { toTransaction, TransactionSchema } from "../../../common/index.js";
+const route = describeRoute({
+    summary: "Set collateral price for lending market",
+    description: "Returns transaction data for setting the collateral price in a lending market",
+    tags: ["Lending"],
+    responses: {
+        200: {
+            description: "Returns transaction data for setting collateral price",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createSetCollateralPriceTransactionV0(factory) {
+    return factory.createHandlers(route, validator("json", SetCollateralPriceRequestSchema), async (c) => {
+        const { campaignId, collateralPriceInFundingPackets } = c.req.valid("json");
+        // TODO: Import and use the actual SDK function once available
+        // For now, return a mock transaction structure
+        const tx = {
+            address: "0x0000000000000000000000000000000000000000",
+            abi: [],
+            functionName: "setCollateralPrice",
+            args: [campaignId, collateralPriceInFundingPackets],
+        };
+        return c.json(toTransaction(tx));
+    });
+}

package/dist/lending/setCollateralPrice/v0/setCollateralPrice.schema.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const SetCollateralPriceRequestSchema: z.ZodObject<{
+    chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+    campaignId: z.ZodBigInt;
+    collateralPriceInFundingPackets: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    campaignId: bigint;
+    collateralPriceInFundingPackets: bigint;
+}, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    campaignId: bigint;
+    collateralPriceInFundingPackets: bigint;
+}>;
+//# sourceMappingURL=setCollateralPrice.schema.d.ts.map

package/dist/lending/setCollateralPrice/v0/setCollateralPrice.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setCollateralPrice.schema.d.ts","sourceRoot":"","sources":["../../../../src/lending/setCollateralPrice/v0/setCollateralPrice.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;EAUU,CAAC"}

package/dist/lending/setCollateralPrice/v0/setCollateralPrice.schema.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { TmiChainIdSchema } from "../../../common/index.js";
+export const SetCollateralPriceRequestSchema = z
+    .object({
+    chainId: TmiChainIdSchema,
+    campaignId: z.coerce.bigint().openapi({
+        description: "The campaign ID to set collateral price for",
+    }),
+    collateralPriceInFundingPackets: z.coerce.bigint().openapi({
+        description: "Collateral price in funding packets",
+    }),
+})
+    .openapi({ ref: "SetCollateralPriceRequestSchema" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evergonlabs/tmi-protocol-api",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -20,7 +20,7 @@
   ],
   "dependencies": {
     "@evergonlabs/tmi-contracts-fractions-sdk": "1.1.0",
-    "@evergonlabs/tmi-evm-contracts": "0.3.4",
+    "@evergonlabs/tmi-evm-contracts": "0.6.0",
     "@evergonlabs/tmi-utils": "^0.2.0",
     "@hono/node-server": "^1.19.3",
     "@hono/swagger-ui": "^0.5.2",
@@ -37,12 +37,12 @@
     "viem": "^2.23.2",
     "zod": "^3.25.0",
     "zod-openapi": "^4.2.4",
-    "@evergonlabs/tmi-protocol-indexer": "0.1.1",
-    "@evergonlabs/tmi-protocol-staking-sdk": "0.2.1",
     "@evergonlabs/tmi-protocol-fractions-sdk": "0.2.1",
+    "@evergonlabs/tmi-protocol-indexer": "0.1.1",
     "@evergonlabs/tmi-protocol-shared": "0.1.0",
-    "@evergonlabs/tmi-protocol-utils": "0.2.1",
-    "@evergonlabs/tmi-protocol-types": "0.2.1"
+    "@evergonlabs/tmi-protocol-types": "0.2.1",
+    "@evergonlabs/tmi-protocol-staking-sdk": "0.2.1",
+    "@evergonlabs/tmi-protocol-utils": "0.2.1"
   },
   "devDependencies": {
     "@evergonlabs/tmi-eslint-config": "^0.1.3",

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

@@ -1,62 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare function createSearchClaimV0App<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            filter: {
-                chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
-                platform?: `0x${string}` | undefined;
-                campaignId?: string | number | bigint | undefined;
-                claimer?: `0x${string}` | undefined;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-    out: {
-        json: {
-            filter: {
-                chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
-                platform?: `0x${string}` | undefined;
-                campaignId?: bigint | undefined;
-                claimer?: `0x${string}` | undefined;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        json: {
-            filter: {
-                chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
-                platform?: `0x${string}` | undefined;
-                campaignId?: string | number | bigint | undefined;
-                claimer?: `0x${string}` | undefined;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-    out: {
-        json: {
-            filter: {
-                chainId?: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId | undefined;
-                platform?: `0x${string}` | undefined;
-                campaignId?: bigint | undefined;
-                claimer?: `0x${string}` | undefined;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
-//# sourceMappingURL=searchClaim.route.d.ts.map

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

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

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

@@ -1,47 +0,0 @@
-import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { and, eq } from "@ponder/client";
-import { z } from "../../common/zod.js";
-import { indexerClient } from "../../common/indexer/index.js";
-import { indexerSchemas } from "../../common/indexer/schemas.js";
-import { PageSchema } from "../../common/models/page.js";
-import { AddressSchema, PlatformContractAddress, CampaignIdSchema, TmiChainIdSchema } from "../../common/index.js";
-import { FractionsSaleSchema } from "./common/fractionsSale.js";
-export function createSearchClaimV0App(factory) {
-    return factory.createHandlers(describeRoute({
-        summary: "Search claim events",
-        description: "Search claim events by users, platforms and pools",
-        tags: ["Fractions"],
-        responses: {
-            200: {
-                description: "Returns list of claim events within specified platforms and pools",
-                content: {
-                    "application/json": {
-                        schema: resolver(z.array(FractionsSaleSchema)),
-                    },
-                },
-            },
-        },
-    }), validator("json", z.object({
-        page: PageSchema,
-        filter: z.object({
-            chainId: TmiChainIdSchema.optional(),
-            claimer: AddressSchema.optional(),
-            platform: PlatformContractAddress.optional(),
-            campaignId: CampaignIdSchema.optional(),
-        }),
-    })), async (c) => {
-        const { page, filter } = c.req.valid("json");
-        const { fractions: { fractionsClaims }, } = indexerSchemas;
-        const result = await indexerClient.db.query.fractionsClaims.findMany({
-            with: {
-                fractionSale: true,
-            },
-            where: and(filter.chainId ? eq(fractionsClaims.chainId, Number(filter.chainId)) : undefined, filter.claimer ? eq(fractionsClaims.receiver, filter.claimer) : undefined, filter.platform ? eq(fractionsClaims.diamondAddress, filter.platform) : undefined, typeof filter.campaignId === "number" ? eq(fractionsClaims.saleId, BigInt(filter.campaignId)) : undefined),
-            limit: page.limit,
-            offset: page.skip,
-            orderBy: fractionsClaims.createdAt,
-        });
-        return c.json(result, 200);
-    });
-}

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

@@ -1,120 +0,0 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { z } from "../../common/zod.js";
-export declare const FractionsPurchaseSchema: z.ZodObject<{
-    chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
-    platform: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    campaignId: z.ZodString;
-    buyerAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    amountOfFractions: z.ZodString;
-    priceId: z.ZodString;
-    txHash: z.ZodString;
-    createdAt: z.ZodDate;
-    updatedAt: z.ZodDate;
-}, "strip", z.ZodTypeAny, {
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    platform: `0x${string}`;
-    campaignId: string;
-    txHash: string;
-    createdAt: Date;
-    updatedAt: Date;
-    buyerAddress: `0x${string}`;
-    amountOfFractions: string;
-    priceId: string;
-}, {
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    platform: `0x${string}`;
-    campaignId: string;
-    txHash: string;
-    createdAt: Date;
-    updatedAt: Date;
-    buyerAddress: `0x${string}`;
-    amountOfFractions: string;
-    priceId: string;
-}>;
-export declare function createSearchPurchasesV0App<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    platform: `0x${string}`;
-    campaignId: string;
-    txHash: string;
-    createdAt: string;
-    updatedAt: string;
-    buyerAddress: `0x${string}`;
-    amountOfFractions: string;
-    priceId: string;
-}[], 200, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            filter: {
-                chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-                platform: `0x${string}`;
-                campaignId: string | number | bigint;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-    out: {
-        json: {
-            filter: {
-                chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-                platform: `0x${string}`;
-                campaignId: bigint;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    platform: `0x${string}`;
-    campaignId: string;
-    txHash: string;
-    createdAt: string;
-    updatedAt: string;
-    buyerAddress: `0x${string}`;
-    amountOfFractions: string;
-    priceId: string;
-}[], 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        json: {
-            filter: {
-                chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-                platform: `0x${string}`;
-                campaignId: string | number | bigint;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-    out: {
-        json: {
-            filter: {
-                chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-                platform: `0x${string}`;
-                campaignId: bigint;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-    platform: `0x${string}`;
-    campaignId: string;
-    txHash: string;
-    createdAt: string;
-    updatedAt: string;
-    buyerAddress: `0x${string}`;
-    amountOfFractions: string;
-    priceId: string;
-}[], 200, "json">>>];
-//# sourceMappingURL=searchPurchase.route.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"searchPurchase.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/searchPurchase.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,EAAE,CAAC,EAAE,MAAM,qBAAqB,CAAC;AAMxC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAchC,CAAC;AAEL,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkE5E"}