@evergonlabs/tmi-protocol-api 0.11.0-rc.3 → 0.11.0

package/dist/fractions/statistics/{networkStatistics.route.d.ts → networkStatistics.d.ts}

@@ -5,9 +5,9 @@ import { AppContext } from "../../common/context.js";
  */
 export declare const GetHoldersV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
                 };
             };
@@ -32,9 +32,9 @@ export declare const GetHoldersV0: import("../../common/controller.js").IControl
  */
 export declare const GetSalesStatisticsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
                 };
             };
@@ -59,9 +59,9 @@ export declare const GetSalesStatisticsV0: import("../../common/controller.js").
  */
 export declare const GetTtvV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
                 };
             };
@@ -83,42 +83,42 @@ export declare const GetTtvV0: import("../../common/controller.js").IController<
 }, "/", "/">>;
 export declare const GetNetworkStatisticsV0: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId?: "1" | "31337" | "11155111" | "84532" | "72080" | undefined;
                 };
             };
             output: {
                 total: {
-                    holders: string & z.core.$brand<"Int256">;
-                    sales: string & z.core.$brand<"Int256">;
-                    ttv: string & z.core.$brand<"Int256">;
+                    holders: string;
+                    sales: string;
+                    ttv: string;
                 };
                 1: {
-                    holders: string & z.core.$brand<"Int256">;
-                    sales: string & z.core.$brand<"Int256">;
-                    ttv: string & z.core.$brand<"Int256">;
+                    holders: string;
+                    sales: string;
+                    ttv: string;
                 };
                 31337: {
-                    holders: string & z.core.$brand<"Int256">;
-                    sales: string & z.core.$brand<"Int256">;
-                    ttv: string & z.core.$brand<"Int256">;
+                    holders: string;
+                    sales: string;
+                    ttv: string;
                 };
                 11155111: {
-                    holders: string & z.core.$brand<"Int256">;
-                    sales: string & z.core.$brand<"Int256">;
-                    ttv: string & z.core.$brand<"Int256">;
+                    holders: string;
+                    sales: string;
+                    ttv: string;
                 };
                 84532: {
-                    holders: string & z.core.$brand<"Int256">;
-                    sales: string & z.core.$brand<"Int256">;
-                    ttv: string & z.core.$brand<"Int256">;
+                    holders: string;
+                    sales: string;
+                    ttv: string;
                 };
                 72080: {
-                    holders: string & z.core.$brand<"Int256">;
-                    sales: string & z.core.$brand<"Int256">;
-                    ttv: string & z.core.$brand<"Int256">;
+                    holders: string;
+                    sales: string;
+                    ttv: string;
                 };
             };
             outputFormat: "json";
@@ -126,4 +126,4 @@ export declare const GetNetworkStatisticsV0: import("../../common/controller.js"
         };
     };
 }, "/", "/">>;
-//# sourceMappingURL=networkStatistics.route.d.ts.map
+//# sourceMappingURL=networkStatistics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"networkStatistics.d.ts","sourceRoot":"","sources":["../../../src/fractions/statistics/networkStatistics.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAGxD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAuIjD;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;aA8BvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;aA8B/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;aA8BnB,CAAC;AA2BH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkCjC,CAAC"}

package/dist/fractions/statistics/{networkStatistics.route.js → networkStatistics.js}

@@ -7,7 +7,7 @@ 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({
+const FractionsStatsRequest = 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.`,
     }),
@@ -99,7 +99,7 @@ async function fetchPerChainStatistics(c, chainIdFilter) {
  * Get the number of unique fraction holders from successful (finalized) sales
  */
 export const GetHoldersV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+    build: (factory) => factory.createApp().get("/", 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: ["Statistics"],
@@ -115,8 +115,8 @@ export const GetHoldersV0 = createController({
                 },
             },
         },
-    }), validator("json", FractionsStatsRequestSchema), async (c) => {
-        const { chainId } = c.req.valid("json");
+    }), validator("query", FractionsStatsRequest), async (c) => {
+        const { chainId } = c.req.valid("query");
         const stats = await fetchPerChainStatistics(c, chainId);
         return c.json(getSingleStats(stats, "holders", chainId));
     }),
@@ -125,7 +125,7 @@ export const GetHoldersV0 = createController({
  * Get the number of successful (finalized) fraction sales
  */
 export const GetSalesStatisticsV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+    build: (factory) => factory.createApp().get("/", 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: ["Statistics"],
@@ -141,8 +141,8 @@ export const GetSalesStatisticsV0 = createController({
                 },
             },
         },
-    }), validator("json", FractionsStatsRequestSchema), async (c) => {
-        const { chainId } = c.req.valid("json");
+    }), validator("query", FractionsStatsRequest), async (c) => {
+        const { chainId } = c.req.valid("query");
         const stats = await fetchPerChainStatistics(c, chainId);
         return c.json(getSingleStats(stats, "sales", chainId));
     }),
@@ -151,7 +151,7 @@ export const GetSalesStatisticsV0 = createController({
  * 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({
+    build: (factory) => factory.createApp().get("/", 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: ["Statistics"],
@@ -167,8 +167,8 @@ export const GetTtvV0 = createController({
                 },
             },
         },
-    }), validator("json", FractionsStatsRequestSchema), async (c) => {
-        const { chainId } = c.req.valid("json");
+    }), validator("query", FractionsStatsRequest), async (c) => {
+        const { chainId } = c.req.valid("query");
         const stats = await fetchPerChainStatistics(c, chainId);
         return c.json(getSingleStats(stats, "ttv", chainId));
     }),
@@ -192,7 +192,7 @@ function getSingleStats(stats, key, chainId) {
     }
 }
 export const GetNetworkStatisticsV0 = createController({
-    build: (factory) => factory.createApp().post("/", describeRoute({
+    build: (factory) => factory.createApp().get("/", 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: ["Statistics"],
@@ -206,8 +206,8 @@ export const GetNetworkStatisticsV0 = createController({
                 },
             },
         },
-    }), validator("json", FractionsStatsRequestSchema), async (c) => {
-        const { chainId } = c.req.valid("json");
+    }), validator("query", FractionsStatsRequest), async (c) => {
+        const { chainId } = c.req.valid("query");
         const stats = await fetchPerChainStatistics(c, chainId);
         if (chainId) {
             return c.json({

package/dist/general/common.d.ts

@@ -12,7 +12,7 @@ export declare const TokenBalanceSchema: z.ZodObject<{
     quantityIn: z.ZodString;
     quantityOut: z.ZodString;
 }, z.core.$strip>;
-export declare const BalancesResponseSchema: z.ZodObject<{
+export declare const BalancesResponse: z.ZodObject<{
     balances: z.ZodArray<z.ZodObject<{
         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;

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,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAExD,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"}
+{"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,qCAAqC,CAAC;AAExD,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,gBAAgB;;;;;;;;;;;;;;iBAOC,CAAC;AAE/B,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,EAAE,MAAM,EAAE,kBAAkB,QAMpF"}

package/dist/general/common.js

@@ -14,14 +14,14 @@ export const TokenBalanceSchema = z
     quantityOut: z.string(),
 })
     .openapi("TokenBalanceSchema");
-export const BalancesResponseSchema = z
+export const BalancesResponse = z
     .object({
     balances: z.array(TokenBalanceSchema),
     totalItems: z.number(),
     totalPages: z.number(),
     pageNumber: z.number(),
 })
-    .openapi("BalancesResponseSchema");
+    .openapi("BalancesResponse");
 export function getQuicknode(chainId, config) {
     const rpc = getBalancesRpc(chainId, config);
     return new Core({

package/dist/general/estimateGas.d.ts

@@ -1,9 +1,18 @@
-import { HttpError } from "../common/http-error.js";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const EstimateGasRequest: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"31337" | "11155111" | "84532">[]>;
+    data: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    from: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    to: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
+export declare const EstimateGasResponse: z.ZodObject<{
+    value: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
 export declare const EstimateGasV0: import("../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId: "31337" | "11155111" | "84532";
                     data: string;
                     from: string;
@@ -11,15 +20,11 @@ export declare const EstimateGasV0: import("../common/controller.js").IControlle
                 };
             };
             output: {
-                readonly success: true;
-                readonly value: string;
+                value: string & z.core.$brand<"Int256">;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/", "/">>;
-export declare class UnableEstimateGasError extends HttpError<500> {
-    constructor(error: unknown);
-}
 //# sourceMappingURL=estimateGas.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"estimateGas.d.ts","sourceRoot":"","sources":["../../src/general/estimateGas.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AA4BpD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;aAoCxB,CAAC;AAEH,qBAAa,sBAAuB,SAAQ,SAAS,CAAC,GAAG,CAAC;gBAC5C,KAAK,EAAE,OAAO;CAM3B"}
+{"version":3,"file":"estimateGas.d.ts","sourceRoot":"","sources":["../../src/general/estimateGas.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,kBAAkB;;;;;iBAOC,CAAC;AAEjC,eAAO,MAAM,mBAAmB;;iBAMC,CAAC;AAkBlC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;aAuBxB,CAAC"}

package/dist/general/estimateGas.js

@@ -3,12 +3,27 @@ import { resolver, validator } from "hono-openapi";
 import { estimateGas } from "viem/actions";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { getErrorMessage } from "@evergonlabs/tmi-utils/errors";
-import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { getPublicClient } from "../common/blockchain.js";
 import { createController } from "../common/controller.js";
 import { HttpError } from "../common/http-error.js";
 import { AddressSchema, HexStringSchema, StakingChainId } from "../common/index.js";
 import { generalTag as tag } from "./tag.js";
+export const EstimateGasRequest = z
+    .object({
+    chainId: StakingChainId,
+    data: HexStringSchema,
+    from: AddressSchema,
+    to: AddressSchema,
+})
+    .openapi("EstimateGasRequest");
+export const EstimateGasResponse = z
+    .object({
+    value: Int256Json.openapi({
+        description: "Amount of gas (in WEI) that is needed for specified transaction",
+    }),
+})
+    .openapi("EstimateGasResponse");
 const estimateGasRoute = describeRoute({
     summary: "Estimate gas",
     description: "Checks given transaction data whether it can be executed and returns estimated gas consumption",
@@ -18,26 +33,15 @@ const estimateGasRoute = describeRoute({
             description: "Returns estimated gas or estimation error",
             content: {
                 "application/json": {
-                    schema: resolver(z
-                        .object({
-                        value: Int256Json.openapi({
-                            description: "Amount of gas (in WEI) that is needed for specified transaction",
-                        }),
-                    })
-                        .openapi("EstimateGasResponse")),
+                    schema: resolver(EstimateGasResponse),
                 },
             },
         },
     },
 });
 export const EstimateGasV0 = createController({
-    build: (factory) => factory.createApp().post("/", estimateGasRoute, validator("json", z.object({
-        chainId: StakingChainId,
-        data: HexStringSchema,
-        from: AddressSchema,
-        to: AddressSchema,
-    })), async (c) => {
-        const { chainId, data, to, from } = c.req.valid("json");
+    build: (factory) => factory.createApp().get("/", estimateGasRoute, validator("query", EstimateGasRequest), async (c) => {
+        const { chainId, data, to, from } = c.req.valid("query");
         const publicClient = getPublicClient(chainId, c.env.config);
         try {
             const estimated = await estimateGas(publicClient, {
@@ -46,20 +50,15 @@ export const EstimateGasV0 = createController({
                 account: from,
             });
             return c.json({
-                success: true,
-                value: estimated.toString(),
-            }, 200);
+                value: toInt256Json(estimated),
+            });
         }
         catch (error) {
-            throw new UnableEstimateGasError(error);
+            throw new HttpError(500, {
+                message: getErrorMessage(error),
+                name: "UnableEstimateGasError",
+                cause: error,
+            });
         }
     }),
 });
-export class UnableEstimateGasError extends HttpError {
-    constructor(error) {
-        super(500, {
-            message: getErrorMessage(error),
-            cause: error,
-        });
-    }
-}

package/dist/general/getBalance.d.ts

@@ -1,3 +1,12 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetBalanceResponse: z.ZodObject<{
+    address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    balance: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
+export declare const GetBalanceQuery: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"1" | "31337" | "11155111" | "84532" | "72080">[]>;
+    address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
 export declare const GetBalanceV0: import("../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, {
     "/": {
         $get: {
@@ -9,7 +18,7 @@ export declare const GetBalanceV0: import("../common/controller.js").IController
             };
             output: {
                 address: `0x${string}`;
-                balance: string;
+                balance: string & z.core.$brand<"Int256">;
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;

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

@@ -1 +1 @@
-{"version":3,"file":"getBalance.d.ts","sourceRoot":"","sources":["../../src/general/getBalance.ts"],"names":[],"mappings":"AAgCA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;aA2BvB,CAAC"}
+{"version":3,"file":"getBalance.d.ts","sourceRoot":"","sources":["../../src/general/getBalance.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,kBAAkB;;;iBAOC,CAAC;AAEjC,eAAO,MAAM,eAAe;;;iBASC,CAAC;AAE9B,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;aAmCvB,CAAC"}

package/dist/general/getBalance.js

@@ -1,36 +1,45 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { createController } from "../common/controller.js";
 import { AddressSchema, FractionsChainId } from "../common/index.js";
 import { getQuicknode } from "./common.js";
 import { generalTag as tag } from "./tag.js";
-const getBalanceRoute = describeRoute({
-    summary: "Get balance",
-    description: "Returns native balance of a wallet for specific token",
-    tags: [tag.tag],
-    responses: {
-        200: {
-            description: "Returns native balance of a wallet",
-            content: {
-                "application/json": {
-                    schema: resolver(z.object({
-                        address: AddressSchema,
-                        balance: Int256Json.openapi({
-                            description: "Native tokens in WEI",
-                        }),
-                    })),
+export const GetBalanceResponse = z
+    .object({
+    address: AddressSchema,
+    balance: Int256Json.openapi({
+        description: "Native tokens in WEI",
+    }),
+})
+    .openapi("GetBalanceResponse");
+export const GetBalanceQuery = z
+    .object({
+    chainId: FractionsChainId.openapi({
+        param: { name: "chainId", in: "query" },
+    }),
+    address: AddressSchema.openapi({
+        param: { name: "address", in: "query" },
+    }),
+})
+    .openapi("GetBalanceQuery");
+export const GetBalanceV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get balance",
+        description: "Returns native balance of a wallet for specific token",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Returns native balance of a wallet",
+                content: {
+                    "application/json": {
+                        schema: resolver(GetBalanceResponse),
+                    },
                 },
             },
         },
-    },
-});
-export const GetBalanceV0 = createController({
-    build: (factory) => factory.createApp().get("/", getBalanceRoute, validator("query", z.object({
-        chainId: FractionsChainId,
-        address: AddressSchema,
-    })), async (c) => {
+    }), validator("query", GetBalanceQuery), async (c) => {
         const { chainId, address } = c.req.valid("query");
         const quicknode = getQuicknode(chainId, c.env.config);
         const result = await quicknode.client.getBalance({
@@ -39,7 +48,7 @@ export const GetBalanceV0 = createController({
         });
         return c.json({
             address: address,
-            balance: result.toString(),
+            balance: toInt256Json(result),
         });
     }),
 });

package/dist/general/getBalancesBatch.d.ts

@@ -1,8 +1,24 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetBalancesBatchResponse: z.ZodArray<z.ZodObject<{
+    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.ZodString>;
+    name: z.ZodNullable<z.ZodString>;
+    symbol: z.ZodNullable<z.ZodString>;
+    decimals: z.ZodNullable<z.ZodString>;
+    quantityIn: z.ZodString;
+    quantityOut: z.ZodString;
+}, z.core.$strip>>;
+export declare const GetBalancesBatchQuery: z.ZodObject<{
+    chainId: z.ZodUnion<z.ZodLiteral<"1" | "31337" | "11155111" | "84532" | "72080">[]>;
+    address: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    contracts: z.ZodArray<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+}, z.core.$strip>;
 export declare const GetBalancesBatchV0: import("../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                     address: string;
                     contracts: string[];

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

@@ -1 +1 @@
-{"version":3,"file":"getBalancesBatch.d.ts","sourceRoot":"","sources":["../../src/general/getBalancesBatch.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;aA2B7B,CAAC"}
+{"version":3,"file":"getBalancesBatch.d.ts","sourceRoot":"","sources":["../../src/general/getBalancesBatch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,wBAAwB;;;;;;;;;kBAAkE,CAAC;AAExG,eAAO,MAAM,qBAAqB;;;;iBAYC,CAAC;AAEpC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;aAgC7B,CAAC"}

package/dist/general/getBalancesBatch.js

@@ -5,30 +5,37 @@ import { createController } from "../common/controller.js";
 import { AddressSchema, FractionsChainId } from "../common/index.js";
 import { getQuicknode, TokenBalanceSchema } from "./common.js";
 import { generalTag as tag } from "./tag.js";
-const getBalancesBatchRoute = describeRoute({
-    summary: "Get balances batch",
-    description: "Returns ERC20 balances of a wallet for specific tokens",
-    tags: [tag.tag],
-    responses: {
-        200: {
-            description: "Returns ERC20 balances",
-            content: {
-                "application/json": {
-                    schema: resolver(z.array(TokenBalanceSchema)),
+export const GetBalancesBatchResponse = z.array(TokenBalanceSchema).openapi("GetBalancesBatchResponse");
+export const GetBalancesBatchQuery = z
+    .object({
+    chainId: FractionsChainId.openapi({
+        param: { name: "chainId", in: "query" },
+    }),
+    address: AddressSchema.openapi({
+        param: { name: "address", in: "query" },
+    }),
+    contracts: z.array(AddressSchema).openapi({
+        param: { name: "contracts", in: "query" },
+    }),
+})
+    .openapi("GetBalancesBatchQuery");
+export const GetBalancesBatchV0 = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get balances batch",
+        description: "Returns ERC20 balances of a wallet for specific tokens",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Returns ERC20 balances",
+                content: {
+                    "application/json": {
+                        schema: resolver(GetBalancesBatchResponse),
+                    },
                 },
             },
         },
-    },
-});
-export const GetBalancesBatchV0 = createController({
-    build: (factory) => factory.createApp().post("/", getBalancesBatchRoute, validator("json", z
-        .object({
-        chainId: FractionsChainId,
-        address: AddressSchema,
-        contracts: z.array(AddressSchema),
-    })
-        .openapi("GetBalanceBatchRequest")), async (c) => {
-        const { chainId, address, contracts } = c.req.valid("json");
+    }), validator("query", GetBalancesBatchQuery), async (c) => {
+        const { chainId, address, contracts } = c.req.valid("query");
         const quicknode = getQuicknode(chainId, c.env.config);
         const result = await quicknode.client.qn_getWalletTokenBalance({
             wallet: address,

package/dist/general/index.d.ts

@@ -1,8 +1,8 @@
 export declare const GeneralApi: import("../common/controller.js").IApi<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId: "31337" | "11155111" | "84532";
                     data: string;
                     from: string;
@@ -10,11 +10,10 @@ export declare const GeneralApi: import("../common/controller.js").IApi<import("
                 };
             };
             output: {
-                readonly success: true;
-                readonly value: string;
+                value: string & import("zod").$brand<"Int256">;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/estimateGas"> | import("hono/types").MergeSchemaPath<{
@@ -28,7 +27,7 @@ export declare const GeneralApi: import("../common/controller.js").IApi<import("
             };
             output: {
                 address: `0x${string}`;
-                balance: string;
+                balance: string & import("zod").$brand<"Int256">;
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;
@@ -36,9 +35,9 @@ export declare const GeneralApi: import("../common/controller.js").IApi<import("
     };
 }, "/balance"> | import("hono/types").MergeSchemaPath<{
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                     address: string;
                     contracts: string[];
@@ -59,9 +58,9 @@ export declare const GeneralApi: import("../common/controller.js").IApi<import("
     };
 }, "/balances"> | import("hono/types").MergeSchemaPath<{
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                     address: string;
                 };

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/general/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAUrB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/general/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAUrB,CAAC"}