@evergonlabs/tmi-protocol-api 0.4.1 → 0.7.0

package/dist/fractions/withdraw/v0/withdraw.route.d.ts

@@ -15,8 +15,8 @@ export declare function createWithdrawPaymentFromSaleTransactionV0<E extends Env
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };
@@ -37,8 +37,8 @@ export declare function createWithdrawPaymentFromSaleTransactionV0<E extends Env
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };
@@ -59,8 +59,8 @@ export declare function createWithdrawPaymentFromSaleTransactionV0<E extends Env
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };

package/dist/general/balanceClient.d.ts

@@ -1,75 +1,35 @@
 import { Address } from "viem";
-import { TmiChainId } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { z } from "zod";
+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;
-        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;
-        contractAddress: `0x${string}`;
-        balance: string;
-        tokenId?: string | undefined;
-    }, {
-        symbol: string;
-        type: string;
         name: string;
-        decimals: string | number | bigint;
-        contractAddress: `0x${string}`;
-        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;
-        name: string;
-        decimals: string | number | bigint;
+        balance: string & z.core.$brand<"Int256">;
         contractAddress: `0x${string}`;
-        balance: string | number | bigint;
-        tokenId?: string | number | bigint | undefined;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    status: string;
-    message: 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;
-    }[];
-}, {
-    status: string;
-    message: string;
-    result: {
-        symbol: string;
-        type: string;
         name: string;
-        decimals: string | number | bigint;
-        contractAddress: `0x${string}`;
-        balance: string | number | bigint;
-        tokenId?: string | number | bigint | undefined;
-    }[];
-}>;
-export declare function getAccountBalances(wallet: Address, chainId: TmiChainId): Promise<z.infer<typeof TokenBalance>[]>;
+        symbol: string;
+        type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
+        tokenId?: (string & z.core.$brand<"Int256">) | undefined;
+    }>>>;
+}, z.core.$strip>;
+export declare function getAccountBalances(wallet: Address, chainId: IPolymorphicChainId): 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,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,GAC3B,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,EAAE,CAAC,CA2BzC"}

package/dist/general/balanceClient.js

@@ -1,7 +1,7 @@
 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(),

package/dist/general/common.d.ts

@@ -1,94 +1,30 @@
-import { z } from "zod";
 import { Core } from "@quicknode/sdk";
-import { TmiChainId } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { z } from "zod";
+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;
-    name: string | null;
-    address: `0x${string}`;
-    decimals: string | null;
-    totalBalance: string;
-    quantityIn: string;
-    quantityOut: string;
-    tokenId?: bigint | undefined;
-}, {
-    symbol: string | null;
-    name: string | null;
-    address: `0x${string}`;
-    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;
-        name: string | null;
-        address: `0x${string}`;
-        decimals: string | null;
-        totalBalance: string;
-        quantityIn: string;
-        quantityOut: string;
-        tokenId?: bigint | undefined;
-    }, {
-        symbol: string | null;
-        name: string | null;
-        address: `0x${string}`;
-        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;
-        name: string | null;
-        address: `0x${string}`;
-        decimals: string | null;
-        totalBalance: string;
-        quantityIn: string;
-        quantityOut: string;
-        tokenId?: bigint | undefined;
-    }[];
-    totalItems: number;
-    totalPages: number;
-    pageNumber: number;
-}, {
-    balances: {
-        symbol: string | null;
-        name: string | null;
-        address: `0x${string}`;
-        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): 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,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,QAMxD"}

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,9 +21,7 @@ export const BalancesResponseSchema = z
     totalPages: z.number(),
     pageNumber: z.number(),
 })
-    .openapi({
-    ref: "BalancesResponseSchema",
-});
+    .openapi("BalancesResponseSchema");
 export function getQuicknode(chainId) {
     const rpc = getBalancesRpc(chainId);
     return new Core({

package/dist/general/estimateGas.d.ts

@@ -1,51 +1,24 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
 import { HttpError } from "../common/http-error.js";
-import { ITag } from "../common/tag.js";
-export declare function createEstimateGasHandlersV0<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    readonly success: true;
-    readonly value: string;
-}, 200, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            data: `0x${string}`;
-            to: `0x${string}`;
-            chainId: "11155111" | "31337";
-            from: `0x${string}`;
+export declare const EstimateGasV0: import("../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    data: string;
+                    from: string;
+                    to: string;
+                };
+            };
+            output: {
+                readonly success: true;
+                readonly value: string;
+            };
+            outputFormat: "json";
+            status: 200;
         };
     };
-    out: {
-        json: {
-            data: `0x${string}`;
-            to: `0x${string}`;
-            chainId: "11155111" | "31337";
-            from: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    readonly success: true;
-    readonly value: string;
-}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        json: {
-            data: `0x${string}`;
-            to: `0x${string}`;
-            chainId: "11155111" | "31337";
-            from: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            data: `0x${string}`;
-            to: `0x${string}`;
-            chainId: "11155111" | "31337";
-            from: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    readonly success: true;
-    readonly value: string;
-}, 200, "json">>>];
+}, "/">>;
 export declare class UnableEstimateGasError extends HttpError<500> {
     constructor(error: unknown);
 }

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

@@ -1 +1 @@
-{"version":3,"file":"estimateGas.d.ts","sourceRoot":"","sources":["../../src/general/estimateGas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAG3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAMvC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA0DxF;AAED,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":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AA8BpD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;QAoCxB,CAAC;AAEH,qBAAa,sBAAuB,SAAQ,SAAS,CAAC,GAAG,CAAC;gBAC5C,KAAK,EAAE,OAAO;CAM3B"}

package/dist/general/estimateGas.js

@@ -1,36 +1,38 @@
-import { Int256Positive } from "@evergonlabs/tmi-utils/models";
-import { getErrorMessage } from "@evergonlabs/tmi-utils/errors";
-import { estimateGas } from "viem/actions";
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
+import { resolver, validator } from "hono-openapi";
+import { estimateGas } from "viem/actions";
+import { z } from "zod";
+import { getErrorMessage } from "@evergonlabs/tmi-utils/errors";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { getPublicClient } from "../common/blockchain.js";
-import { AddressSchema, HexStringSchema, StakingChainId } from "../common/index.js";
+import { createController } from "../common/controller.js";
 import { HttpError } from "../common/http-error.js";
-import { z } from "../common/zod.js";
-export function createEstimateGasHandlersV0(factory, tag) {
-    return factory.createHandlers(describeRoute({
-        summary: "Estimate gas",
-        description: "Checks given transaction data whether it can be executed and returns estimated gas consumption",
-        tags: [tag.tag],
-        responses: {
-            200: {
-                description: "Returns estimated gas or estimation error",
-                content: {
-                    "application/json": {
-                        schema: resolver(z
-                            .object({
-                            value: Int256Positive.openapi({
-                                description: "Amount of gas (in WEI) that is needed for specified transaction",
-                            }),
-                        })
-                            .openapi({
-                            ref: "EstimateGasResponse",
-                        })),
-                    },
+import { AddressSchema, HexStringSchema, StakingChainId } from "../common/index.js";
+import { createTag } from "../common/tag.js";
+const tag = createTag("General");
+const estimateGasRoute = describeRoute({
+    summary: "Estimate gas",
+    description: "Checks given transaction data whether it can be executed and returns estimated gas consumption",
+    tags: [tag.tag],
+    responses: {
+        200: {
+            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")),
                 },
             },
         },
-    }), validator("json", z.object({
+    },
+});
+export const EstimateGasV0 = createController({
+    build: (factory) => factory.createApp().post("/", estimateGasRoute, validator("json", z.object({
         chainId: StakingChainId,
         data: HexStringSchema,
         from: AddressSchema,
@@ -52,8 +54,8 @@ export function createEstimateGasHandlersV0(factory, tag) {
         catch (error) {
             throw new UnableEstimateGasError(error);
         }
-    });
-}
+    }),
+});
 export class UnableEstimateGasError extends HttpError {
     constructor(error) {
         super(500, {

package/dist/general/getBalance.d.ts

@@ -1,40 +1,19 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { ITag } from "../common/tag.js";
-export declare function createGetBalanceV0<E extends Env, TTag extends ITag>(factory: Factory<E>, tag: TTag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    address: `0x${string}`;
-    balance: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        query: {
-            address: string | string[];
-            chainId: string | string[];
+export declare const GetBalanceV0: import("../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    address: string | string[];
+                };
+            };
+            output: {
+                address: `0x${string}`;
+                balance: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-    out: {
-        query: {
-            address: `0x${string}`;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    address: `0x${string}`;
-    balance: string;
-}, 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: {
-        query: {
-            address: string | string[];
-            chainId: string | string[];
-        };
-    };
-    out: {
-        query: {
-            address: `0x${string}`;
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    address: `0x${string}`;
-    balance: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+}, "/">>;
 //# sourceMappingURL=getBalance.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getBalance.d.ts","sourceRoot":"","sources":["../../src/general/getBalance.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGxC,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,SAAS,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA8ClG"}
+{"version":3,"file":"getBalance.d.ts","sourceRoot":"","sources":["../../src/general/getBalance.ts"],"names":[],"mappings":"AAkCA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;QA2BvB,CAAC"}

package/dist/general/getBalance.js

@@ -1,31 +1,35 @@
-import { z } from "zod";
-import { Int256 } from "@evergonlabs/tmi-utils/models";
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { AddressSchema, TmiChainIdSchema } from "../common/index.js";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { createController } from "../common/controller.js";
+import { AddressSchema, FractionsChainId } from "../common/index.js";
+import { createTag } from "../common/tag.js";
 import { getQuicknode } from "./common.js";
-export function createGetBalanceV0(factory, tag) {
-    return factory.createHandlers(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: Int256.openapi({
-                                description: "Native tokens in WEI",
-                            }),
-                        })),
-                    },
+const tag = createTag("General");
+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",
+                        }),
+                    })),
                 },
             },
         },
-    }), validator("query", z.object({
-        chainId: TmiChainIdSchema,
+    },
+});
+export const GetBalanceV0 = createController({
+    build: (factory) => factory.createApp().get("/", getBalanceRoute, validator("query", z.object({
+        chainId: FractionsChainId,
         address: AddressSchema,
     })), async (c) => {
         const { chainId, address } = c.req.valid("query");
@@ -38,5 +42,5 @@ export function createGetBalanceV0(factory, tag) {
             address: address,
             balance: result.toString(),
         });
-    });
-}
+    }),
+});