@evergonlabs/tmi-protocol-api 0.1.0

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

@@ -0,0 +1,68 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { z } from "zod";
+export declare const WithdrawRequestSchema: z.ZodObject<{
+    market: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    campaignId: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    campaignId: bigint;
+    market: `0x${string}`;
+}, {
+    campaignId: bigint;
+    market: `0x${string}`;
+}>;
+export declare function createWithdrawPaymentFromSaleTransactionV0<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            campaignId: bigint;
+            market: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            campaignId: bigint;
+            market: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${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: {
+            campaignId: bigint;
+            market: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            campaignId: bigint;
+            market: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+    to: `0x${string}`;
+    details: {
+        functionName: string;
+        address: `0x${string}`;
+        abi: any[];
+        args: any[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=withdraw.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withdraw.route.d.ts","sourceRoot":"","sources":["../../../../../src/fractions/withdraw/v0/withdraw.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qBAAqB;;;;;;;;;EAGhC,CAAC;AAkBH,wBAAgB,0CAA0C,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAU5F"}

package/dist/src/fractions/withdraw/v0/withdraw.route.js

@@ -0,0 +1,31 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { builtWithdrawTx } from "@evergonlabs/tmi-protocol-fractions-sdk";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
+import { z } from "zod";
+export const WithdrawRequestSchema = z.object({
+    market: AddressSchema,
+    campaignId: z.coerce.bigint(),
+});
+const route = describeRoute({
+    summary: "Withdraw payment tokens from a sale",
+    description: "Returns transaction to withdraw payment tokens from a sale",
+    tags: ["Fractions"],
+    responses: {
+        200: {
+            description: "Returns transaction to withdraw payment tokens from a sale",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createWithdrawPaymentFromSaleTransactionV0(factory) {
+    return factory.createHandlers(route, validator("json", WithdrawRequestSchema.openapi({ ref: "WithdrawRequestSchema" })), async (c) => {
+        const { market, campaignId } = c.req.valid("json");
+        const tx = builtWithdrawTx(market, campaignId);
+        return c.json(toTransaction(tx));
+    });
+}

package/dist/src/general/balance-client.d.ts

@@ -0,0 +1,13 @@
+import { Address } from "viem";
+import { TmiChainId } from "@evergonlabs/tmi-protocol-fractions-sdk";
+export type TokenBalance = {
+    balance: bigint;
+    contractAddress: Address;
+    decimals: number | undefined;
+    name: string;
+    symbol: string;
+    type: "ERC-20" | "ERC-721" | "ERC-1155";
+    id: bigint | undefined;
+};
+export declare function getTokenBalance(wallet: Address, chainId: TmiChainId, contracts?: Address[]): Promise<TokenBalance[]>;
+//# sourceMappingURL=balance-client.d.ts.map

package/dist/src/general/balance-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"balance-client.d.ts","sourceRoot":"","sources":["../../../src/general/balance-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAK/B,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAErE,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;IACxC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;CACxB,CAAC;AAQF,wBAAsB,eAAe,CACnC,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,UAAU,EACnB,SAAS,CAAC,EAAE,OAAO,EAAE,GACpB,OAAO,CAAC,YAAY,EAAE,CAAC,CAsBzB"}

package/dist/src/general/balance-client.js

@@ -0,0 +1,26 @@
+import { getBalancesApi } from "../common/blockchain.js";
+import axios from "axios";
+export async function getTokenBalance(wallet, chainId, contracts) {
+    const url = getBalancesApi(chainId);
+    try {
+        const result = await axios.get(url, {
+            params: {
+                module: "account",
+                action: "tokenlist",
+                address: wallet,
+            },
+        });
+        if (contracts) {
+            return result.data.result.filter((token) => contracts.includes(token.contractAddress));
+        }
+        else {
+            return result.data.result;
+        }
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            throw new Error(`Network error: ${error.message}`);
+        }
+        throw error;
+    }
+}

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

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

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

@@ -0,0 +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"}

package/dist/src/general/common.js

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

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

@@ -0,0 +1,52 @@
+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}`;
+        };
+    };
+    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);
+}
+//# sourceMappingURL=estimateGas.d.ts.map

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

@@ -0,0 +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"}

package/dist/src/general/estimateGas.js

@@ -0,0 +1,64 @@
+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 { getPublicClient } from "../common/blockchain.js";
+import { AddressSchema, HexStringSchema, StakingChainId } from "../common/index.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",
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        chainId: StakingChainId,
+        data: HexStringSchema,
+        from: AddressSchema,
+        to: AddressSchema,
+    })), async (c) => {
+        const { chainId, data, to, from } = c.req.valid("json");
+        const publicClient = getPublicClient(chainId);
+        try {
+            const estimated = await estimateGas(publicClient, {
+                data: data,
+                to: to,
+                account: from,
+            });
+            return c.json({
+                success: true,
+                value: estimated.toString(),
+            }, 200);
+        }
+        catch (error) {
+            throw new UnableEstimateGasError(error);
+        }
+    });
+}
+export class UnableEstimateGasError extends HttpError {
+    constructor(error) {
+        super(500, {
+            message: getErrorMessage(error),
+            cause: error,
+        });
+    }
+}

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

@@ -0,0 +1,44 @@
+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[];
+            contract: string | string[];
+        };
+    };
+    out: {
+        query: {
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            contract: `0x${string}`;
+        };
+    };
+}, 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[];
+            contract: string | string[];
+        };
+    };
+    out: {
+        query: {
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            contract: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    address: `0x${string}`;
+    balance: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=getBalance.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA+ClG"}

package/dist/src/general/getBalance.js

@@ -0,0 +1,43 @@
+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 { getQuicknode } from "./common.js";
+export function createGetBalanceV0(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Get balance",
+        description: "Returns ERC20 balance of a wallet for specific token",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Returns ERC20 balances of a wallet",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            address: AddressSchema,
+                            balance: Int256.openapi({
+                                description: "Amount of tokens in WEI",
+                            }),
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", z.object({
+        chainId: TmiChainIdSchema,
+        address: AddressSchema,
+        contract: AddressSchema,
+    })), async (c) => {
+        const { chainId, address } = c.req.valid("query");
+        const quicknode = getQuicknode(chainId);
+        const result = await quicknode.client.getBalance({
+            address: address,
+            blockTag: "safe",
+        });
+        return c.json({
+            address: address,
+            balance: result.toString(),
+        });
+    });
+}

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

@@ -0,0 +1,59 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../common/tag.js";
+export declare function createGetBalancesBatchV0<E extends Env, TTag extends ITag>(factory: Factory<E>, tag: TTag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    quantityIn: string;
+    quantityOut: string;
+    name: string | null;
+    symbol: string | null;
+    decimals: string | null;
+    address: string;
+    totalBalance: string;
+}[], 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            contracts: `0x${string}`[];
+        };
+    };
+    out: {
+        json: {
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            contracts: `0x${string}`[];
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    quantityIn: string;
+    quantityOut: string;
+    name: string | null;
+    symbol: string | null;
+    decimals: string | null;
+    address: string;
+    totalBalance: string;
+}[], 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            contracts: `0x${string}`[];
+        };
+    };
+    out: {
+        json: {
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            contracts: `0x${string}`[];
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    quantityIn: string;
+    quantityOut: string;
+    name: string | null;
+    symbol: string | null;
+    decimals: string | null;
+    address: string;
+    totalBalance: string;
+}[], 200, "json">>>];
+//# sourceMappingURL=getBalancesBatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getBalancesBatch.d.ts","sourceRoot":"","sources":["../../../src/general/getBalancesBatch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGxC,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,SAAS,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCxG"}

package/dist/src/general/getBalancesBatch.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { AddressSchema, TmiChainIdSchema } from "../common/index.js";
+import { getQuicknode, TokenBalanceSchema } from "./common.js";
+export function createGetBalancesBatchV0(factory, tag) {
+    return factory.createHandlers(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)),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        chainId: TmiChainIdSchema,
+        address: AddressSchema,
+        contracts: z.array(AddressSchema),
+    })), async (c) => {
+        const { chainId, address, contracts } = c.req.valid("json");
+        const quicknode = getQuicknode(chainId);
+        const result = await quicknode.client.qn_getWalletTokenBalance({
+            wallet: address,
+            contracts: contracts,
+        });
+        return c.json(result.result, 200);
+    });
+}