@evergonlabs/tmi-protocol-api 0.4.1 → 0.7.0

package/dist/fractions/sig/getAuthData.js

@@ -0,0 +1,52 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { encodePacked, keccak256, padHex, toHex } from "viem";
+import { z } from "zod";
+import { HexStringSchema } from "@evergonlabs/tmi-utils/models";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, FractionsChainId } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
+/**
+ * functionCallData: functionCallData as `0x${string}`,
+ *     contractAddress: diamondAddress_ as string,
+ *     userAddress: creator_.address as string,
+ *     chainID: chainID_,
+ *     nonce: Number(nonce_),
+ *     blockExpiration: blockExpiration_,
+ */
+export const TxAuthDataRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    userAddress: AddressSchema,
+    chainId: FractionsChainId,
+    nonce: Int256BigInt(),
+    blockExpiration: Int256BigInt(),
+    callData: HexStringSchema,
+});
+const route = describeRoute({
+    summary: "Get TX auth data",
+    description: "Returns TX auth data ",
+    tags: ["Signatures"],
+    responses: {
+        200: {
+            description: "Returns TX auth data",
+            content: {
+                "application/json": {
+                    schema: resolver(TxAuthDataRequestSchema),
+                },
+            },
+        },
+    },
+});
+export const GetAuthDataV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", TxAuthDataRequestSchema.openapi("TxAuthDataRequestSchema")), async (c) => {
+        const { marketAddress, userAddress, chainId, blockExpiration, callData, nonce } = c.req.valid("json");
+        const blockExpirationAbi = padHex(toHex(blockExpiration), { size: 32 });
+        const message = keccak256(encodePacked(["uint256", "uint256", "uint256", "address", "address", "bytes"], [BigInt(chainId), BigInt(nonce), BigInt(blockExpiration), marketAddress, userAddress, callData]));
+        return c.json({
+            messageToSign: message,
+            blockExpiration: blockExpirationAbi,
+        });
+    }),
+});

package/dist/fractions/sig/getNonce.route.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const NonceRequestSchema: z.ZodObject<{
+    marketAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    userAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<1 | 11155111 | 31337 | 72080>, z.ZodLiteral<1 | 11155111 | 31337 | 72080>, ...z.ZodLiteral<1 | 11155111 | 31337 | 72080>[]]>>;
+}, z.core.$strip>;
+export declare const GetNonceV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    marketAddress: string;
+                    userAddress: string;
+                    chainId: unknown;
+                };
+            };
+            output: {
+                nonce: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=getNonce.route.d.ts.map

package/dist/fractions/sig/getNonce.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNonce.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/sig/getNonce.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AAkBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;QAiBrB,CAAC"}

package/dist/fractions/sig/getNonce.route.js

@@ -0,0 +1,43 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { ABIS } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { getPublicClient } from "../../common/blockchain.js";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, FractionsChainId } from "../../common/index.js";
+export const NonceRequestSchema = z.object({
+    marketAddress: AddressSchema,
+    userAddress: AddressSchema,
+    chainId: FractionsChainId,
+});
+const route = describeRoute({
+    summary: "Get a nonce",
+    description: "Returns transaction data for approving a sale",
+    tags: ["Signatures"],
+    responses: {
+        200: {
+            description: "Returns transaction data for approving a sale",
+            content: {
+                "application/json": {
+                    schema: resolver(NonceRequestSchema),
+                },
+            },
+        },
+    },
+});
+export const GetNonceV0 = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", route, validator("json", NonceRequestSchema.openapi("NonceRequestSchema")), async (c) => {
+        const { marketAddress, userAddress, chainId } = c.req.valid("json");
+        const nonce = await getPublicClient(chainId).readContract({
+            address: marketAddress,
+            abi: ABIS.createFractionsAbi.nid,
+            functionName: "txAuthDataUserNonce",
+            args: [userAddress],
+        });
+        return c.json({
+            nonce: nonce.toString(),
+        });
+    }),
+});

package/dist/fractions/sig/index.d.ts

@@ -0,0 +1,40 @@
+export declare const SigController: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    marketAddress: string;
+                    userAddress: string;
+                    chainId: unknown;
+                };
+            };
+            output: {
+                nonce: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/nonce"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    marketAddress: string;
+                    userAddress: string;
+                    chainId: unknown;
+                    nonce: string;
+                    blockExpiration: string;
+                    callData: string;
+                };
+            };
+            output: {
+                messageToSign: `0x${string}`;
+                blockExpiration: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/authData">, "/">>;
+//# sourceMappingURL=index.d.ts.map

package/dist/fractions/sig/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fractions/sig/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAGxB,CAAC"}

package/dist/fractions/sig/index.js

@@ -0,0 +1,6 @@
+import { createController } from "../../common/controller.js";
+import { GetAuthDataV0 } from "./getAuthData.js";
+import { GetNonceV0 } from "./getNonce.route.js";
+export const SigController = createController({
+    build: (factory) => factory.createApp().route("/nonce", GetNonceV0.build(factory)).route("/authData", GetAuthDataV0.build(factory)),
+});

package/dist/fractions/statistics/index.d.ts

@@ -0,0 +1,107 @@
+export declare const StatisticsController: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId?: unknown;
+                };
+            };
+            output: {
+                [x: number]: string & import("zod").$brand<"Int256">;
+                total: string & import("zod").$brand<"Int256">;
+            } | {
+                total: string & import("zod").$brand<"Int256">;
+                1: string & import("zod").$brand<"Int256">;
+                11155111: string & import("zod").$brand<"Int256">;
+                31337: string & import("zod").$brand<"Int256">;
+                72080: string & import("zod").$brand<"Int256">;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/holders"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId?: unknown;
+                };
+            };
+            output: {
+                [x: number]: string & import("zod").$brand<"Int256">;
+                total: string & import("zod").$brand<"Int256">;
+            } | {
+                total: string & import("zod").$brand<"Int256">;
+                1: string & import("zod").$brand<"Int256">;
+                11155111: string & import("zod").$brand<"Int256">;
+                31337: string & import("zod").$brand<"Int256">;
+                72080: string & import("zod").$brand<"Int256">;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/sales"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId?: unknown;
+                };
+            };
+            output: {
+                [x: number]: string & import("zod").$brand<"Int256">;
+                total: string & import("zod").$brand<"Int256">;
+            } | {
+                total: string & import("zod").$brand<"Int256">;
+                1: string & import("zod").$brand<"Int256">;
+                11155111: string & import("zod").$brand<"Int256">;
+                31337: string & import("zod").$brand<"Int256">;
+                72080: string & import("zod").$brand<"Int256">;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/ttv"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId?: unknown;
+                };
+            };
+            output: {
+                total: {
+                    holders: string & import("zod").$brand<"Int256">;
+                    sales: string & import("zod").$brand<"Int256">;
+                    ttv: string & import("zod").$brand<"Int256">;
+                };
+                1: {
+                    holders: string & import("zod").$brand<"Int256">;
+                    sales: string & import("zod").$brand<"Int256">;
+                    ttv: string & import("zod").$brand<"Int256">;
+                };
+                11155111: {
+                    holders: string & import("zod").$brand<"Int256">;
+                    sales: string & import("zod").$brand<"Int256">;
+                    ttv: string & import("zod").$brand<"Int256">;
+                };
+                31337: {
+                    holders: string & import("zod").$brand<"Int256">;
+                    sales: string & import("zod").$brand<"Int256">;
+                    ttv: string & import("zod").$brand<"Int256">;
+                };
+                72080: {
+                    holders: string & import("zod").$brand<"Int256">;
+                    sales: string & import("zod").$brand<"Int256">;
+                    ttv: string & import("zod").$brand<"Int256">;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">, "/">>;
+//# sourceMappingURL=index.d.ts.map

package/dist/fractions/statistics/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fractions/statistics/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAQ/B,CAAC"}

package/dist/fractions/statistics/index.js

@@ -0,0 +1,10 @@
+import { createController } from "../../common/controller.js";
+import { GetHoldersV0, GetNetworkStatisticsV0, GetSalesStatisticsV0, GetTtvV0 } from "./networkStatistics.route.js";
+export const StatisticsController = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/holders", GetHoldersV0.build(factory))
+        .route("/sales", GetSalesStatisticsV0.build(factory))
+        .route("/ttv", GetTtvV0.build(factory))
+        .route("/", GetNetworkStatisticsV0.build(factory)),
+});

package/dist/fractions/statistics/networkStatistics.route.d.ts

@@ -0,0 +1,121 @@
+import { z } from "zod";
+import { AppContext } from "../../common/context.js";
+/**
+ * Get the number of unique fraction holders from successful (finalized) sales
+ */
+export declare const GetHoldersV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId?: unknown;
+                };
+            };
+            output: {
+                [x: number]: string & z.core.$brand<"Int256">;
+                total: string & z.core.$brand<"Int256">;
+            } | {
+                total: string & z.core.$brand<"Int256">;
+                1: string & z.core.$brand<"Int256">;
+                11155111: string & z.core.$brand<"Int256">;
+                31337: string & z.core.$brand<"Int256">;
+                72080: string & z.core.$brand<"Int256">;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+/**
+ * Get the number of successful (finalized) fraction sales
+ */
+export declare const GetSalesStatisticsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId?: unknown;
+                };
+            };
+            output: {
+                [x: number]: string & z.core.$brand<"Int256">;
+                total: string & z.core.$brand<"Int256">;
+            } | {
+                total: string & z.core.$brand<"Int256">;
+                1: string & z.core.$brand<"Int256">;
+                11155111: string & z.core.$brand<"Int256">;
+                31337: string & z.core.$brand<"Int256">;
+                72080: string & z.core.$brand<"Int256">;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+/**
+ * Get the Total Tokenized Value (TTV) - sum of all amounts raised by successful sales in USDC
+ */
+export declare const GetTtvV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId?: unknown;
+                };
+            };
+            output: {
+                [x: number]: string & z.core.$brand<"Int256">;
+                total: string & z.core.$brand<"Int256">;
+            } | {
+                total: string & z.core.$brand<"Int256">;
+                1: string & z.core.$brand<"Int256">;
+                11155111: string & z.core.$brand<"Int256">;
+                31337: string & z.core.$brand<"Int256">;
+                72080: string & z.core.$brand<"Int256">;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+export declare const GetNetworkStatisticsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId?: unknown;
+                };
+            };
+            output: {
+                total: {
+                    holders: string & z.core.$brand<"Int256">;
+                    sales: string & z.core.$brand<"Int256">;
+                    ttv: string & z.core.$brand<"Int256">;
+                };
+                1: {
+                    holders: string & z.core.$brand<"Int256">;
+                    sales: string & z.core.$brand<"Int256">;
+                    ttv: string & z.core.$brand<"Int256">;
+                };
+                11155111: {
+                    holders: string & z.core.$brand<"Int256">;
+                    sales: string & z.core.$brand<"Int256">;
+                    ttv: string & z.core.$brand<"Int256">;
+                };
+                31337: {
+                    holders: string & z.core.$brand<"Int256">;
+                    sales: string & z.core.$brand<"Int256">;
+                    ttv: string & z.core.$brand<"Int256">;
+                };
+                72080: {
+                    holders: string & z.core.$brand<"Int256">;
+                    sales: string & z.core.$brand<"Int256">;
+                    ttv: string & z.core.$brand<"Int256">;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=networkStatistics.route.d.ts.map

package/dist/fractions/statistics/networkStatistics.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkStatistics.route.d.ts","sourceRoot":"","sources":["../../../src/fractions/statistics/networkStatistics.route.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAuIrD;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;QA8BvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;QA8B/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;QA8BnB,CAAC;AA2BH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkCjC,CAAC"}

package/dist/fractions/statistics/networkStatistics.route.js

@@ -0,0 +1,222 @@
+import { and, count, countDistinct, eq, sum } from "@ponder/client";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { FractionsChains } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
+import { createController } from "../../common/controller.js";
+import { FractionsChainId } from "../../common/index.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+const FractionsStatsRequestSchema = z.object({
+    chainId: FractionsChainId.optional().openapi({
+        description: `Optional chain ID to filter statistics by specific chain. If provided, returns only that chain's data. If not provided, returns total and all per-chain breakdowns.`,
+    }),
+});
+const FractionStatsByChain = z.intersection(z.object({ total: Int256Json }), z.partialRecord(FractionsChainId, Int256Json));
+const FractionChainStats = z.object({
+    holders: Int256Json.openapi({
+        description: "Number of unique fraction holders",
+    }),
+    sales: Int256Json.openapi({
+        description: "Number of successful (finalized) fraction sales",
+    }),
+    ttv: Int256Json.openapi({
+        description: "Total Tokenized Value as string representation of bigdecimal in USDC (raw units)",
+    }),
+});
+/**
+ * Combined network statistics response schema
+ * Keys can be 'total' or chain IDs (as strings), values are statistics objects
+ */
+const FractionsStatsAllSchema = z
+    .intersection(z.object({ total: FractionChainStats }), z.record(FractionsChainId, FractionChainStats))
+    .openapi("NetworkStatistics", {
+    description: `Contains 'total' (when chainId not specified) aggregated statistics and per-chain breakdowns (chain IDs as string keys). When chainId is specified, only that chain's data is returned.`,
+});
+async function fetchPerChainStatistics(c, chainIdFilter) {
+    const { fractionsPurchases, fractionsSales } = indexerSchemas.fractions;
+    const chainFilter = chainIdFilter ? eq(fractionsSales.chainId, chainIdFilter) : undefined;
+    const purchaseChainFilter = chainIdFilter ? eq(fractionsPurchases.chainId, chainIdFilter) : undefined;
+    const indexerClient = c.get("indexerClient");
+    const [holders, sales, ttv] = await Promise.all([
+        // Unique holders from finalized sales, grouped by chain
+        indexerClient.db
+            .select({
+            chainId: fractionsPurchases.chainId,
+            holders: countDistinct(fractionsPurchases.buyerAddress),
+        })
+            .from(fractionsPurchases)
+            .innerJoin(fractionsSales, and(eq(fractionsPurchases.chainId, fractionsSales.chainId), eq(fractionsPurchases.diamondAddress, fractionsSales.diamondAddress), eq(fractionsPurchases.saleId, fractionsSales.saleId)))
+            .where(chainFilter)
+            .groupBy(fractionsPurchases.chainId),
+        // Count of finalized sales, grouped by chain
+        indexerClient.db
+            .select({
+            chainId: fractionsSales.chainId,
+            sales: count(fractionsSales.saleId),
+        })
+            .from(fractionsSales)
+            .where(chainFilter)
+            .groupBy(fractionsSales.chainId),
+        // Sum of amountPaid from purchases of finalized sales, grouped by chain
+        indexerClient.db
+            .select({
+            chainId: fractionsPurchases.chainId,
+            ttv: sum(fractionsPurchases.usdValue),
+        })
+            .from(fractionsPurchases)
+            .innerJoin(fractionsSales, and(eq(fractionsPurchases.chainId, fractionsSales.chainId), eq(fractionsPurchases.diamondAddress, fractionsSales.diamondAddress), eq(fractionsPurchases.saleId, fractionsSales.saleId)))
+            .where(purchaseChainFilter)
+            .groupBy(fractionsPurchases.chainId),
+    ]);
+    const val = FractionsChains.chainIds.reduce((prev, curr) => {
+        const holdersByChain = holders.find((x) => x.chainId === curr);
+        const salesByChain = sales.find((x) => x.chainId === curr);
+        const ttvByChain = ttv.find((x) => x.chainId === curr);
+        return {
+            ...prev,
+            [curr]: {
+                holders: toInt256Json(holdersByChain ? holdersByChain.holders : 0),
+                sales: toInt256Json(salesByChain ? salesByChain.sales : 0),
+                ttv: toInt256Json(ttvByChain?.ttv ? ttvByChain.ttv : 0),
+            },
+        };
+    }, {});
+    return {
+        ...val,
+        total: FractionsChains.chainIds.reduce((prev, curr) => ({
+            holders: toInt256Json(BigInt(prev.holders) + BigInt(val[curr].holders)),
+            sales: toInt256Json(BigInt(prev.sales) + BigInt(val[curr].sales)),
+            ttv: toInt256Json(BigInt(prev.ttv) + BigInt(val[curr].ttv)),
+        }), {
+            holders: toInt256Json(0),
+            sales: toInt256Json(0),
+            ttv: toInt256Json(0),
+        }),
+    };
+}
+/**
+ * Get the number of unique fraction holders from successful (finalized) sales
+ */
+export const GetHoldersV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Get number of fraction holders",
+        description: `Returns the count of unique wallet addresses that hold fractions from successful (finalized) sales. If chainId is provided, returns only that chain's data. Otherwise, returns total and all per-chain breakdowns. Used for RWA aggregator integrations.`,
+        tags: ["RWA Statistics"],
+        responses: {
+            200: {
+                description: "Number of unique fraction holders",
+                content: {
+                    "application/json": {
+                        schema: resolver(FractionStatsByChain.openapi("FractionHoldersCount", {
+                            description: `Contains 'total' (when chainId not specified) and per-chain holder counts (chain IDs as string keys). When chainId is specified, only that chain's data is returned.`,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("json", FractionsStatsRequestSchema), async (c) => {
+        const { chainId } = c.req.valid("json");
+        const stats = await fetchPerChainStatistics(c, chainId);
+        return c.json(getSingleStats(stats, "holders", chainId));
+    }),
+});
+/**
+ * Get the number of successful (finalized) fraction sales
+ */
+export const GetSalesStatisticsV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Get number of successful sales",
+        description: `Returns the count of successful (finalized) fraction sales representing RWA tokens. If chainId is provided, returns only that chain's data. Otherwise, returns total and all per-chain breakdowns. Used for RWA aggregator integrations.`,
+        tags: ["RWA Statistics"],
+        responses: {
+            200: {
+                description: "Number of successful fraction sales",
+                content: {
+                    "application/json": {
+                        schema: resolver(FractionStatsByChain.openapi("SuccessfulSalesCount", {
+                            description: `Contains 'total' (when chainId not specified) and per-chain sales counts (chain IDs as string keys). When chainId is specified, only that chain's data is returned.`,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("json", FractionsStatsRequestSchema), async (c) => {
+        const { chainId } = c.req.valid("json");
+        const stats = await fetchPerChainStatistics(c, chainId);
+        return c.json(getSingleStats(stats, "sales", chainId));
+    }),
+});
+/**
+ * Get the Total Tokenized Value (TTV) - sum of all amounts raised by successful sales in USDC
+ */
+export const GetTtvV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Get Total Tokenized Value (TTV)",
+        description: `Returns the Total Tokenized Value - the sum of all amounts raised by successful (finalized) sales in USDC. If chainId is provided, returns only that chain's data. Otherwise, returns total and all per-chain breakdowns. Used for RWA aggregator integrations.`,
+        tags: ["RWA Statistics"],
+        responses: {
+            200: {
+                description: "Total Tokenized Value in USDC",
+                content: {
+                    "application/json": {
+                        schema: resolver(FractionStatsByChain.openapi("TotalTokenizedValue", {
+                            description: `Contains 'total' (when chainId not specified) and per-chain TTV values as string representations of bigdecimal (chain IDs as string keys). When chainId is specified, only that chain's data is returned.`,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("json", FractionsStatsRequestSchema), async (c) => {
+        const { chainId } = c.req.valid("json");
+        const stats = await fetchPerChainStatistics(c, chainId);
+        return c.json(getSingleStats(stats, "ttv", chainId));
+    }),
+});
+function getSingleStats(stats, key, chainId) {
+    if (chainId) {
+        const statsByChain = stats[chainId];
+        return {
+            [chainId]: statsByChain[key],
+            total: stats.total[key],
+        };
+    }
+    else {
+        return {
+            ...FractionsChains.chainIds.reduce((prev, curr) => ({
+                ...prev,
+                [curr]: stats[curr][key],
+            }), {}),
+            total: stats.total[key],
+        };
+    }
+}
+export const GetNetworkStatisticsV0 = createController({
+    build: (factory) => factory.createApp().post("/", describeRoute({
+        summary: "Get all network statistics",
+        description: `Returns all network statistics in a single call: number of fraction holders, successful sales count, and TTV. If chainId is provided, returns only that chain's data. Otherwise, returns total and all per-chain breakdowns. Used for RWA aggregator integrations like RWA.XYZ.`,
+        tags: ["RWA Statistics"],
+        responses: {
+            200: {
+                description: "Network statistics including holders, sales, and TTV",
+                content: {
+                    "application/json": {
+                        schema: resolver(FractionsStatsAllSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", FractionsStatsRequestSchema), async (c) => {
+        const { chainId } = c.req.valid("json");
+        const stats = await fetchPerChainStatistics(c, chainId);
+        if (chainId) {
+            return c.json({
+                total: stats.total,
+                [chainId]: stats[chainId],
+            });
+        }
+        else {
+            return c.json(stats);
+        }
+    }),
+});