@evergonlabs/tmi-protocol-api 0.1.0

package/dist/fractions/sales/common/fractionsSale.d.ts

@@ -0,0 +1,352 @@
+import { z } from "../../../common/zod.js";
+import { indexerSchemas } from "../../../common/indexer/schemas.js";
+export declare const FractionsSaleSchema: 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.ZodNumber;
+    nftId: z.ZodNumber;
+    status: z.ZodEnum<["created", "approved", "rejected", "finalized", "refunded"]>;
+    owner: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    fractions: z.ZodObject<{
+        asset: z.ZodObject<{
+            chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+            address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+            type: z.ZodString;
+            symbol: z.ZodString;
+            name: z.ZodString;
+            tokenId: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+            decimals: z.ZodDefault<z.ZodNumber>;
+            burnable: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals: number;
+            burnable: boolean;
+        }, {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals?: number | undefined;
+            burnable?: boolean | undefined;
+        }>;
+        totalFractions: z.ZodString;
+        price: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        asset: {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals: number;
+            burnable: boolean;
+        };
+        totalFractions: string;
+        price: string;
+    }, {
+        asset: {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals?: number | undefined;
+            burnable?: boolean | undefined;
+        };
+        totalFractions: string;
+        price: string;
+    }>;
+    capitalization: z.ZodUnion<[z.ZodObject<{
+        hardCap: z.ZodString;
+        hardCapPerAccount: z.ZodString;
+        softCap: z.ZodString;
+        softCapPerAccount: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        softCap: string;
+        hardCap: string;
+        softCapPerAccount: string;
+        hardCapPerAccount: string;
+    }, {
+        softCap: string;
+        hardCap: string;
+        softCapPerAccount: string;
+        hardCapPerAccount: string;
+    }>, z.ZodNull]>;
+    timeline: z.ZodUnion<[z.ZodObject<{
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        startDate: string;
+        endDate: string;
+    }, {
+        startDate: string;
+        endDate: string;
+    }>, z.ZodNull]>;
+    vesting: z.ZodUnion<[z.ZodObject<{
+        cliffDate: z.ZodString;
+        totalVestingPeriod: z.ZodNumber;
+        portionPeriod: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        cliffDate: string;
+        totalVestingPeriod: number;
+        portionPeriod: number;
+    }, {
+        cliffDate: string;
+        totalVestingPeriod: number;
+        portionPeriod: number;
+    }>, z.ZodNull]>;
+    wrappedAssets: z.ZodArray<z.ZodObject<{
+        asset: z.ZodObject<{
+            chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+            address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+            type: z.ZodString;
+            symbol: z.ZodString;
+            name: z.ZodString;
+            tokenId: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+            decimals: z.ZodDefault<z.ZodNumber>;
+            burnable: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals: number;
+            burnable: boolean;
+        }, {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals?: number | undefined;
+            burnable?: boolean | undefined;
+        }>;
+        wrappedAmount: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    }, "strip", z.ZodTypeAny, {
+        asset: {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals: number;
+            burnable: boolean;
+        };
+        wrappedAmount: bigint;
+    }, {
+        asset: {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals?: number | undefined;
+            burnable?: boolean | undefined;
+        };
+        wrappedAmount: string | number | bigint;
+    }>, "many">;
+    fundingAssets: z.ZodArray<z.ZodObject<{
+        asset: z.ZodObject<{
+            chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+            address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+            type: z.ZodString;
+            symbol: z.ZodString;
+            name: z.ZodString;
+            tokenId: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+            decimals: z.ZodDefault<z.ZodNumber>;
+            burnable: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals: number;
+            burnable: boolean;
+        }, {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals?: number | undefined;
+            burnable?: boolean | undefined;
+        }>;
+        amountPerPacket: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodBigInt>;
+    }, "strip", z.ZodTypeAny, {
+        asset: {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals: number;
+            burnable: boolean;
+        };
+        amountPerPacket: bigint;
+    }, {
+        asset: {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals?: number | undefined;
+            burnable?: boolean | undefined;
+        };
+        amountPerPacket: string | number | bigint;
+    }>, "many">;
+    transactionHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "created" | "approved" | "rejected" | "finalized" | "refunded";
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: number;
+    createdAt: string;
+    updatedAt: string;
+    transactionHash: `0x${string}`;
+    nftId: number;
+    fractions: {
+        asset: {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals: number;
+            burnable: boolean;
+        };
+        totalFractions: string;
+        price: 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;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals: number;
+            burnable: boolean;
+        };
+        wrappedAmount: bigint;
+    }[];
+    fundingAssets: {
+        asset: {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals: number;
+            burnable: boolean;
+        };
+        amountPerPacket: bigint;
+    }[];
+}, {
+    status: "created" | "approved" | "rejected" | "finalized" | "refunded";
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: number;
+    createdAt: string;
+    updatedAt: string;
+    transactionHash: `0x${string}`;
+    nftId: number;
+    fractions: {
+        asset: {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals?: number | undefined;
+            burnable?: boolean | undefined;
+        };
+        totalFractions: string;
+        price: 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;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals?: number | undefined;
+            burnable?: boolean | undefined;
+        };
+        wrappedAmount: string | number | bigint;
+    }[];
+    fundingAssets: {
+        asset: {
+            symbol: string;
+            type: string;
+            name: string;
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            tokenId: string | null;
+            decimals?: number | undefined;
+            burnable?: boolean | undefined;
+        };
+        amountPerPacket: string | number | bigint;
+    }[];
+}>;
+export declare function toFractionsSale(raw: typeof indexerSchemas.fractions.fractionsSales.$inferSelect, fractionsAsset: typeof indexerSchemas.assets.$inferSelect, wrappedAssets: any[], fundingAssets: any[]): z.output<typeof FractionsSaleSchema>;
+//# sourceMappingURL=fractionsSale.d.ts.map

package/dist/fractions/sales/common/fractionsSale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fractionsSale.d.ts","sourceRoot":"","sources":["../../../../src/fractions/sales/common/fractionsSale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAapE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuD5B,CAAC;AAEL,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,cAAc,CAAC,SAAS,CAAC,cAAc,CAAC,YAAY,EAChE,cAAc,EAAE,OAAO,cAAc,CAAC,MAAM,CAAC,YAAY,EACzD,aAAa,EAAE,GAAG,EAAE,EACpB,aAAa,EAAE,GAAG,EAAE,GACnB,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAgCtC"}

package/dist/fractions/sales/common/fractionsSale.js

@@ -0,0 +1,123 @@
+import { z } from "../../../common/zod.js";
+import { AddressSchema, HashSchema, PlatformContractAddress, TmiChainIdSchema, AssetSchema, FractionsSaleStatusSchema, } from "../../../common/index.js";
+import { ISOSchema } from "../../../common/models/date.js";
+import { Int256Positive } from "@evergonlabs/tmi-utils/models";
+export const FractionsSaleSchema = z
+    .object({
+    chainId: TmiChainIdSchema,
+    platform: PlatformContractAddress,
+    // campaignId: CampaignIdSchema,
+    campaignId: z.number(),
+    // nftId: Int256Positive,
+    nftId: z.number(),
+    status: FractionsSaleStatusSchema,
+    owner: AddressSchema.openapi({
+        description: "Address role assigned to",
+    }),
+    fractions: z.object({
+        asset: AssetSchema,
+        // totalFractions: Int256Positive,
+        totalFractions: z.string(),
+        // price: Int256Positive,
+        price: z.string(),
+    }),
+    capitalization: z.union([
+        z.object({
+            // hardCap: Int256Positive,
+            // hardCapPerAccount: Int256Positive,
+            // softCap: Int256Positive,
+            // softCapPerAccount: Int256Positive,
+            hardCap: z.string(),
+            hardCapPerAccount: z.string(),
+            softCap: z.string(),
+            softCapPerAccount: z.string(),
+        }),
+        z.null(),
+    ]),
+    timeline: z.union([
+        z.object({
+            startDate: ISOSchema,
+            endDate: ISOSchema,
+        }),
+        z.null(),
+    ]),
+    vesting: z.union([
+        z.object({
+            cliffDate: ISOSchema,
+            totalVestingPeriod: z.number().nonnegative(),
+            portionPeriod: z.number().nonnegative(),
+        }),
+        z.null(),
+    ]),
+    wrappedAssets: z.array(z.object({ asset: AssetSchema, wrappedAmount: Int256Positive })),
+    fundingAssets: z.array(z.object({ asset: AssetSchema, amountPerPacket: Int256Positive })),
+    transactionHash: HashSchema,
+    createdAt: ISOSchema,
+    updatedAt: ISOSchema,
+})
+    .openapi({
+    ref: "FractionsSale",
+});
+export function toFractionsSale(raw, fractionsAsset, wrappedAssets, fundingAssets) {
+    const fractions = toSaleFractions(raw, fractionsAsset);
+    const capitalization = toSaleCapitalization(raw);
+    const timeline = toSaleTimeline(raw);
+    const vesting = toSaleVesting(raw);
+    return {
+        chainId: TmiChainIdSchema.parse(raw.chainId),
+        platform: AddressSchema.parse(raw.diamondAddress),
+        campaignId: Number(raw.saleId),
+        nftId: Number(raw.nftId),
+        owner: AddressSchema.parse(raw.creator),
+        status: FractionsSaleStatusSchema.parse(raw.status),
+        wrappedAssets: wrappedAssets.map((wrapped) => ({
+            asset: AssetSchema.parse(wrapped.asset),
+            wrappedAmount: wrapped.wrappedAmount.toString(),
+        })),
+        fundingAssets: fundingAssets.map((funding) => ({
+            asset: AssetSchema.parse(funding.asset),
+            amountPerPacket: funding.amountPerPacket.toString(),
+        })),
+        fractions,
+        capitalization,
+        timeline,
+        vesting,
+        transactionHash: raw.transactionHash,
+        createdAt: raw.createdAt.toISOString(),
+        updatedAt: raw.updatedAt.toISOString(),
+    };
+}
+function toSaleFractions(raw, fractionsAsset) {
+    //TODO:
+    return {
+        asset: AssetSchema.parse(fractionsAsset),
+        totalFractions: raw.fractionsCreated.toString(),
+        price: raw.fractionPrice.toString(),
+    };
+}
+function toSaleCapitalization(raw) {
+    //TODO:
+    return {
+        softCap: raw.softCap.toString(),
+        hardCap: raw.hardCap.toString(),
+        softCapPerAccount: raw.softCapPerAccount.toString(),
+        hardCapPerAccount: raw.hardCapPerAccount.toString(),
+    };
+}
+function toSaleTimeline(raw) {
+    //TODO:
+    return {
+        startDate: raw.startDate.toISOString(),
+        endDate: raw.endDate.toISOString(),
+    };
+}
+function toSaleVesting(raw) {
+    //TODO:
+    return raw.cliffDate
+        ? {
+            cliffDate: raw.cliffDate.toISOString(),
+            totalVestingPeriod: Number(raw.totalVestingPeriod),
+            portionPeriod: Number(raw.portionPeriod),
+        }
+        : null;
+}

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

@@ -0,0 +1,98 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { z } from "../../common/zod.js";
+export declare const FractionsSaleStatisticSchema: 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;
+    statistics: z.ZodArray<z.ZodObject<{
+        priceId: z.ZodString;
+        fractionsSold: z.ZodString;
+        purchases: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        priceId: string;
+        purchases: number;
+        fractionsSold: string;
+    }, {
+        priceId: string;
+        purchases: number;
+        fractionsSold: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: string;
+    statistics: {
+        priceId: string;
+        purchases: number;
+        fractionsSold: string;
+    }[];
+}, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: string;
+    statistics: {
+        priceId: string;
+        purchases: number;
+        fractionsSold: string;
+    }[];
+}>;
+export declare function createSaleStatisticsV0App<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;
+    statistics: {
+        priceId: string;
+        purchases: number;
+        fractionsSold: string;
+    }[];
+}, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            platform: `0x${string}`;
+            campaignId: string | number | bigint;
+        };
+    };
+    out: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            platform: `0x${string}`;
+            campaignId: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: string;
+    statistics: {
+        priceId: string;
+        purchases: number;
+        fractionsSold: string;
+    }[];
+}, 200, "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;
+            platform: `0x${string}`;
+            campaignId: string | number | bigint;
+        };
+    };
+    out: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            platform: `0x${string}`;
+            campaignId: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    platform: `0x${string}`;
+    campaignId: string;
+    statistics: {
+        priceId: string;
+        purchases: number;
+        fractionsSold: string;
+    }[];
+}, 200, "json">>>];
+//# sourceMappingURL=getFractionSaleStatistics.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getFractionSaleStatistics.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sales/getFractionSaleStatistics.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;AAKxC,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAerC,CAAC;AAEL,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA+D3E"}

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

@@ -0,0 +1,64 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { and, count, eq, sum } from "@ponder/client";
+import { z } from "../../common/zod.js";
+import { indexerClient } from "../../common/indexer/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { PlatformContractAddress, CampaignIdSchema, TmiChainIdSchema } from "../../common/index.js";
+export const FractionsSaleStatisticSchema = z
+    .object({
+    chainId: TmiChainIdSchema,
+    platform: PlatformContractAddress,
+    campaignId: z.coerce.string(),
+    statistics: z.array(z.object({
+        priceId: z.coerce.string(),
+        fractionsSold: z.coerce.string(),
+        purchases: z.number(),
+    })),
+})
+    .openapi({
+    ref: "FractionsSaleStatistics",
+});
+export function createSaleStatisticsV0App(factory) {
+    return factory.createHandlers(describeRoute({
+        summary: "Aggregate sale statistics",
+        description: "",
+        tags: ["Fractions"],
+        responses: {
+            200: {
+                description: "",
+                content: {
+                    "application/json": {
+                        schema: resolver(FractionsSaleStatisticSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        chainId: TmiChainIdSchema,
+        platform: PlatformContractAddress,
+        campaignId: CampaignIdSchema,
+    })), async (c) => {
+        const { chainId, platform, campaignId } = c.req.valid("json");
+        const { fractions: { fractionsPurchases }, } = indexerSchemas;
+        const rows = await indexerClient.db
+            .select({
+            purchases: count(fractionsPurchases.transactionHash),
+            fractionsSold: sum(fractionsPurchases.amountOfFractions),
+            priceId: fractionsPurchases.priceId,
+        })
+            .from(fractionsPurchases)
+            .where(and(eq(fractionsPurchases.chainId, Number(chainId)), eq(fractionsPurchases.diamondAddress, platform), eq(fractionsPurchases.saleId, BigInt(campaignId))))
+            .groupBy(fractionsPurchases.priceId);
+        const statistics = rows.map((r) => ({
+            ...r,
+            fractionsSold: r.fractionsSold || "0",
+        }));
+        return c.json(FractionsSaleStatisticSchema.parse({
+            chainId: chainId,
+            platform: platform,
+            campaignId: campaignId,
+            statistics,
+        }), 200);
+    });
+}