@evergonlabs/tmi-protocol-api 0.9.0 → 0.10.0-rc.1

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

@@ -1,89 +0,0 @@
-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/fractions/sales/searchSaleEvents/v0/searchSaleEvents.d.ts.map

@@ -1 +0,0 @@
-{"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/fractions/sales/searchSaleEvents/v0/searchSaleEvents.js

@@ -1,82 +0,0 @@
-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(),
-    };
-}

package/dist/fractions/sales/searchSales/v0/searchSales.d.ts

@@ -1,257 +0,0 @@
-import { Factory } from "hono/factory";
-import { AppContext } from "../../../../common/context.js";
-export declare function createSearchSalesV0App(factory: Factory<AppContext>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    status: "created" | "approved" | "rejected" | "finalized" | "refunded";
-    chainId: 1 | 31337 | 11155111 | 72080;
-    createdAt: string;
-    updatedAt: string;
-    campaignId: number;
-    transactionHash: `0x${string}`;
-    nftId: number;
-    fractions: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: 1 | 31337 | 11155111 | 72080;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        totalFractions: string;
-        price: string;
-    };
-    platform: `0x${string}`;
-    owner: `0x${string}`;
-    vesting: {
-        cliffDate: string;
-        totalVestingPeriod: number;
-        portionPeriod: number;
-    } | null;
-    capitalization: {
-        softCap: string;
-        hardCap: string;
-        softCapPerAccount: string;
-        hardCapPerAccount: string;
-    } | null;
-    timeline: {
-        startDate: string;
-        endDate: string;
-    } | null;
-    wrappedAssets: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: 1 | 31337 | 11155111 | 72080;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        wrappedAmount: never;
-    }[];
-    fundingAssets: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: 1 | 31337 | 11155111 | 72080;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        amountPerPacket: never;
-    }[];
-}[], 200, "json">>>, import("hono/types").H<import("hono").Env, string, {
-    in: {
-        json: {
-            filter: {
-                chainId?: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080" | undefined;
-                campaignId?: string | number | bigint | undefined;
-                platform?: `0x${string}` | undefined;
-                owner?: `0x${string}` | undefined;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-    out: {
-        json: {
-            filter: {
-                chainId?: 1 | 31337 | 11155111 | 72080 | undefined;
-                campaignId?: bigint | undefined;
-                platform?: `0x${string}` | undefined;
-                owner?: `0x${string}` | undefined;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    status: "created" | "approved" | "rejected" | "finalized" | "refunded";
-    chainId: 1 | 31337 | 11155111 | 72080;
-    createdAt: string;
-    updatedAt: string;
-    campaignId: number;
-    transactionHash: `0x${string}`;
-    nftId: number;
-    fractions: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: 1 | 31337 | 11155111 | 72080;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        totalFractions: string;
-        price: string;
-    };
-    platform: `0x${string}`;
-    owner: `0x${string}`;
-    vesting: {
-        cliffDate: string;
-        totalVestingPeriod: number;
-        portionPeriod: number;
-    } | null;
-    capitalization: {
-        softCap: string;
-        hardCap: string;
-        softCapPerAccount: string;
-        hardCapPerAccount: string;
-    } | null;
-    timeline: {
-        startDate: string;
-        endDate: string;
-    } | null;
-    wrappedAssets: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: 1 | 31337 | 11155111 | 72080;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        wrappedAmount: never;
-    }[];
-    fundingAssets: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: 1 | 31337 | 11155111 | 72080;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        amountPerPacket: never;
-    }[];
-}[], 200, "json">>>, import("hono/types").H<AppContext, string, {
-    in: {
-        json: {
-            filter: {
-                chainId?: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080" | undefined;
-                campaignId?: string | number | bigint | undefined;
-                platform?: `0x${string}` | undefined;
-                owner?: `0x${string}` | undefined;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-    out: {
-        json: {
-            filter: {
-                chainId?: 1 | 31337 | 11155111 | 72080 | undefined;
-                campaignId?: bigint | undefined;
-                platform?: `0x${string}` | undefined;
-                owner?: `0x${string}` | undefined;
-            };
-            page: {
-                skip: number;
-                limit: number;
-            };
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    status: "created" | "approved" | "rejected" | "finalized" | "refunded";
-    chainId: 1 | 31337 | 11155111 | 72080;
-    createdAt: string;
-    updatedAt: string;
-    campaignId: number;
-    transactionHash: `0x${string}`;
-    nftId: number;
-    fractions: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: 1 | 31337 | 11155111 | 72080;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        totalFractions: string;
-        price: string;
-    };
-    platform: `0x${string}`;
-    owner: `0x${string}`;
-    vesting: {
-        cliffDate: string;
-        totalVestingPeriod: number;
-        portionPeriod: number;
-    } | null;
-    capitalization: {
-        softCap: string;
-        hardCap: string;
-        softCapPerAccount: string;
-        hardCapPerAccount: string;
-    } | null;
-    timeline: {
-        startDate: string;
-        endDate: string;
-    } | null;
-    wrappedAssets: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: 1 | 31337 | 11155111 | 72080;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        wrappedAmount: never;
-    }[];
-    fundingAssets: {
-        asset: {
-            symbol: string;
-            type: string;
-            chainId: 1 | 31337 | 11155111 | 72080;
-            address: `0x${string}`;
-            name: string;
-            tokenId: string | null;
-            decimals: number;
-            burnable: boolean;
-        };
-        amountPerPacket: never;
-    }[];
-}[], 200, "json">>>];
-//# sourceMappingURL=searchSales.d.ts.map

package/dist/fractions/sales/searchSales/v0/searchSales.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"searchSales.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/sales/searchSales/v0/searchSales.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAevC,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwDlE"}

package/dist/fractions/sales/searchSales/v0/searchSales.js

@@ -1,49 +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 { indexerSchemas } from "../../../../common/indexer/schemas.js";
-import { PageSchema } from "../../../../common/models/page.js";
-import { AddressSchema, PlatformContractAddress, CampaignIdSchema, FractionsChainId, } from "../../../../common/index.js";
-import { FractionsSaleSchema, toFractionsSale } from "../../common/fractionsSale.js";
-export function createSearchSalesV0App(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(FractionsSaleSchema)),
-                    },
-                },
-            },
-        },
-    }), validator("json", z.object({
-        page: PageSchema,
-        filter: z.object({
-            chainId: FractionsChainId.optional(),
-            owner: AddressSchema.optional(),
-            platform: PlatformContractAddress.optional(),
-            campaignId: CampaignIdSchema.optional(),
-        }),
-    })), async (c) => {
-        const { page, filter } = c.req.valid("json");
-        const { fractions: { fractionsSales }, } = indexerSchemas;
-        const result = await c.get("indexerClient").db.query.fractionsSales.findMany({
-            with: {
-                fractionsAsset: true,
-                wrappedAssets: { with: { asset: true } },
-                fundingAssets: { with: { asset: true } },
-            },
-            where: and(filter.chainId ? eq(fractionsSales.chainId, Number(filter.chainId)) : undefined, filter.owner ? eq(fractionsSales.creator, filter.owner) : undefined, filter.platform ? eq(fractionsSales.diamondAddress, filter.platform) : undefined, typeof filter.campaignId === "number" ? eq(fractionsSales.saleId, BigInt(filter.campaignId)) : undefined),
-            limit: page.limit,
-            offset: page.skip,
-            orderBy: fractionsSales.createdAt,
-        });
-        const sales = result.map((x) => toFractionsSale(x, x.fractionsAsset, x.wrappedAssets, x.fundingAssets));
-        return c.json(sales, 200);
-    });
-}

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

@@ -1,92 +0,0 @@
-import { Factory } from "hono/factory";
-import { z } from "../../../../common/zod.js";
-import { AppContext } from "../../../../common/context.js";
-export declare const ClaimStatisticsRequestSchema: z.ZodObject<{
-    chainId: z.ZodPipeline<z.ZodEffects<z.ZodType<1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080", z.ZodTypeDef, 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080">, 1 | 31337 | 11155111 | 72080, 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080">, z.ZodType<1 | 31337 | 11155111 | 72080, z.ZodTypeDef, 1 | 31337 | 11155111 | 72080>>;
-    platform: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    campaignId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
-    walletAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-}, "strip", z.ZodTypeAny, {
-    chainId: 1 | 31337 | 11155111 | 72080;
-    walletAddress: `0x${string}`;
-    campaignId: bigint;
-    platform: `0x${string}`;
-}, {
-    chainId: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080";
-    walletAddress: `0x${string}`;
-    campaignId: string | number | bigint;
-    platform: `0x${string}`;
-}>;
-export declare const ClaimStatisticsResponseSchema: z.ZodObject<{
-    chainId: z.ZodPipeline<z.ZodEffects<z.ZodType<1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080", z.ZodTypeDef, 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080">, 1 | 31337 | 11155111 | 72080, 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080">, z.ZodType<1 | 31337 | 11155111 | 72080, z.ZodTypeDef, 1 | 31337 | 11155111 | 72080>>;
-    platform: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    campaignId: z.ZodString;
-    totalClaims: z.ZodNumber;
-    lastClaimId: z.ZodNullable<z.ZodString>;
-    totalClaimed: z.ZodArray<z.ZodObject<{
-        tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-        amount: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        tokenAddress: `0x${string}`;
-        amount: string;
-    }, {
-        tokenAddress: `0x${string}`;
-        amount: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    chainId: 1 | 31337 | 11155111 | 72080;
-    campaignId: string;
-    platform: `0x${string}`;
-    totalClaims: number;
-    lastClaimId: string | null;
-    totalClaimed: {
-        tokenAddress: `0x${string}`;
-        amount: string;
-    }[];
-}, {
-    chainId: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080";
-    campaignId: string;
-    platform: `0x${string}`;
-    totalClaims: number;
-    lastClaimId: string | null;
-    totalClaimed: {
-        tokenAddress: `0x${string}`;
-        amount: string;
-    }[];
-}>;
-export declare function createClaimStatisticsV0App(factory: Factory<AppContext>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<import("hono").Env, string, {
-    in: {
-        json: {
-            chainId: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080";
-            walletAddress: `0x${string}`;
-            campaignId: string | number | bigint;
-            platform: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            chainId: 1 | 31337 | 11155111 | 72080;
-            walletAddress: `0x${string}`;
-            campaignId: bigint;
-            platform: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>, import("hono/types").H<AppContext, string, {
-    in: {
-        json: {
-            chainId: 1 | 31337 | 11155111 | "31337" | "11155111" | "1" | 72080 | "72080";
-            walletAddress: `0x${string}`;
-            campaignId: string | number | bigint;
-            platform: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            chainId: 1 | 31337 | 11155111 | 72080;
-            walletAddress: `0x${string}`;
-            campaignId: bigint;
-            platform: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<never, 200, "json">>>];
-//# sourceMappingURL=claimStatistics.route.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"claimStatistics.route.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/sales/vesting/v0/claimStatistics.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAQvC,OAAO,EAAE,CAAC,EAAE,MAAM,2BAA2B,CAAC;AAG9C,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;EASrC,CAAC;AAEL,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBtC,CAAC;AAEL,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAuFtE"}

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

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