@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/issuance/erc20/index.d.ts

@@ -0,0 +1,324 @@
+export declare const Erc20Controller: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    tokenName: string;
+                    tokenSymbol: string;
+                    supplyCap: string;
+                    defaultTokenAdmin: string;
+                    minter: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deploy"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    tokenName: string;
+                    tokenSymbol: string;
+                    supplyCap: string;
+                    defaultTokenAdmin: string;
+                    minter: string;
+                    gatingSigner?: string | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deployGated"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                proxy: `0x${string}`;
+                admin: `0x${string}`;
+                minter: `0x${string}`;
+                supplyCap: string;
+                name: string;
+                symbol: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/getDeployEvent"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    spender: string;
+                    amount: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/approve"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    amount: string;
+                    burnFrom: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/burn"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    to: string;
+                    amount: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/mint"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    to: string;
+                    amount: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/transfer"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    from: string;
+                    to: string;
+                    amount: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/transferFrom"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    from: string;
+                    to: string;
+                    amount: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/recover"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: import("../../client.js").Erc20GatedRole;
+                    account: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/grantRole"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: import("../../client.js").Erc20GatedRole;
+                    account: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/revokeRole"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: import("../../client.js").Erc20GatedRole;
+                    callerConfirmation: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/renounceRole"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    name: string;
+                    symbol: string;
+                    cap: string;
+                    defaultAdmin: string;
+                    minter: string;
+                    gatingSigner?: string | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/initialize">, "/">>;
+//# sourceMappingURL=index.d.ts.map

package/dist/issuance/erc20/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/index.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiB1B,CAAC"}

package/dist/issuance/erc20/index.js

@@ -0,0 +1,31 @@
+import { createController } from "../../common/controller.js";
+import { ApproveErc20Token } from "./approve.js";
+import { BurnErc20Token } from "./burn.js";
+import { CreateErc20Token } from "./deploy.js";
+import { CreateGatedErc20Token } from "./deployGated.js";
+import { GrantRoleErc20 } from "./grantRole.js";
+import { InitializeErc20 } from "./initialize.js";
+import { MintErc20Token } from "./mint.js";
+import { ParseErc20DeployEvent } from "./parseErc20DeployEvent.js";
+import { RecoverErc20 } from "./recover.js";
+import { RenounceRoleErc20 } from "./renounceRole.js";
+import { RevokeRoleErc20 } from "./revokeRole.js";
+import { TransferErc20 } from "./transfer.js";
+import { TransferFromErc20 } from "./transferFrom.js";
+export const Erc20Controller = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/deploy", CreateErc20Token.build(factory))
+        .route("/deployGated", CreateGatedErc20Token.build(factory))
+        .route("/getDeployEvent", ParseErc20DeployEvent.build(factory))
+        .route("/approve", ApproveErc20Token.build(factory))
+        .route("/burn", BurnErc20Token.build(factory))
+        .route("/mint", MintErc20Token.build(factory))
+        .route("/transfer", TransferErc20.build(factory))
+        .route("/transferFrom", TransferFromErc20.build(factory))
+        .route("/recover", RecoverErc20.build(factory))
+        .route("/grantRole", GrantRoleErc20.build(factory))
+        .route("/revokeRole", RevokeRoleErc20.build(factory))
+        .route("/renounceRole", RenounceRoleErc20.build(factory))
+        .route("/initialize", InitializeErc20.build(factory)),
+});

package/dist/issuance/erc20/initialize.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const InitializeErc20RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    name: z.ZodString;
+    symbol: z.ZodString;
+    cap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    defaultAdmin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    minter: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    gatingSigner: z.ZodOptional<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 InitializeErc20: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    name: string;
+                    symbol: string;
+                    cap: string;
+                    defaultAdmin: string;
+                    minter: string;
+                    gatingSigner?: string | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=initialize.d.ts.map

package/dist/issuance/erc20/initialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,4BAA4B;;;;;;;;iBAUvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAc1B,CAAC"}

package/dist/issuance/erc20/initialize.js

@@ -0,0 +1,45 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
+import { DEFAULT_COMPILOT_SIGNER } from "../../common/models/compilot.js";
+export const InitializeErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    name: z.string().nonempty().openapi({ description: "Name of the ERC20 token" }),
+    symbol: z.string().nonempty().openapi({ description: "Symbol of the ERC20 token" }),
+    cap: Int256BigInt(z.bigint().nonnegative()),
+    defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
+    minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
+    gatingSigner: AddressSchema.optional().openapi({
+        description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
+    }),
+});
+const initializeRoute = describeRoute({
+    summary: "Initialize Gated ERC20",
+    description: "Returns transaction data for initializing a gated ERC20 token proxy contract",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for initializing a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const InitializeErc20 = createController({
+    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeErc20RequestSchema), async (c) => {
+        const { tokenAddress, name, symbol, cap, defaultAdmin, minter, gatingSigner } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20WhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "initialize",
+            args: [name, symbol, BigInt(cap), defaultAdmin, minter, gatingSigner ?? DEFAULT_COMPILOT_SIGNER],
+        }));
+    }),
+});

package/dist/issuance/erc20/mint.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const MintErc20RequestSchema: z.ZodObject<{
+    tokenAddress: 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}`>>;
+    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const MintErc20Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    to: string;
+                    amount: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=mint.d.ts.map

package/dist/issuance/erc20/mint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/mint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;QAczB,CAAC"}

package/dist/issuance/erc20/mint.js

@@ -0,0 +1,38 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
+export const MintErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    to: AddressSchema.openapi({ description: "Address to mint tokens to" }),
+    amount: Int256BigInt(z.bigint().nonnegative()),
+});
+const mintRoute = describeRoute({
+    summary: "Mint Gated ERC20",
+    description: "Returns transaction data for minting a gated ERC20 (MINTER_ROLE required)",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for minting a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const MintErc20Token = createController({
+    build: (factory) => factory.createApp().post("/", mintRoute, validator("json", MintErc20RequestSchema), async (c) => {
+        const { tokenAddress, to, amount } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20WhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "mint",
+            args: [to, BigInt(amount)],
+        }));
+    }),
+});

package/dist/issuance/erc20/parseErc20DeployEvent.d.ts

@@ -0,0 +1,23 @@
+export declare const ParseErc20DeployEvent: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                proxy: `0x${string}`;
+                admin: `0x${string}`;
+                minter: `0x${string}`;
+                supplyCap: string;
+                name: string;
+                symbol: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=parseErc20DeployEvent.d.ts.map

package/dist/issuance/erc20/parseErc20DeployEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseErc20DeployEvent.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/parseErc20DeployEvent.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;QAoDhC,CAAC"}

package/dist/issuance/erc20/parseErc20DeployEvent.js

@@ -0,0 +1,79 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { parseEventLogs } from "viem";
+import { waitForTransactionReceipt } from "viem/actions";
+import { z } from "zod";
+import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { Int256Json } 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, HashSchema } from "../../common/index.js";
+import { FactoryChainId } from "../common/factories.js";
+const QuerySchema = z.object({
+    chainId: FactoryChainId.Schema.openapi({
+        param: {
+            name: "chainId",
+            in: "query",
+        },
+    }),
+    hash: HashSchema.openapi({
+        param: {
+            name: "hash",
+            in: "query",
+        },
+    }),
+});
+export const ParseErc20DeployEvent = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get TokenProxyConfigured Event",
+        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted by the ERC20 factory \`deployAndInitializeProxy\` action`,
+        tags: ["Issuance"],
+        responses: {
+            200: {
+                description: "Returns parsed event log",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            proxy: AddressSchema,
+                            admin: AddressSchema,
+                            minter: AddressSchema,
+                            supplyCap: Int256Json,
+                            name: z.string(),
+                            symbol: z.string(),
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", QuerySchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
+            hash: params.hash,
+        });
+        const [event] = parseEventLogs({
+            abi: abis.erc20GatedPausableRecoverableFactoryAbi,
+            eventName: "TokenProxyConfigured",
+            logs: receipt.logs,
+        });
+        if (!event) {
+            throw new UnableParseErc20DeployEvent();
+        }
+        return c.json({
+            proxy: event.args.proxy,
+            admin: event.args.admin,
+            minter: event.args.minter,
+            supplyCap: event.args.supplyCap.toString(),
+            name: event.args.name,
+            symbol: event.args.symbol,
+        });
+    }),
+});
+class UnableParseErc20DeployEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse TokenProxyConfigured event. Make sure you're passing a transaction generated by the ERC20 factory \`deployAndInitializeProxy\` action`,
+            name: "UnableParseErc20DeployEvent",
+        });
+    }
+}

package/dist/issuance/erc20/recover.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const RecoverErc20RequestSchema: z.ZodObject<{
+    tokenAddress: 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}`>>;
+    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const RecoverErc20: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    from: string;
+                    to: string;
+                    amount: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=recover.d.ts.map

package/dist/issuance/erc20/recover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/recover.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;;;iBAKpC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;QAcvB,CAAC"}