@evergonlabs/tmi-protocol-api 0.1.0

package/dist/issuance/approve.js

@@ -0,0 +1,36 @@
+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";
+export const ApproveErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    spender: AddressSchema,
+    amount: z.coerce.bigint().nonnegative(),
+});
+const approveRoute = describeRoute({
+    summary: "Approve Gated ERC20",
+    description: "Returns transaction data for approving spender to use a gated ERC20",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for approving a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function approveErc20Token(factory) {
+    return factory.createHandlers(approveRoute, validator("json", ApproveErc20RequestSchema), async (c) => {
+        const { tokenAddress, spender, amount } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: erc20GatedAbi,
+            functionName: "approve",
+            args: [spender, BigInt(amount).toString()],
+        }));
+    });
+}

package/dist/issuance/burn.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../src/issuance/burn.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,sBAAsB;;;;;;;;;;;;EAIjC,CAAC;AAkBH,wBAAgB,cAAc,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAahE"}

package/dist/issuance/burn.js

@@ -0,0 +1,36 @@
+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";
+export const BurnErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    amount: z.coerce.bigint().nonnegative(),
+    burnFrom: AddressSchema,
+});
+const burnRoute = describeRoute({
+    summary: "Burn Gated ERC20",
+    description: "Returns transaction data for burning a gated ERC20",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for burning a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function burnErc20Token(factory) {
+    return factory.createHandlers(burnRoute, validator("json", BurnErc20RequestSchema), async (c) => {
+        const { tokenAddress, amount, burnFrom } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: erc20GatedAbi,
+            functionName: "burnFrom",
+            args: [burnFrom, BigInt(amount).toString()],
+        }));
+    });
+}

package/dist/issuance/deploy.d.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare function createErc20Token<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    abi: any[];
+    bytecode: `0x${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, {}, Promise<Response & import("hono").TypedResponse<{
+    abi: any[];
+    bytecode: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+export declare const DeployErc1967ProxySchema: z.ZodObject<{
+    erc20Address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    tokenName: z.ZodString;
+    tokenSymbol: z.ZodString;
+    cap: z.ZodBigInt;
+    defaultAdmin: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    minter: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    cap: bigint;
+    erc20Address: `0x${string}`;
+    defaultAdmin: `0x${string}`;
+    minter: `0x${string}`;
+    tokenName: string;
+    tokenSymbol: string;
+}, {
+    cap: bigint;
+    erc20Address: `0x${string}`;
+    defaultAdmin: `0x${string}`;
+    minter: `0x${string}`;
+    tokenName: string;
+    tokenSymbol: string;
+}>;
+export declare function createErc1967Proxy<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    abi: any[];
+    args: any[];
+    bytecode: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            cap: bigint;
+            erc20Address: `0x${string}`;
+            defaultAdmin: `0x${string}`;
+            minter: `0x${string}`;
+            tokenName: string;
+            tokenSymbol: string;
+        };
+    };
+    out: {
+        json: {
+            cap: bigint;
+            erc20Address: `0x${string}`;
+            defaultAdmin: `0x${string}`;
+            minter: `0x${string}`;
+            tokenName: string;
+            tokenSymbol: string;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    abi: any[];
+    args: any[];
+    bytecode: `0x${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: {
+        json: {
+            cap: bigint;
+            erc20Address: `0x${string}`;
+            defaultAdmin: `0x${string}`;
+            minter: `0x${string}`;
+            tokenName: string;
+            tokenSymbol: string;
+        };
+    };
+    out: {
+        json: {
+            cap: bigint;
+            erc20Address: `0x${string}`;
+            defaultAdmin: `0x${string}`;
+            minter: `0x${string}`;
+            tokenName: string;
+            tokenSymbol: string;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    abi: any[];
+    args: any[];
+    bytecode: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=deploy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/issuance/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA+BvC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;qEAOlE;AAgCD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAiBpE"}

package/dist/issuance/deploy.js

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { describeRoute } from "hono-openapi";
+import { erc1967ProxyAbi, erc1967ProxyBytecode } from "@evergonlabs/tmi-evm-contracts/erc1967";
+import { resolver, validator } from "hono-openapi/zod";
+import { AddressSchema, HexStringSchema } from "../common/index.js";
+import { encodeFunctionData } from "viem";
+import { erc20GatedAbi, erc20GatedBytecode } from "../common/abis/erc20Whitelisted.js";
+const IssuanceDeployErc20Schema = z
+    .object({
+    bytecode: HexStringSchema,
+    abi: z.array(z.any()).openapi({
+        description: "ABI of a contract.",
+        type: "array",
+    }),
+})
+    .openapi({ ref: "IssuanceDeployErc20Schema" });
+const deployRoute = describeRoute({
+    summary: "Get Gated ERC20",
+    description: "Returns transaction data for deploying a gated ERC20",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(IssuanceDeployErc20Schema),
+                },
+            },
+        },
+    },
+});
+export function createErc20Token(factory) {
+    return factory.createHandlers(deployRoute, async (c) => {
+        return c.json({
+            bytecode: erc20GatedBytecode,
+            abi: erc20GatedAbi,
+        });
+    });
+}
+const IssuanceDeployErc1967Schema = z
+    .object({
+    bytecode: HexStringSchema.openapi({ description: "Bytecode of the smartcontract" }),
+    abi: z.array(z.any()).openapi({
+        description: "ABI of a contract.",
+        type: "array",
+    }),
+    args: z.array(z.any()).openapi({
+        description: "Arguments for the proxy initialization",
+        type: "array",
+    }),
+})
+    .openapi({ ref: "IssuanceDeployErc1967Schema" });
+const deployProxyRoute = describeRoute({
+    summary: "Get ERC1967Proxy",
+    description: "Returns transaction data for deploying a ERC1967Proxy",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a ERC1967Proxy",
+            content: {
+                "application/json": {
+                    schema: resolver(IssuanceDeployErc1967Schema),
+                },
+            },
+        },
+    },
+});
+export const DeployErc1967ProxySchema = z.object({
+    erc20Address: AddressSchema.openapi("The address of the deployed contract from `Get Gated ERC20`"),
+    tokenName: z.string(),
+    tokenSymbol: z.string(),
+    cap: z.coerce.bigint(),
+    defaultAdmin: AddressSchema,
+    minter: AddressSchema,
+});
+export function createErc1967Proxy(factory) {
+    return factory.createHandlers(deployProxyRoute, validator("json", DeployErc1967ProxySchema), async (c) => {
+        const { erc20Address, tokenName, tokenSymbol, cap, defaultAdmin, minter } = c.req.valid("json");
+        const gatingSigner = "0x29A75f22AC9A7303Abb86ce521Bb44C4C69028A0"; // todo: externalize
+        const initData = encodeFunctionData({
+            abi: erc20GatedAbi,
+            functionName: "init",
+            args: [tokenName, tokenSymbol, BigInt(cap), defaultAdmin, minter, gatingSigner],
+        });
+        return c.json({
+            bytecode: erc1967ProxyBytecode,
+            abi: erc1967ProxyAbi,
+            args: [erc20Address, initData],
+        });
+    });
+}

package/dist/issuance/grantRole.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import { Erc20GatedRole } from "../common/roles/erc20-gated-roles.js";
+export declare const GrantRoleSchema: z.ZodObject<{
+    role: z.ZodNativeEnum<typeof Erc20GatedRole>;
+    address: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    tokenAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+}, "strip", z.ZodTypeAny, {
+    address: `0x${string}`;
+    role: Erc20GatedRole;
+    tokenAddress: `0x${string}`;
+}, {
+    address: `0x${string}`;
+    role: Erc20GatedRole;
+    tokenAddress: `0x${string}`;
+}>;
+export declare function createGrantRole<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: {
+            address: `0x${string}`;
+            role: Erc20GatedRole;
+            tokenAddress: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            address: `0x${string}`;
+            role: Erc20GatedRole;
+            tokenAddress: `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: {
+            address: `0x${string}`;
+            role: Erc20GatedRole;
+            tokenAddress: `0x${string}`;
+        };
+    };
+    out: {
+        json: {
+            address: `0x${string}`;
+            role: Erc20GatedRole;
+            tokenAddress: `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=grantRole.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../src/issuance/grantRole.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;AAGvC,OAAO,EAAqB,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAGzF,eAAO,MAAM,eAAe;;;;;;;;;;;;EAO1B,CAAC;AAkBH,wBAAgB,eAAe,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAejE"}

package/dist/issuance/grantRole.js

@@ -0,0 +1,42 @@
+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 { convertRoleToHash, Erc20GatedRole } from "../common/roles/erc20-gated-roles.js";
+// Define the schema for the grant role request
+export const GrantRoleSchema = z.object({
+    role: z.nativeEnum(Erc20GatedRole).openapi({
+        description: "The role to grant to the address",
+        example: Erc20GatedRole.WHITELISTED_SPENDER_ROLE,
+    }),
+    address: AddressSchema.openapi("The address to grant the role to"),
+    tokenAddress: AddressSchema.openapi("The address of the ERC20 token contract"),
+});
+const grantRoleRoute = describeRoute({
+    summary: "Grant Role to Address",
+    description: "Returns transaction data for granting a role to an address",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for granting a role",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export function createGrantRole(factory) {
+    return factory.createHandlers(grantRoleRoute, validator("json", GrantRoleSchema), async (c) => {
+        const { role, address, tokenAddress } = c.req.valid("json");
+        const roleHash = convertRoleToHash(role);
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: erc20GatedAbi,
+            functionName: "grantRole",
+            args: [roleHash, address],
+        }));
+    });
+}

package/dist/issuance/index.d.ts

@@ -0,0 +1,189 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+export declare const issuanceApis: {
+    name: string;
+    createApp: <E extends Env>(factory: Factory<E>) => import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+        "/erc20": {
+            $get: {
+                input: {};
+                output: {
+                    abi: any[];
+                    bytecode: `0x${string}`;
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/erc20/mint": {
+            $post: {
+                input: {
+                    json: {
+                        tokenAddress: `0x${string}`;
+                        amount: bigint;
+                        mintTo: `0x${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;
+            };
+        };
+    } & {
+        "/erc20/burn": {
+            $post: {
+                input: {
+                    json: {
+                        tokenAddress: `0x${string}`;
+                        amount: bigint;
+                        burnFrom: `0x${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;
+            };
+        };
+    } & {
+        "/erc20/approve": {
+            $post: {
+                input: {
+                    json: {
+                        tokenAddress: `0x${string}`;
+                        amount: bigint;
+                        spender: `0x${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;
+            };
+        };
+    } & {
+        "/erc20/transfer": {
+            $post: {
+                input: {
+                    json: {
+                        to: `0x${string}`;
+                        tokenAddress: `0x${string}`;
+                        amount: bigint;
+                    };
+                };
+                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;
+            };
+        };
+    } & {
+        "/erc20/proxy": {
+            $post: {
+                input: {
+                    json: {
+                        cap: bigint;
+                        erc20Address: `0x${string}`;
+                        defaultAdmin: `0x${string}`;
+                        minter: `0x${string}`;
+                        tokenName: string;
+                        tokenSymbol: string;
+                    };
+                };
+                output: {
+                    abi: any[];
+                    args: any[];
+                    bytecode: `0x${string}`;
+                };
+                outputFormat: "json";
+                status: import("hono/utils/http-status").ContentfulStatusCode;
+            };
+        };
+    } & {
+        "/erc20/grantRole": {
+            $post: {
+                input: {
+                    json: {
+                        address: `0x${string}`;
+                        role: import("../common/roles/erc20-gated-roles.js").Erc20GatedRole;
+                        tokenAddress: `0x${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;
+            };
+        };
+    } & {
+        "/erc20/renounceRole": {
+            $post: {
+                input: {
+                    json: {
+                        address: `0x${string}`;
+                        role: import("../common/roles/erc20-gated-roles.js").Erc20GatedRole;
+                        tokenAddress: `0x${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;
+            };
+        };
+    }, "/issuance">, "/">;
+    config: {
+        title: string;
+        description: string;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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;AAUvC,eAAO,MAAM,YAAY;;gBAEX,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkB/C,CAAC"}

package/dist/issuance/index.js

@@ -0,0 +1,25 @@
+import { createApiConfig } from "../common/app.js";
+import { approveErc20Token } from "./approve.js";
+import { burnErc20Token } from "./burn.js";
+import { createErc1967Proxy, createErc20Token } from "./deploy.js";
+import { mintErc20Token } from "./mint.js";
+import { transferErc20Token } from "./transfer.js";
+import { createGrantRole } from "./grantRole.js";
+import { createRenounceRole } from "./renounceRole.js";
+export const issuanceApis = {
+    name: "Issuance APIs",
+    createApp: (factory) => factory.createApp().route("/issuance", 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))),
+    config: createApiConfig({
+        title: "Issuance API",
+        description: "APIs for issuing tokens",
+    }),
+};