@evergonlabs/tmi-protocol-api 0.4.1 → 0.7.0

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/issuance/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAYvC,eAAO,MAAM,YAAY;;gBAEX,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsB/C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/issuance/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAStB,CAAC"}

package/dist/issuance/index.js

@@ -1,31 +1,13 @@
-import { createApiConfig } from "../common/app.js";
-import { approveErc20Token } from "./approve.js";
-import { burnErc20Token } from "./burn.js";
-import { createErc1967Proxy, createErc20Token, createTransparentUpgradeableProxy, createProxyAdmin } from "./deploy.js";
-import { mintErc20Token } from "./mint.js";
-import { transferErc20Token } from "./transfer.js";
-import { createGrantRole } from "./grantRole.js";
-import { createRenounceRole } from "./renounceRole.js";
-import { upgradeTransparentProxy } from "./upgrade.js";
-import { createGetErc20InitData } from "./getInitData.js";
-export const issuanceApis = {
-    name: "Issuance APIs",
-    createApp: (factory) => factory.createApp().route("/issuance", factory
+import { createApi } from "../common/controller.js";
+import { Erc20Controller } from "./erc20/index.js";
+import { Erc721Controller } from "./erc721/index.js";
+import { ProxyController } from "./proxy/index.js";
+export const IssuanceApi = createApi({
+    title: "Issuance API",
+    description: "APIs for issuing tokens",
+    build: (factory) => factory
         .createApp()
-        .get("/erc20", ...createErc20Token(factory))
-        .post("/erc20/mint", ...mintErc20Token(factory))
-        .post("/erc20/burn", ...burnErc20Token(factory))
-        .post("/erc20/approve", ...approveErc20Token(factory))
-        .post("/erc20/transfer", ...transferErc20Token(factory))
-        .post("/erc20/proxy", ...createErc1967Proxy(factory))
-        .post("/erc20/grantRole", ...createGrantRole(factory))
-        .post("/erc20/renounceRole", ...createRenounceRole(factory))
-        .post("/erc20/getInitData", ...createGetErc20InitData(factory))
-        .get("/proxy/deployProxyAdmin", ...createProxyAdmin(factory))
-        .post("/proxy/deployTransparentProxy", ...createTransparentUpgradeableProxy(factory))
-        .post("/proxy/upgradeTransparentProxy", ...upgradeTransparentProxy(factory))),
-    config: createApiConfig({
-        title: "Issuance API",
-        description: "APIs for issuing tokens",
-    }),
-};
+        .route("/erc20", Erc20Controller.build(factory))
+        .route("/erc721", Erc721Controller.build(factory))
+        .route("/proxy", ProxyController.build(factory)),
+});

package/dist/issuance/mint.d.ts

@@ -18,8 +18,8 @@ export declare function mintErc20Token<E extends Env>(factory: Factory<E>): [imp
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };
@@ -42,8 +42,8 @@ export declare function mintErc20Token<E extends Env>(factory: Factory<E>): [imp
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };
@@ -66,8 +66,8 @@ export declare function mintErc20Token<E extends Env>(factory: Factory<E>): [imp
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };

package/dist/issuance/mint.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi/zod";
 import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
-import { erc20GatedAbi } from "../common/abis/erc20Whitelisted.js";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
 export const MintErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     amount: z.coerce.bigint().nonnegative(),

package/dist/issuance/proxy/deploy.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const DeployTransparentUpgradeableProxySchema: z.ZodObject<{
+    implementation: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    proxyAdminOwner: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    initData: 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 CreateTransparentUpgradeableProxy: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    implementation: string;
+                    proxyAdminOwner: string;
+                    initData: string;
+                };
+            };
+            output: {
+                bytecode: `0x${string}`;
+                abi: any[];
+                args?: any[] | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+export declare const CreateProxyAdmin: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {};
+            output: {
+                bytecode: `0x${string}`;
+                abi: any[];
+                args?: any[] | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/issuance/proxy/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2BxB,eAAO,MAAM,uCAAuC;;;;iBASlD,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;QAa5C,CAAC;AAoBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;QAQ3B,CAAC"}

package/dist/issuance/proxy/deploy.js

@@ -0,0 +1,68 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { proxyAdminAbi, proxyAdminBytecode } from "@evergonlabs/tmi-evm-contracts/proxyAdmin";
+import { transparentUpgradeableProxyAbi, transparentUpgradeableProxyBytecode, } from "@evergonlabs/tmi-protocol-contracts/transparentProxy";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, DeployTransactionSchema, HexStringSchema } from "../../common/index.js";
+// Issue generic TUP contract
+const deployTransparentProxyRoute = describeRoute({
+    summary: "Deploy TransparentUpgradeableProxy",
+    description: "Returns transaction data for deploying a TransparentUpgradeableProxy",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a TransparentUpgradeableProxy",
+            content: {
+                "application/json": {
+                    schema: resolver(DeployTransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const DeployTransparentUpgradeableProxySchema = z.object({
+    implementation: AddressSchema.openapi("The address of the implementation contract"),
+    proxyAdminOwner: AddressSchema.openapi("The address of the proxy admin who is eligible to upgrade implementation"),
+    initData: HexStringSchema.openapi(`Encoded function call hex data for underlying implementation contract initialization.
+
+    Can be combined with "encodeFunctionData" of viem.
+    NOTE: The underlying implementation contract must have initialization function.
+    `),
+});
+export const CreateTransparentUpgradeableProxy = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", deployTransparentProxyRoute, validator("json", DeployTransparentUpgradeableProxySchema), async (c) => {
+        const { implementation, proxyAdminOwner, initData } = c.req.valid("json");
+        return c.json({
+            bytecode: transparentUpgradeableProxyBytecode,
+            abi: transparentUpgradeableProxyAbi,
+            args: [implementation, proxyAdminOwner, initData],
+        });
+    }),
+});
+// Issue generic ProxyAdmin contract
+const deployProxyAdminRoute = describeRoute({
+    summary: "Deploy ProxyAdmin",
+    description: "Returns transaction data for deploying a ProxyAdmin contract",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a ProxyAdmin contract",
+            content: {
+                "application/json": {
+                    schema: resolver(DeployTransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateProxyAdmin = createController({
+    build: (factory) => factory.createApp().get("/", deployProxyAdminRoute, async (c) => {
+        return c.json({
+            bytecode: proxyAdminBytecode,
+            abi: proxyAdminAbi,
+        });
+    }),
+});

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

@@ -0,0 +1,59 @@
+export declare const ProxyController: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {};
+            output: {
+                bytecode: `0x${string}`;
+                abi: any[];
+                args?: any[] | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deployProxyAdmin"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    implementation: string;
+                    proxyAdminOwner: string;
+                    initData: string;
+                };
+            };
+            output: {
+                bytecode: `0x${string}`;
+                abi: any[];
+                args?: any[] | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deployTransparentProxy"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    proxyAdminAddress: string;
+                    proxyAddress: string;
+                    newImplementation: string;
+                    data?: 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;
+        };
+    };
+}, "/upgradeTransparentProxy">, "/">>;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/issuance/proxy/index.js

@@ -0,0 +1,10 @@
+import { createController } from "../../common/controller.js";
+import { CreateProxyAdmin, CreateTransparentUpgradeableProxy } from "./deploy.js";
+import { UpgradeProxy } from "./upgrade.js";
+export const ProxyController = createController({
+    build: (factory) => factory
+        .createApp()
+        .route("/deployProxyAdmin", CreateProxyAdmin.build(factory))
+        .route("/deployTransparentProxy", CreateTransparentUpgradeableProxy.build(factory))
+        .route("/upgradeTransparentProxy", UpgradeProxy.build(factory)),
+});

package/dist/issuance/proxy/upgrade.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const UpgradeProxyRequestSchema: z.ZodObject<{
+    proxyAdminAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    proxyAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    newImplementation: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    data: 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 UpgradeProxy: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    proxyAdminAddress: string;
+                    proxyAddress: string;
+                    newImplementation: string;
+                    data?: 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=upgrade.d.ts.map

package/dist/issuance/proxy/upgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/upgrade.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,yBAAyB;;;;;iBAapC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;QAcvB,CAAC"}

package/dist/issuance/proxy/upgrade.js

@@ -0,0 +1,46 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { proxyAdminAbi } from "@evergonlabs/tmi-evm-contracts/proxyAdmin";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, HexStringSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+export const UpgradeProxyRequestSchema = z.object({
+    proxyAdminAddress: AddressSchema.openapi({
+        description: "The address of the ProxyAdmin contract that manages the proxy",
+    }),
+    proxyAddress: AddressSchema.openapi({
+        description: "The address of the transparent proxy contract to upgrade",
+    }),
+    newImplementation: AddressSchema.openapi({
+        description: "The address of the new implementation contract",
+    }),
+    data: HexStringSchema.optional().openapi({
+        description: "Initialization data",
+    }),
+});
+const upgradeRoute = describeRoute({
+    summary: "Upgrade Transparent Proxy Implementation",
+    description: "Returns transaction data for upgrading the implementation of a transparent proxy contract using ProxyAdmin",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for upgrading transparent proxy implementation via ProxyAdmin",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const UpgradeProxy = createController({
+    build: (factory) => factory.createApp().post("/", upgradeRoute, validator("json", UpgradeProxyRequestSchema), async (c) => {
+        const { proxyAdminAddress, proxyAddress, newImplementation, data } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: proxyAdminAddress,
+            abi: proxyAdminAbi,
+            functionName: "upgradeAndCall",
+            args: [proxyAddress, newImplementation, data || "0x"],
+        }));
+    }),
+});

package/dist/issuance/recover.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../src/issuance/recover.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;AAKvC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EAKpC,CAAC;AAkBH,wBAAgB,YAAY,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAa9D"}

package/dist/issuance/recover.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
+import { toHex } from "viem";
+export const RecoverErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    from: AddressSchema,
+    to: AddressSchema,
+    amount: z.coerce.bigint().nonnegative(),
+});
+const recoverRoute = describeRoute({
+    summary: "Recover Gated ERC20",
+    description: "Returns transaction data for recovering a gated ERC20 token from one address to another",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for recovering a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function recoverErc20(factory) {
+    return factory.createHandlers(recoverRoute, validator("json", RecoverErc20RequestSchema), async (c) => {
+        const { tokenAddress, from, to, amount } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: erc20GatedAbi,
+            functionName: "recover",
+            args: [from, to, toHex(amount)],
+        }));
+    });
+}

package/dist/issuance/renounceRole.d.ts

@@ -8,19 +8,19 @@ export declare const RenounceRoleSchema: z.ZodObject<{
     tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
 }, "strip", z.ZodTypeAny, {
     address: `0x${string}`;
-    role: Erc20GatedRole;
     tokenAddress: `0x${string}`;
+    role: Erc20GatedRole;
 }, {
     address: `0x${string}`;
-    role: Erc20GatedRole;
     tokenAddress: `0x${string}`;
+    role: Erc20GatedRole;
 }>;
 export declare function createRenounceRole<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}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };
@@ -28,23 +28,23 @@ export declare function createRenounceRole<E extends Env>(factory: Factory<E>):
     in: {
         json: {
             address: `0x${string}`;
-            role: Erc20GatedRole;
             tokenAddress: `0x${string}`;
+            role: Erc20GatedRole;
         };
     };
     out: {
         json: {
             address: `0x${string}`;
-            role: Erc20GatedRole;
             tokenAddress: `0x${string}`;
+            role: Erc20GatedRole;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };
@@ -52,23 +52,23 @@ export declare function createRenounceRole<E extends Env>(factory: Factory<E>):
     in: {
         json: {
             address: `0x${string}`;
-            role: Erc20GatedRole;
             tokenAddress: `0x${string}`;
+            role: Erc20GatedRole;
         };
     };
     out: {
         json: {
             address: `0x${string}`;
-            role: Erc20GatedRole;
             tokenAddress: `0x${string}`;
+            role: Erc20GatedRole;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };

package/dist/issuance/renounceRole.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi/zod";
 import { AddressSchema, toTransaction, TransactionSchema } from "../common/index.js";
-import { erc20GatedAbi } from "../common/abis/erc20Whitelisted.js";
+import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
 import { convertRoleToHash, Erc20GatedRole } from "../common/roles/erc20-gated-roles.js";
 // Define the schema for the renounce role request
 export const RenounceRoleSchema = z.object({

package/dist/issuance/transfer.d.ts

@@ -6,68 +6,68 @@ export declare const TransferErc20RequestSchema: z.ZodObject<{
     to: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
     amount: z.ZodBigInt;
 }, "strip", z.ZodTypeAny, {
-    to: `0x${string}`;
     tokenAddress: `0x${string}`;
     amount: bigint;
-}, {
     to: `0x${string}`;
+}, {
     tokenAddress: `0x${string}`;
     amount: bigint;
+    to: `0x${string}`;
 }>;
 export declare function transferErc20Token<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}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
     in: {
         json: {
-            to: `0x${string}`;
             tokenAddress: `0x${string}`;
             amount: bigint;
+            to: `0x${string}`;
         };
     };
     out: {
         json: {
-            to: `0x${string}`;
             tokenAddress: `0x${string}`;
             amount: bigint;
+            to: `0x${string}`;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: 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: {
-            to: `0x${string}`;
             tokenAddress: `0x${string}`;
             amount: bigint;
+            to: `0x${string}`;
         };
     };
     out: {
         json: {
-            to: `0x${string}`;
             tokenAddress: `0x${string}`;
             amount: bigint;
+            to: `0x${string}`;
         };
     };
 }, Promise<Response & import("hono").TypedResponse<{
     data: `0x${string}`;
     to: `0x${string}`;
     details: {
-        functionName: string;
         address: `0x${string}`;
+        functionName: string;
         abi: any[];
         args: any[];
     };