@evergonlabs/tmi-protocol-api 0.4.0 → 0.5.0

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

@@ -0,0 +1,354 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { and, count, countDistinct, eq, sum } from "@ponder/client";
+import { z } from "../../common/zod.js";
+import { indexerSchemas } from "../../common/indexer/schemas.js";
+import { TmiChainIdSchema } from "../../common/index.js";
+const NetworkStatisticsRequestSchema = z.object({
+    chainId: TmiChainIdSchema.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.",
+    }),
+});
+/**
+ * Response schema for fraction holders count endpoint
+ * Keys can be 'total' or chain IDs (as strings), values are holder counts
+ */
+export const FractionHoldersCountSchema = z.record(z.union([z.literal("total"), z.string()]), z.number()).openapi({
+    ref: "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.",
+});
+/**
+ * Response schema for successful sales count endpoint
+ * Keys can be 'total' or chain IDs (as strings), values are sales counts
+ */
+export const SuccessfulSalesCountSchema = z.record(z.union([z.literal("total"), z.string()]), z.number()).openapi({
+    ref: "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.",
+});
+/**
+ * Response schema for TTV endpoint
+ * Keys can be 'total' or chain IDs (as strings), values are TTV amounts as strings (bigdecimal representation)
+ */
+export const TtvSchema = z.record(z.union([z.literal("total"), z.string()]), z.string()).openapi({
+    ref: "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.",
+});
+/**
+ * Per-chain statistics object schema
+ */
+const ChainStatisticsSchema = z.object({
+    holders: z.number().openapi({
+        description: "Number of unique fraction holders",
+    }),
+    sales: z.number().openapi({
+        description: "Number of successful (finalized) fraction sales",
+    }),
+    ttv: z.string().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
+ */
+export const NetworkStatisticsSchema = z
+    .record(z.union([z.literal("total"), z.string()]), ChainStatisticsSchema)
+    .openapi({
+    ref: "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.",
+});
+/**
+ * Fetches all statistics grouped by chain in parallel
+ */
+async function fetchPerChainStatistics(c, chainIdFilter) {
+    const { fractions: { fractionsPurchases, fractionsSales }, } = indexerSchemas;
+    const chainFilter = chainIdFilter ? eq(fractionsSales.chainId, chainIdFilter) : undefined;
+    const purchaseChainFilter = chainIdFilter ? eq(fractionsPurchases.chainId, chainIdFilter) : undefined;
+    const [holders, sales, ttv] = await Promise.all([
+        // Unique holders from finalized sales, grouped by chain
+        c
+            .get("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(and(purchaseChainFilter, eq(fractionsSales.status, "finalized")))
+            .groupBy(fractionsPurchases.chainId),
+        // Count of finalized sales, grouped by chain
+        c
+            .get("indexerClient")
+            .db.select({
+            chainId: fractionsSales.chainId,
+            sales: count(fractionsSales.saleId),
+        })
+            .from(fractionsSales)
+            .where(and(chainFilter, eq(fractionsSales.status, "finalized")))
+            .groupBy(fractionsSales.chainId),
+        // Sum of amountPaid from purchases of finalized sales, grouped by chain
+        c
+            .get("indexerClient")
+            .db.select({
+            chainId: fractionsPurchases.chainId,
+            ttv: sum(fractionsPurchases.amountPaid),
+        })
+            .from(fractionsPurchases)
+            .innerJoin(fractionsSales, and(eq(fractionsPurchases.chainId, fractionsSales.chainId), eq(fractionsPurchases.diamondAddress, fractionsSales.diamondAddress), eq(fractionsPurchases.saleId, fractionsSales.saleId)))
+            .where(and(purchaseChainFilter, eq(fractionsSales.status, "finalized")))
+            .groupBy(fractionsPurchases.chainId),
+    ]);
+    return { holders, sales, ttv };
+}
+/**
+ * Builds complete statistics response with total and per-chain breakdown
+ */
+function buildCompleteStatisticsResponse(stats) {
+    // Build per-chain statistics map
+    const chainStats = {};
+    // Collect all unique chain IDs
+    const allChainIds = new Set();
+    stats.holders.forEach((r) => allChainIds.add(r.chainId));
+    stats.sales.forEach((r) => allChainIds.add(r.chainId));
+    stats.ttv.forEach((r) => allChainIds.add(r.chainId));
+    // Initialize all chains with zeros
+    for (const cId of allChainIds) {
+        chainStats[cId.toString()] = {
+            holders: 0,
+            sales: 0,
+            ttv: "0",
+        };
+    }
+    // Populate holders
+    for (const result of stats.holders) {
+        const chainIdStr = result.chainId.toString();
+        if (chainStats[chainIdStr]) {
+            chainStats[chainIdStr].holders = result.holders ?? 0;
+        }
+    }
+    // Populate sales
+    for (const result of stats.sales) {
+        const chainIdStr = result.chainId.toString();
+        if (chainStats[chainIdStr]) {
+            chainStats[chainIdStr].sales = result.sales ?? 0;
+        }
+    }
+    // Populate TTV
+    for (const result of stats.ttv) {
+        const chainIdStr = result.chainId.toString();
+        if (chainStats[chainIdStr]) {
+            chainStats[chainIdStr].ttv = result.ttv ?? "0";
+        }
+    }
+    // Calculate totals
+    let totalHolders = 0;
+    let totalSales = 0;
+    let totalTtv = BigInt(0);
+    for (const chainStat of Object.values(chainStats)) {
+        totalHolders += chainStat.holders;
+        totalSales += chainStat.sales;
+        totalTtv += BigInt(chainStat.ttv);
+    }
+    // Build final response
+    return {
+        total: {
+            holders: totalHolders,
+            sales: totalSales,
+            ttv: totalTtv.toString(),
+        },
+        ...chainStats,
+    };
+}
+/**
+ * Get the number of unique fraction holders from successful (finalized) sales
+ */
+export function createFractionHoldersCountV0(factory) {
+    return factory.createHandlers(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(FractionHoldersCountSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", NetworkStatisticsRequestSchema), async (c) => {
+        const { chainId } = c.req.valid("json");
+        const stats = await fetchPerChainStatistics(c, chainId ? Number(chainId) : undefined);
+        if (chainId) {
+            // Return only the specific chain's data
+            const holdersResponse = {};
+            for (const result of stats.holders) {
+                if (result.chainId === Number(chainId)) {
+                    holdersResponse[result.chainId.toString()] = result.holders ?? 0;
+                }
+            }
+            return c.json(FractionHoldersCountSchema.parse(holdersResponse), 200);
+        }
+        else {
+            // Return total and all per-chain breakdowns
+            const response = buildCompleteStatisticsResponse(stats);
+            // Extract only holders data
+            const holdersResponse = { total: response.total.holders };
+            for (const [chain, data] of Object.entries(response)) {
+                if (chain !== "total") {
+                    holdersResponse[chain] = data.holders;
+                }
+            }
+            return c.json(FractionHoldersCountSchema.parse(holdersResponse), 200);
+        }
+    });
+}
+/**
+ * Get the number of successful (finalized) fraction sales
+ */
+export function createSuccessfulSalesCountV0(factory) {
+    return factory.createHandlers(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(SuccessfulSalesCountSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", NetworkStatisticsRequestSchema), async (c) => {
+        const { chainId } = c.req.valid("json");
+        const stats = await fetchPerChainStatistics(c, chainId ? Number(chainId) : undefined);
+        if (chainId) {
+            // Return only the specific chain's data
+            const salesResponse = {};
+            for (const result of stats.sales) {
+                if (result.chainId === Number(chainId)) {
+                    salesResponse[result.chainId.toString()] = result.sales ?? 0;
+                }
+            }
+            return c.json(SuccessfulSalesCountSchema.parse(salesResponse), 200);
+        }
+        else {
+            // Return total and all per-chain breakdowns
+            const response = buildCompleteStatisticsResponse(stats);
+            // Extract only sales data
+            const salesResponse = { total: response.total.sales };
+            for (const [chain, data] of Object.entries(response)) {
+                if (chain !== "total") {
+                    salesResponse[chain] = data.sales;
+                }
+            }
+            return c.json(SuccessfulSalesCountSchema.parse(salesResponse), 200);
+        }
+    });
+}
+/**
+ * Get the Total Tokenized Value (TTV) - sum of all amounts raised by successful sales in USDC
+ */
+export function createTtvV0(factory) {
+    return factory.createHandlers(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(TtvSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", NetworkStatisticsRequestSchema), async (c) => {
+        const { chainId } = c.req.valid("json");
+        const stats = await fetchPerChainStatistics(c, chainId ? Number(chainId) : undefined);
+        if (chainId) {
+            // Return only the specific chain's data
+            const ttvResponse = {};
+            for (const result of stats.ttv) {
+                if (result.chainId === Number(chainId)) {
+                    ttvResponse[result.chainId.toString()] = result.ttv ?? "0";
+                }
+            }
+            return c.json(TtvSchema.parse(ttvResponse), 200);
+        }
+        else {
+            // Return total and all per-chain breakdowns
+            const response = buildCompleteStatisticsResponse(stats);
+            // Extract only TTV data
+            const ttvResponse = { total: response.total.ttv };
+            for (const [chain, data] of Object.entries(response)) {
+                if (chain !== "total") {
+                    ttvResponse[chain] = data.ttv;
+                }
+            }
+            return c.json(TtvSchema.parse(ttvResponse), 200);
+        }
+    });
+}
+/**
+ * Get all network statistics in a single call
+ */
+export function createNetworkStatisticsV0(factory) {
+    return factory.createHandlers(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(NetworkStatisticsSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", NetworkStatisticsRequestSchema), async (c) => {
+        const { chainId } = c.req.valid("json");
+        const stats = await fetchPerChainStatistics(c, chainId ? Number(chainId) : undefined);
+        if (chainId) {
+            // Return only the specific chain's data
+            const chainIdNum = Number(chainId);
+            const chainIdStr = chainIdNum.toString();
+            let holders = 0;
+            let sales = 0;
+            let ttv = "0";
+            for (const result of stats.holders) {
+                if (result.chainId === chainIdNum) {
+                    holders = result.holders ?? 0;
+                }
+            }
+            for (const result of stats.sales) {
+                if (result.chainId === chainIdNum) {
+                    sales = result.sales ?? 0;
+                }
+            }
+            for (const result of stats.ttv) {
+                if (result.chainId === chainIdNum) {
+                    ttv = result.ttv ?? "0";
+                }
+            }
+            return c.json(NetworkStatisticsSchema.parse({
+                [chainIdStr]: {
+                    holders,
+                    sales,
+                    ttv,
+                },
+            }), 200);
+        }
+        else {
+            // Return total and all per-chain breakdowns
+            const response = buildCompleteStatisticsResponse(stats);
+            return c.json(NetworkStatisticsSchema.parse(response), 200);
+        }
+    });
+}

package/dist/v1/fractions/lending/buyback/buyback.routes.d.ts

@@ -0,0 +1,65 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createBuybackTransactionV0<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        address: `0x${string}`;
+        functionName: string;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+            market: `0x${string}`;
+            buybackPacketsAmount: bigint;
+        };
+    };
+    out: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+            market: `0x${string}`;
+            buybackPacketsAmount: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        address: `0x${string}`;
+        functionName: string;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+            market: `0x${string}`;
+            buybackPacketsAmount: bigint;
+        };
+    };
+    out: {
+        json: {
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            campaignId: bigint;
+            market: `0x${string}`;
+            buybackPacketsAmount: bigint;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        address: `0x${string}`;
+        functionName: string;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=buyback.routes.d.ts.map

package/dist/v1/fractions/lending/buyback/buyback.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buyback.routes.d.ts","sourceRoot":"","sources":["../../../../../src/v1/fractions/lending/buyback/buyback.routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAuBvC,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAQ5E"}

package/dist/v1/fractions/lending/buyback/buyback.routes.js

@@ -0,0 +1,27 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { toTransaction, TransactionSchema } from "../../../../common/index.js";
+import { buildBuybackTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { BuybackRequestSchema } from "./buyback.schema.js";
+const route = describeRoute({
+    summary: "Perform buyback of lending position",
+    description: "Returns transaction data for buying back the lending position with interest",
+    tags: ["Buy-back"],
+    responses: {
+        200: {
+            description: "Returns transaction data for buyback operation",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createBuybackTransactionV0(factory) {
+    return factory.createHandlers(route, validator("json", BuybackRequestSchema), async (c) => {
+        const { market, campaignId, buybackPacketsAmount } = c.req.valid("json");
+        const tx = buildBuybackTx(market, campaignId, buybackPacketsAmount);
+        return c.json(toTransaction(tx));
+    });
+}

package/dist/v1/fractions/lending/buyback/buyback.schema.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const BuybackRequestSchema: z.ZodObject<{
+    chainId: z.ZodType<import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId, z.ZodTypeDef, import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId>;
+    buybackPacketsAmount: z.ZodBigInt;
+} & {
+    market: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    campaignId: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    campaignId: bigint;
+    market: `0x${string}`;
+    buybackPacketsAmount: bigint;
+}, {
+    chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+    campaignId: bigint;
+    market: `0x${string}`;
+    buybackPacketsAmount: bigint;
+}>;
+//# sourceMappingURL=buyback.schema.d.ts.map

package/dist/v1/fractions/lending/buyback/buyback.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buyback.schema.d.ts","sourceRoot":"","sources":["../../../../../src/v1/fractions/lending/buyback/buyback.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;EAQU,CAAC"}

package/dist/v1/fractions/lending/buyback/buyback.schema.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { TmiChainIdSchema } from "../../../../common/index.js";
+import { SaleIdSchema } from "../../../../common/models/saleId.js";
+export const BuybackRequestSchema = z
+    .object({
+    chainId: TmiChainIdSchema,
+    buybackPacketsAmount: z.coerce.bigint().openapi({
+        description: "Amount of packets to buyback (with interest)",
+    }),
+})
+    .extend(SaleIdSchema.shape)
+    .openapi({ ref: "BuybackRequestSchema" });