@evergonlabs/tmi-protocol-api 0.10.0-rc.0 → 0.10.0-rc.2

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

@@ -0,0 +1,361 @@
+export declare const Erc1155Controller: 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;
+                    baseURI: 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: {
+                    tokenAddress: string;
+                    baseURI: string;
+                    defaultAdmin: 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;
+        };
+    };
+}, "/initialize"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                proxy: `0x${string}`;
+                admin: `0x${string}`;
+                minter: `0x${string}`;
+                baseURI: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/getDeployEvent"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    baseURI: 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<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    baseURI: 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;
+        };
+    };
+}, "/initializeGated"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                proxy: `0x${string}`;
+                admin: `0x${string}`;
+                minter: `0x${string}`;
+                baseURI: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/getDeployEventGated"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    to: string;
+                    amount: 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;
+        };
+    };
+}, "/mint"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    account: string;
+                    id: 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;
+        };
+    };
+}, "/burn"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    operator: string;
+                    approved: boolean;
+                };
+            };
+            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;
+        };
+    };
+}, "/setApprovalForAll"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    baseURI: 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;
+        };
+    };
+}, "/setBaseURI"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    id: string;
+                    tokenURI: 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;
+        };
+    };
+}, "/setTokenURI"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    from: string;
+                    to: string;
+                    id: 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").Erc1155TokenRole;
+                    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").Erc1155TokenRole;
+                    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").Erc1155TokenRole;
+                    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">, "/", "/">>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/index.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAsB5B,CAAC"}

package/dist/issuance/erc1155/index.js

@@ -0,0 +1,38 @@
+import { createController } from "../../common/controller.js";
+import { CreateErc1155Token } from "./default/deploy.js";
+import { InitializeDefaultErc1155 } from "./default/initialize.js";
+import { ParseDefaultErc1155DeployEvent } from "./default/parseDeployEvent.js";
+import { CreateGatedErc1155Token } from "./gated/deploy.js";
+import { InitializeGatedErc1155 } from "./gated/initialize.js";
+import { ParseGatedErc1155DeployEvent } from "./gated/parseDeployEvent.js";
+import { BurnErc1155 } from "./burn.js";
+import { GrantRoleErc1155 } from "./grantRole.js";
+import { MintErc1155 } from "./mint.js";
+import { RecoverErc1155 } from "./recover.js";
+import { RenounceRoleErc1155 } from "./renounceRole.js";
+import { RevokeRoleErc1155 } from "./revokeRole.js";
+import { SetApprovalForAllErc1155 } from "./setApprovalForAll.js";
+import { SetBaseURIErc1155 } from "./setBaseURI.js";
+import { SetTokenURIErc1155 } from "./setTokenURI.js";
+export const Erc1155Controller = createController({
+    build: (factory) => factory
+        .createApp()
+        // Default (non-gated) variant
+        .route("/deploy", CreateErc1155Token.build(factory))
+        .route("/initialize", InitializeDefaultErc1155.build(factory))
+        .route("/getDeployEvent", ParseDefaultErc1155DeployEvent.build(factory))
+        // Gated variant
+        .route("/deployGated", CreateGatedErc1155Token.build(factory))
+        .route("/initializeGated", InitializeGatedErc1155.build(factory))
+        .route("/getDeployEventGated", ParseGatedErc1155DeployEvent.build(factory))
+        // Common actions
+        .route("/mint", MintErc1155.build(factory))
+        .route("/burn", BurnErc1155.build(factory))
+        .route("/setApprovalForAll", SetApprovalForAllErc1155.build(factory))
+        .route("/setBaseURI", SetBaseURIErc1155.build(factory))
+        .route("/setTokenURI", SetTokenURIErc1155.build(factory))
+        .route("/recover", RecoverErc1155.build(factory))
+        .route("/grantRole", GrantRoleErc1155.build(factory))
+        .route("/revokeRole", RevokeRoleErc1155.build(factory))
+        .route("/renounceRole", RenounceRoleErc1155.build(factory)),
+});

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

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const MintErc1155RequestSchema: 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">>>;
+    data: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export declare const MintErc1155: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    to: string;
+                    amount: 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=mint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/mint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAC;AAmBH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;aActB,CAAC"}

package/dist/issuance/erc1155/mint.js

@@ -0,0 +1,40 @@
+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 { erc1155Tag } from "./tag.js";
+export const MintErc1155RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    to: AddressSchema.openapi({ description: "Address to mint tokens to" }),
+    amount: Int256BigInt(z.bigint().nonnegative()).openapi({ description: "Amount of tokens to mint" }),
+    data: z.string().optional().default("0x").openapi({ description: "Additional data (hex string)" }),
+});
+const mintRoute = describeRoute({
+    summary: "Mint ERC1155",
+    description: "Returns transaction data for minting ERC1155 tokens with an auto-generated token ID (MINTER_ROLE required)",
+    tags: [erc1155Tag.tag],
+    responses: {
+        200: {
+            description: "Returns transaction data for minting an ERC1155 token",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const MintErc1155 = createController({
+    build: (factory) => factory.createApp().post("/", mintRoute, validator("json", MintErc1155RequestSchema), async (c) => {
+        const { tokenAddress, to, amount, data } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc1155AutoIdPausableRecoverableUpgradeableAbi,
+            functionName: "mint",
+            args: [to, BigInt(amount), data],
+        }));
+    }),
+});

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const RecoverErc1155RequestSchema: 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}`>>;
+    id: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const RecoverErc1155: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    from: string;
+                    to: string;
+                    id: 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/erc1155/recover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/recover.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,2BAA2B;;;;;;iBAMtC,CAAC;AAmBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}

package/dist/issuance/erc1155/recover.js

@@ -0,0 +1,41 @@
+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 { erc1155Tag } from "./tag.js";
+export const RecoverErc1155RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    from: AddressSchema.openapi({ description: "Address to recover the tokens from" }),
+    to: AddressSchema.openapi({ description: "Address to recover the tokens to" }),
+    id: Int256BigInt(z.bigint().nonnegative()).openapi({ description: "Token ID to recover" }),
+    amount: Int256BigInt(z.bigint().nonnegative()).openapi({ description: "Amount of tokens to recover" }),
+});
+const recoverRoute = describeRoute({
+    summary: "Recover ERC1155",
+    description: "Returns transaction data for recovering ERC1155 tokens from one address to another (RECOVER_ROLE required)",
+    tags: [erc1155Tag.tag],
+    responses: {
+        200: {
+            description: "Returns transaction data for recovering ERC1155 tokens",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const RecoverErc1155 = createController({
+    build: (factory) => factory.createApp().post("/", recoverRoute, validator("json", RecoverErc1155RequestSchema), async (c) => {
+        const { tokenAddress, from, to, id, amount } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc1155AutoIdPausableRecoverableUpgradeableAbi,
+            functionName: "recover",
+            args: [from, to, BigInt(id), BigInt(amount)],
+        }));
+    }),
+});

package/dist/issuance/erc1155/renounceRole.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { Erc1155TokenRole } from "../../common/roles/erc1155-token-roles.js";
+export declare const RenounceRoleErc1155RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    role: z.ZodEnum<typeof Erc1155TokenRole>;
+    callerConfirmation: 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 RenounceRoleErc1155: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: Erc1155TokenRole;
+                    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;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=renounceRole.d.ts.map

package/dist/issuance/erc1155/renounceRole.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/renounceRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAiC,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAG5G,eAAO,MAAM,gCAAgC;;;;iBAO3C,CAAC;AAkBH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;aAc9B,CAAC"}

package/dist/issuance/erc1155/renounceRole.js

@@ -0,0 +1,42 @@
+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 { convertErc1155TokenRoleToHash, Erc1155TokenRole } from "../../common/roles/erc1155-token-roles.js";
+import { erc1155Tag } from "./tag.js";
+export const RenounceRoleErc1155RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    role: z.nativeEnum(Erc1155TokenRole).openapi({
+        description: "The role to renounce",
+        example: Erc1155TokenRole.MINTER_ROLE,
+    }),
+    callerConfirmation: AddressSchema.openapi({ description: "The caller's address for confirmation" }),
+});
+const renounceRoleRoute = describeRoute({
+    summary: "Renounce Role on ERC1155",
+    description: "Returns transaction data for renouncing a role on the ERC1155 token contract",
+    tags: [erc1155Tag.tag],
+    responses: {
+        200: {
+            description: "Returns transaction data for renouncing a role",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const RenounceRoleErc1155 = createController({
+    build: (factory) => factory.createApp().post("/", renounceRoleRoute, validator("json", RenounceRoleErc1155RequestSchema), async (c) => {
+        const { tokenAddress, role, callerConfirmation } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc1155AutoIdPausableRecoverableUpgradeableAbi,
+            functionName: "renounceRole",
+            args: [convertErc1155TokenRoleToHash(role), callerConfirmation],
+        }));
+    }),
+});