@evergonlabs/tmi-protocol-api 0.1.0

package/dist/src/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/src/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/src/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/src/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/src/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;
+    marketAddress: `0x${string}`;
+    lostAccount: `0x${string}`;
+    recoveryAddress: `0x${string}`;
+    amountOfFractions: bigint;
+    fractionId: bigint;
+}, {
+    campaignId: bigint;
+    marketAddress: `0x${string}`;
+    lostAccount: `0x${string}`;
+    recoveryAddress: `0x${string}`;
+    amountOfFractions: bigint;
+    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;
+            marketAddress: `0x${string}`;
+            lostAccount: `0x${string}`;
+            recoveryAddress: `0x${string}`;
+            amountOfFractions: bigint;
+            fractionId: bigint;
+        };
+    };
+    out: {
+        json: {
+            campaignId: bigint;
+            marketAddress: `0x${string}`;
+            lostAccount: `0x${string}`;
+            recoveryAddress: `0x${string}`;
+            amountOfFractions: bigint;
+            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;
+            marketAddress: `0x${string}`;
+            lostAccount: `0x${string}`;
+            recoveryAddress: `0x${string}`;
+            amountOfFractions: bigint;
+            fractionId: bigint;
+        };
+    };
+    out: {
+        json: {
+            campaignId: bigint;
+            marketAddress: `0x${string}`;
+            lostAccount: `0x${string}`;
+            recoveryAddress: `0x${string}`;
+            amountOfFractions: bigint;
+            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/src/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/src/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);
+        }
+    });
+}

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

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { Factory } from "hono/factory";
+import { Env } from "hono";
+export declare const RejectFractionsRequestSchema: z.ZodObject<{
+    marketAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    saleId: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    saleId: bigint;
+    marketAddress: `0x${string}`;
+}, {
+    saleId: bigint;
+    marketAddress: `0x${string}`;
+}>;
+export declare function createRejectFractionsTransaction<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}`;
+        };
+    };
+    out: {
+        json: {
+            saleId: bigint;
+            marketAddress: `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">) | (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}`;
+        };
+    };
+    out: {
+        json: {
+            saleId: bigint;
+            marketAddress: `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">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>>];
+//# sourceMappingURL=rejectFractions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rejectFractions.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/rejectFractions.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,4BAA4B;;;;;;;;;EAGvC,CAAC;AAkBH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAkBlF"}

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

@@ -0,0 +1,39 @@
+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 { builtRejectFractionsTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export const RejectFractionsRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    saleId: z.coerce.bigint().positive(),
+});
+const route = describeRoute({
+    summary: "Reject fractions",
+    description: "Returns transaction data for rejecting fractions in a sale",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction data for rejecting fractions",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createRejectFractionsTransaction(factory) {
+    return factory.createHandlers(route, validator("json", RejectFractionsRequestSchema.openapi({ ref: "RejectFractionsRequestSchema" })), async (c) => {
+        const { marketAddress, saleId } = c.req.valid("json");
+        try {
+            const tx = builtRejectFractionsTx(marketAddress, saleId);
+            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/searchSaleEvents/index.d.ts

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

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

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

package/dist/src/fractions/sales/searchSaleEvents/v0/searchSaleEvents.d.ts

@@ -0,0 +1,89 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { z } from "../../../../common/zod.js";
+export declare const CampaignIdSchema: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+export declare const SaleEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    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.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>>;
+    owner: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    createdAt: z.ZodString;
+    txHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    id: string;
+    txHash: `0x${string}`;
+    createdAt: string;
+    owner: `0x${string}`;
+    campaignId?: bigint | undefined;
+}, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    id: string;
+    txHash: `0x${string}`;
+    createdAt: string;
+    owner: `0x${string}`;
+    campaignId?: string | number | bigint | undefined;
+}>;
+export declare function createSearchSaleEventsV0App<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;
+                owner?: `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;
+                owner?: `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;
+                owner?: `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;
+                owner?: `0x${string}` | undefined;
+            };
+            page: {
+                skip: number;
+                limit: number;
+            };
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
+//# sourceMappingURL=searchSaleEvents.d.ts.map

package/dist/src/fractions/sales/searchSaleEvents/v0/searchSaleEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchSaleEvents.d.ts","sourceRoot":"","sources":["../../../../../../src/fractions/sales/searchSaleEvents/v0/searchSaleEvents.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,2BAA2B,CAAC;AAe9C,eAAO,MAAM,gBAAgB,iFAG3B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;EAkBxB,CAAC;AAEL,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAsD7E"}

package/dist/src/fractions/sales/searchSaleEvents/v0/searchSaleEvents.js

@@ -0,0 +1,82 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { unixToDate } from "@evergonlabs/tmi-protocol-utils/date";
+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, HashSchema, PlatformContractAddress, PoolIdSchema, TmiChainIdSchema, } from "../../../../common/index.js";
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+import { ISOSchema } from "../../../../common/models/date.js";
+export const CampaignIdSchema = Int256Positive.openapi({
+    description: "Id of a Sale",
+    example: "1",
+});
+export const SaleEventSchema = z
+    .object({
+    id: z.string().openapi({
+        description: "Unique event id",
+    }),
+    chainId: TmiChainIdSchema,
+    platform: PlatformContractAddress,
+    campaignId: CampaignIdSchema.optional().openapi({
+        description: "If empty or 0 then it's platform-wide",
+    }),
+    owner: AddressSchema.openapi({
+        description: "Address role assigned to",
+    }),
+    createdAt: ISOSchema,
+    txHash: HashSchema,
+})
+    .openapi({
+    ref: "StakeEvent",
+});
+export function createSearchSaleEventsV0App(factory) {
+    return factory.createHandlers(describeRoute({
+        summary: "Search sale events",
+        description: "Search sale events by users, platforms and pools",
+        tags: ["Fractions"],
+        responses: {
+            200: {
+                description: "Returns list of sales events within specified platforms and pools",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.array(SaleEventSchema)),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        page: PageSchema,
+        filter: z.object({
+            chainId: TmiChainIdSchema.optional(),
+            owner: AddressSchema.optional(),
+            platform: PlatformContractAddress.optional(),
+            campaignId: CampaignIdSchema.optional(),
+        }),
+    })), async (c) => {
+        const { page, filter } = c.req.valid("json");
+        const result = await indexerClient.db
+            .select()
+            .from(indexerSchemas.fractions.fractionEvents)
+            .limit(page.limit)
+            .offset(page.skip)
+            .orderBy(indexerSchemas.fractions.fractionEvents.createdAt)
+            .where(and(filter.chainId ? eq(indexerSchemas.fractions.fractionEvents.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(indexerSchemas.fractions.fractionEvents.walletAddress, filter.owner) : undefined, filter.platform ? eq(indexerSchemas.fractions.fractionEvents.diamondAddress, filter.platform) : undefined, typeof filter.campaignId === "number"
+            ? eq(indexerSchemas.fractions.fractionEvents.saleId, BigInt(filter.campaignId))
+            : undefined));
+        return c.json(result.map((x) => toSaleEvent(x)), 200);
+    });
+}
+function toSaleEvent(raw) {
+    return {
+        id: raw.id,
+        txHash: raw.txHash,
+        chainId: TmiChainIdSchema.parse(raw.chainId),
+        platform: raw.diamondAddress,
+        owner: raw.walletAddress,
+        campaignId: raw.saleId ? PoolIdSchema.parse(raw.saleId) : undefined,
+        createdAt: unixToDate(raw.createdAt).toISOString(),
+    };
+}