@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

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);
+        }
+    }),
+});

package/dist/general/balanceClient.d.ts

@@ -1,75 +1,36 @@
 import { Address } from "viem";
-import { TmiChainId } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { z } from "zod";
+import type { IBalancesApiConfig } from "../common/config.js";
+import { IPolymorphicChainId } from "../common/index.js";
 import { TokenBalance } from "./utils/tokenBalance/tokenBalance.js";
-import { z } from "../common/zod.js";
 export declare const AccountBalancesResponse: z.ZodObject<{
     message: z.ZodString;
     status: z.ZodString;
-    result: z.ZodArray<z.ZodEffects<z.ZodObject<{
-        balance: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodString>;
-        contractAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-        decimals: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodNumber>, number, string | number | bigint>;
-        tokenId: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBigInt]>, z.ZodString>>;
+    result: z.ZodArray<z.ZodPipe<z.ZodObject<{
+        balance: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        contractAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        decimals: z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodTransform<number, number>>;
+        tokenId: z.ZodOptional<z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodTransform<string & z.core.$brand<"Int256">, number>>>;
         name: z.ZodString;
         symbol: z.ZodString;
-        type: z.ZodEffects<z.ZodString, import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null, string>;
-    }, "strip", z.ZodTypeAny, {
-        symbol: string;
-        type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
-        contractAddress: `0x${string}`;
-        name: string;
+        type: z.ZodPipe<z.ZodString, z.ZodTransform<import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null, string>>;
+    }, z.core.$strip>, z.ZodTransform<{
+        tokenAddress: `0x${string}`;
+        balance: string & z.core.$brand<"Int256">;
         decimals: number;
-        balance: string;
-        tokenId?: string | undefined;
-    }, {
-        symbol: string;
-        type: string;
-        contractAddress: `0x${string}`;
         name: string;
-        decimals: string | number | bigint;
-        balance: string | number | bigint;
-        tokenId?: string | number | bigint | undefined;
-    }>, {
-        tokenAddress: `0x${string}`;
         symbol: string;
         type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
-        name: string;
-        decimals: number;
-        balance: string;
-        tokenId?: string | undefined;
+        tokenId?: (string & z.core.$brand<"Int256">) | undefined;
     }, {
-        symbol: string;
-        type: string;
+        balance: string & z.core.$brand<"Int256">;
         contractAddress: `0x${string}`;
+        decimals: number;
         name: string;
-        decimals: string | number | bigint;
-        balance: string | number | bigint;
-        tokenId?: string | number | bigint | undefined;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-    status: string;
-    result: {
-        tokenAddress: `0x${string}`;
         symbol: string;
         type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
-        name: string;
-        decimals: number;
-        balance: string;
-        tokenId?: string | undefined;
-    }[];
-}, {
-    message: string;
-    status: string;
-    result: {
-        symbol: string;
-        type: string;
-        contractAddress: `0x${string}`;
-        name: string;
-        decimals: string | number | bigint;
-        balance: string | number | bigint;
-        tokenId?: string | number | bigint | undefined;
-    }[];
-}>;
-export declare function getAccountBalances(wallet: Address, chainId: TmiChainId): Promise<z.infer<typeof TokenBalance>[]>;
+        tokenId?: (string & z.core.$brand<"Int256">) | undefined;
+    }>>>;
+}, z.core.$strip>;
+export declare function getAccountBalances(wallet: Address, chainId: IPolymorphicChainId, config: IBalancesApiConfig): Promise<z.infer<typeof TokenBalance>[]>;
 //# sourceMappingURL=balanceClient.d.ts.map

package/dist/general/balanceClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"balanceClient.d.ts","sourceRoot":"","sources":["../../src/general/balanceClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAErE,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AACpE,OAAO,EAAE,CAAC,EAAE,MAAM,kBAAkB,CAAC;AAErC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIlC,CAAC;AAEH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,EAAE,CAAC,CA2BzC"}
+{"version":3,"file":"balanceClient.d.ts","sourceRoot":"","sources":["../../src/general/balanceClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AAEpE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAC;AAEH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,EAAE,CAAC,CA2BzC"}

package/dist/general/balanceClient.js

@@ -1,14 +1,14 @@
 import axios from "axios";
+import { z } from "zod";
 import { getBalancesApi } from "../common/blockchain.js";
 import { TokenBalance } from "./utils/tokenBalance/tokenBalance.js";
-import { z } from "../common/zod.js";
 export const AccountBalancesResponse = z.object({
     message: z.string(),
     status: z.string(),
     result: z.array(TokenBalance),
 });
-export async function getAccountBalances(wallet, chainId) {
-    const url = getBalancesApi(chainId);
+export async function getAccountBalances(wallet, chainId, config) {
+    const url = getBalancesApi(chainId, config);
     try {
         const result = await axios.get(url, {
             params: {

package/dist/general/common.d.ts

@@ -1,94 +1,31 @@
-import { z } from "zod";
 import { Core } from "@quicknode/sdk";
-import { TmiChainId } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { z } from "zod";
+import type { IBalancesRpcConfig } from "../common/config.js";
+import { IPolymorphicChainId } from "../common/index.js";
 export declare const TokenBalanceSchema: z.ZodObject<{
-    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     totalBalance: z.ZodString;
-    tokenId: z.ZodOptional<z.ZodBigInt>;
+    tokenId: z.ZodOptional<z.ZodString>;
     name: z.ZodNullable<z.ZodString>;
     symbol: z.ZodNullable<z.ZodString>;
     decimals: z.ZodNullable<z.ZodString>;
     quantityIn: z.ZodString;
     quantityOut: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    symbol: string | null;
-    address: `0x${string}`;
-    name: string | null;
-    decimals: string | null;
-    totalBalance: string;
-    quantityIn: string;
-    quantityOut: string;
-    tokenId?: bigint | undefined;
-}, {
-    symbol: string | null;
-    address: `0x${string}`;
-    name: string | null;
-    decimals: string | null;
-    totalBalance: string;
-    quantityIn: string;
-    quantityOut: string;
-    tokenId?: bigint | undefined;
-}>;
+}, z.core.$strip>;
 export declare const BalancesResponseSchema: z.ZodObject<{
     balances: z.ZodArray<z.ZodObject<{
-        address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+        address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
         totalBalance: z.ZodString;
-        tokenId: z.ZodOptional<z.ZodBigInt>;
+        tokenId: z.ZodOptional<z.ZodString>;
         name: z.ZodNullable<z.ZodString>;
         symbol: z.ZodNullable<z.ZodString>;
         decimals: z.ZodNullable<z.ZodString>;
         quantityIn: z.ZodString;
         quantityOut: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        symbol: string | null;
-        address: `0x${string}`;
-        name: string | null;
-        decimals: string | null;
-        totalBalance: string;
-        quantityIn: string;
-        quantityOut: string;
-        tokenId?: bigint | undefined;
-    }, {
-        symbol: string | null;
-        address: `0x${string}`;
-        name: string | null;
-        decimals: string | null;
-        totalBalance: string;
-        quantityIn: string;
-        quantityOut: string;
-        tokenId?: bigint | undefined;
-    }>, "many">;
+    }, z.core.$strip>>;
     totalItems: z.ZodNumber;
     totalPages: z.ZodNumber;
     pageNumber: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    balances: {
-        symbol: string | null;
-        address: `0x${string}`;
-        name: string | null;
-        decimals: string | null;
-        totalBalance: string;
-        quantityIn: string;
-        quantityOut: string;
-        tokenId?: bigint | undefined;
-    }[];
-    totalItems: number;
-    totalPages: number;
-    pageNumber: number;
-}, {
-    balances: {
-        symbol: string | null;
-        address: `0x${string}`;
-        name: string | null;
-        decimals: string | null;
-        totalBalance: string;
-        quantityIn: string;
-        quantityOut: string;
-        tokenId?: bigint | undefined;
-    }[];
-    totalItems: number;
-    totalPages: number;
-    pageNumber: number;
-}>;
-export declare function getQuicknode(chainId: TmiChainId): Core;
+}, z.core.$strip>;
+export declare function getQuicknode(chainId: IPolymorphicChainId, config: IBalancesRpcConfig): Core;
 //# sourceMappingURL=common.d.ts.map

package/dist/general/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/general/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAGtC,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAErE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa3B,CAAC;AAEL,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS/B,CAAC;AAEL,wBAAgB,YAAY,CAAC,OAAO,EAAE,UAAU,QAM/C"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/general/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAiB,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAExE,eAAO,MAAM,kBAAkB;;;;;;;;;iBAWC,CAAC;AAEjC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;iBAOC,CAAC;AAErC,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,EAAE,MAAM,EAAE,kBAAkB,QAMpF"}

package/dist/general/common.js

@@ -1,21 +1,19 @@
-import { z } from "zod";
 import { Core } from "@quicknode/sdk";
-import { AddressSchema } from "../common/index.js";
+import { z } from "zod";
 import { getBalancesRpc } from "../common/blockchain.js";
+import { AddressSchema } from "../common/index.js";
 export const TokenBalanceSchema = z
     .object({
     address: AddressSchema,
     totalBalance: z.string(),
-    tokenId: z.bigint().optional(),
+    tokenId: z.string().optional(),
     name: z.string().nullable(),
     symbol: z.string().nullable(),
     decimals: z.string().nullable(),
     quantityIn: z.string(),
     quantityOut: z.string(),
 })
-    .openapi({
-    ref: "TokenBalanceSchema",
-});
+    .openapi("TokenBalanceSchema");
 export const BalancesResponseSchema = z
     .object({
     balances: z.array(TokenBalanceSchema),
@@ -23,11 +21,9 @@ export const BalancesResponseSchema = z
     totalPages: z.number(),
     pageNumber: z.number(),
 })
-    .openapi({
-    ref: "BalancesResponseSchema",
-});
-export function getQuicknode(chainId) {
-    const rpc = getBalancesRpc(chainId);
+    .openapi("BalancesResponseSchema");
+export function getQuicknode(chainId, config) {
+    const rpc = getBalancesRpc(chainId, config);
     return new Core({
         endpointUrl: rpc,
         config: { addOns: { nftTokenV2: true } },