@evergonlabs/tmi-protocol-api 0.1.0

package/dist/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/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/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/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/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/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/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/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/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);
+    });
+}

package/dist/general/index.d.ts

@@ -0,0 +1,100 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare const generalApis: {
+    name: string;
+    createApp: <E extends Env>(factory: Factory<E>) => import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/estimateGas": {
+            $post: {
+                input: {
+                    json: {
+                        data: `0x${string}`;
+                        to: `0x${string}`;
+                        chainId: "11155111" | "31337";
+                        from: `0x${string}`;
+                    };
+                };
+                output: {
+                    readonly success: true;
+                    readonly value: string;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    } & {
+        "/balance": {
+            $get: {
+                input: {
+                    query: {
+                        address: string | string[];
+                        chainId: string | string[];
+                        contract: string | string[];
+                    };
+                };
+                output: {
+                    address: `0x${string}`;
+                    balance: string;
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/balances": {
+            $post: {
+                input: {
+                    json: {
+                        address: `0x${string}`;
+                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+                        contracts: `0x${string}`[];
+                    };
+                };
+                output: {
+                    quantityIn: string;
+                    quantityOut: string;
+                    name: string | null;
+                    symbol: string | null;
+                    decimals: string | null;
+                    address: string;
+                    totalBalance: string;
+                }[];
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    } & {
+        "/searchBalances": {
+            $post: {
+                input: {
+                    json: {
+                        address: `0x${string}`;
+                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+                        page?: number | undefined;
+                        perPage?: number | undefined;
+                    };
+                };
+                output: {
+                    balances: {
+                        tokenAddress: `0x${string}`;
+                        balance: never;
+                        decimals: number | undefined;
+                        symbol: string;
+                        name: string;
+                        tokenId: undefined;
+                        type: "ERC-20" | "ERC-721" | "ERC-1155";
+                    }[];
+                    totalItems: number;
+                    totalPages: number;
+                    pageNumber: number;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    }, "/general">, "/">;
+    config: {
+        title: string;
+        description: string;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/general/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,eAAO,MAAM,WAAW;;gBAEV,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc/C,CAAC"}

package/dist/general/index.js

@@ -0,0 +1,20 @@
+import { createApiConfig } from "../common/app.js";
+import { createEstimateGasHandlersV0 } from "./estimateGas.js";
+import { createTag } from "../common/tag.js";
+import { createSearchBalancesV0 } from "./searchBalances.js";
+import { createGetBalanceV0 } from "./getBalance.js";
+import { createGetBalancesBatchV0 } from "./getBalancesBatch.js";
+const tag = createTag("General");
+export const generalApis = {
+    name: "General APIs",
+    createApp: (factory) => factory.createApp().route("/general", factory
+        .createApp()
+        .post("/estimateGas", ...createEstimateGasHandlersV0(factory, tag))
+        .get("/balance", ...createGetBalanceV0(factory, tag))
+        .post("/balances", ...createGetBalancesBatchV0(factory, tag))
+        .post("/searchBalances", ...createSearchBalancesV0(factory, tag))),
+    config: createApiConfig({
+        title: "General API",
+        description: "Utility APIs",
+    }),
+};

package/dist/general/searchBalances.d.ts

@@ -0,0 +1,78 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { ITag } from "../common/tag.js";
+export declare function createSearchBalancesV0<E extends Env, TTag extends ITag>(factory: Factory<E>, tag: TTag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    balances: {
+        tokenAddress: `0x${string}`;
+        balance: never;
+        decimals: number | undefined;
+        symbol: string;
+        name: string;
+        tokenId: undefined;
+        type: "ERC-20" | "ERC-721" | "ERC-1155";
+    }[];
+    totalItems: number;
+    totalPages: number;
+    pageNumber: number;
+}, 200, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            page?: number | undefined;
+            perPage?: number | undefined;
+        };
+    };
+    out: {
+        json: {
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            page?: number | undefined;
+            perPage?: number | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    balances: {
+        tokenAddress: `0x${string}`;
+        balance: never;
+        decimals: number | undefined;
+        symbol: string;
+        name: string;
+        tokenId: undefined;
+        type: "ERC-20" | "ERC-721" | "ERC-1155";
+    }[];
+    totalItems: number;
+    totalPages: number;
+    pageNumber: number;
+}, 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;
+            page?: number | undefined;
+            perPage?: number | undefined;
+        };
+    };
+    out: {
+        json: {
+            address: `0x${string}`;
+            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
+            page?: number | undefined;
+            perPage?: number | undefined;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    balances: {
+        tokenAddress: `0x${string}`;
+        balance: never;
+        decimals: number | undefined;
+        symbol: string;
+        name: string;
+        tokenId: undefined;
+        type: "ERC-20" | "ERC-721" | "ERC-1155";
+    }[];
+    totalItems: number;
+    totalPages: number;
+    pageNumber: number;
+}, 200, "json">>>];
+//# sourceMappingURL=searchBalances.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"searchBalances.d.ts","sourceRoot":"","sources":["../../src/general/searchBalances.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;AAIxC,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,SAAS,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDtG"}

package/dist/general/searchBalances.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { AddressSchema, TmiChainIdSchema } from "../common/index.js";
+import { BalancesResponseSchema } from "./common.js";
+import { getTokenBalance } from "./balance-client.js";
+export function createSearchBalancesV0(factory, tag) {
+    return factory.createHandlers(describeRoute({
+        summary: "Search balances",
+        description: "Returns ERC20 balances of a wallet",
+        tags: [tag.tag],
+        responses: {
+            200: {
+                description: "Returns ERC20 balances of a wallet",
+                content: {
+                    "application/json": {
+                        schema: resolver(BalancesResponseSchema),
+                    },
+                },
+            },
+        },
+    }), validator("json", z.object({
+        chainId: TmiChainIdSchema,
+        address: AddressSchema.openapi({
+            description: "The address to get the balance for.",
+        }),
+        page: z.optional(z.number()),
+        perPage: z.optional(z.number()),
+    })), async (c) => {
+        const { chainId, address } = c.req.valid("json");
+        const result = await getTokenBalance(address, chainId);
+        return c.json({
+            balances: result.map((it) => {
+                return {
+                    tokenAddress: it.contractAddress,
+                    balance: it.balance,
+                    decimals: it.decimals,
+                    symbol: it.symbol,
+                    name: it.name,
+                    tokenId: it.id,
+                    type: it.type,
+                };
+            }),
+            totalItems: result.length,
+            totalPages: 1,
+            pageNumber: 1,
+        }, 200);
+    });
+}

package/dist/issuance/approve.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare const ApproveErc20RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    spender: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    amount: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    tokenAddress: `0x${string}`;
+    amount: bigint;
+    spender: `0x${string}`;
+}, {
+    tokenAddress: `0x${string}`;
+    amount: bigint;
+    spender: `0x${string}`;
+}>;
+export declare function approveErc20Token<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: {
+            tokenAddress: `0x${string}`;
+            amount: bigint;
+            spender: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            tokenAddress: `0x${string}`;
+            amount: bigint;
+            spender: `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: {
+            tokenAddress: `0x${string}`;
+            amount: bigint;
+            spender: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            tokenAddress: `0x${string}`;
+            amount: bigint;
+            spender: `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=approve.d.ts.map

package/dist/issuance/approve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../src/issuance/approve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAIpC,CAAC;AAkBH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAanE"}