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

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

@@ -1 +1 @@
-{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/recover.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AAmBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}
+{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/recover.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AAmBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}

package/dist/issuance/erc721/recover.js

@@ -5,6 +5,7 @@ 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 { erc721Tag } from "./tag.js";
 export const RecoverErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to recover the token from" }),
@@ -14,7 +15,7 @@ export const RecoverErc721RequestSchema = z.object({
 const recoverRoute = describeRoute({
     summary: "Recover ERC721",
     description: "Returns transaction data for recovering an ERC721 token from one address to another (RECOVER_ROLE required)",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for recovering an ERC721 token",
@@ -31,7 +32,7 @@ export const RecoverErc721 = createController({
         const { tokenAddress, from, to, tokenId } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "recover",
             args: [from, to, BigInt(tokenId)],
         }));

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

@@ -1 +1 @@
-{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/renounceRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAgC,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAE3G,eAAO,MAAM,+BAA+B;;;;iBAO1C,CAAC;AAkBH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}
+{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/renounceRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAgC,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAG3G,eAAO,MAAM,+BAA+B;;;;iBAO1C,CAAC;AAkBH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}

package/dist/issuance/erc721/renounceRole.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { convertErc721TokenRoleToHash, Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
+import { erc721Tag } from "./tag.js";
 export const RenounceRoleErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     role: z.nativeEnum(Erc721TokenRole).openapi({
@@ -16,7 +17,7 @@ export const RenounceRoleErc721RequestSchema = z.object({
 const renounceRoleRoute = describeRoute({
     summary: "Renounce Role on ERC721",
     description: "Returns transaction data for renouncing a role on the ERC721 token contract",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for renouncing a role",
@@ -33,7 +34,7 @@ export const RenounceRoleErc721 = createController({
         const { tokenAddress, role, callerConfirmation } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "renounceRole",
             args: [convertErc721TokenRoleToHash(role), callerConfirmation],
         }));

package/dist/issuance/erc721/revokeRole.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"revokeRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/revokeRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAgC,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAE3G,eAAO,MAAM,6BAA6B;;;;iBAOxC,CAAC;AAkBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}
+{"version":3,"file":"revokeRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/revokeRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAgC,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAG3G,eAAO,MAAM,6BAA6B;;;;iBAOxC,CAAC;AAkBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}

package/dist/issuance/erc721/revokeRole.js

@@ -5,6 +5,7 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { convertErc721TokenRoleToHash, Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
+import { erc721Tag } from "./tag.js";
 export const RevokeRoleErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     role: z.nativeEnum(Erc721TokenRole).openapi({
@@ -16,7 +17,7 @@ export const RevokeRoleErc721RequestSchema = z.object({
 const revokeRoleRoute = describeRoute({
     summary: "Revoke Role on ERC721",
     description: "Returns transaction data for revoking a role on the ERC721 token contract",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for revoking a role",
@@ -33,7 +34,7 @@ export const RevokeRoleErc721 = createController({
         const { tokenAddress, role, account } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "revokeRole",
             args: [convertErc721TokenRoleToHash(role), account],
         }));

package/dist/issuance/erc721/setBaseURI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setBaseURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/setBaseURI.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAkBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}
+{"version":3,"file":"setBaseURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/setBaseURI.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAkBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}

package/dist/issuance/erc721/setBaseURI.js

@@ -4,6 +4,7 @@ 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 { erc721Tag } from "./tag.js";
 export const SetBaseURIRequestSchema = z.object({
     tokenAddress: AddressSchema,
     baseURI: z.string().nonempty().openapi({ description: "New base URI for token metadata" }),
@@ -11,7 +12,7 @@ export const SetBaseURIRequestSchema = z.object({
 const setBaseURIRoute = describeRoute({
     summary: "Set ERC721 Base URI",
     description: "Returns transaction data for setting the base URI on an ERC721 token",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for setting the base URI",
@@ -28,7 +29,7 @@ export const SetBaseURIErc721 = createController({
         const { tokenAddress, baseURI } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "setBaseURI",
             args: [baseURI],
         }));

package/dist/issuance/erc721/setTokenURI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setTokenURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/setTokenURI.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,wBAAwB;;;;iBAInC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}
+{"version":3,"file":"setTokenURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/setTokenURI.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,wBAAwB;;;;iBAInC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc721/setTokenURI.js

@@ -5,6 +5,7 @@ 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 { erc721Tag } from "./tag.js";
 export const SetTokenURIRequestSchema = z.object({
     tokenAddress: AddressSchema,
     tokenId: Int256BigInt(z.bigint().nonnegative()),
@@ -13,7 +14,7 @@ export const SetTokenURIRequestSchema = z.object({
 const setTokenURIRoute = describeRoute({
     summary: "Set ERC721 Token URI",
     description: "Returns transaction data for setting a token-specific URI on an ERC721 token",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for setting a token URI",
@@ -30,7 +31,7 @@ export const SetTokenURIErc721 = createController({
         const { tokenAddress, tokenId, tokenURI } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "setTokenURI",
             args: [BigInt(tokenId), tokenURI],
         }));

package/dist/issuance/erc721/tag.d.ts

@@ -0,0 +1,4 @@
+export declare const erc721Tag: {
+    tag: "ERC721";
+};
+//# sourceMappingURL=tag.d.ts.map

package/dist/issuance/erc721/tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/tag.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;CAAsB,CAAC"}

package/dist/issuance/erc721/tag.js

@@ -0,0 +1,2 @@
+import { createTag } from "../../common/tag.js";
+export const erc721Tag = createTag("ERC721");

package/dist/issuance/erc721/transferFrom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/transferFrom.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,+BAA+B;;;;;iBAK1C,CAAC;AAkBH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}
+{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/transferFrom.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,+BAA+B;;;;;iBAK1C,CAAC;AAkBH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}

package/dist/issuance/erc721/transferFrom.js

@@ -5,6 +5,7 @@ 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 { erc721Tag } from "./tag.js";
 export const TransferFromErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to transfer the token from" }),
@@ -14,7 +15,7 @@ export const TransferFromErc721RequestSchema = z.object({
 const transferFromRoute = describeRoute({
     summary: "Transfer ERC721",
     description: "Returns transaction data for transferring an ERC721 token from one address to another",
-    tags: ["Issuance"],
+    tags: [erc721Tag.tag],
     responses: {
         200: {
             description: "Returns transaction data for transferring an ERC721 token",
@@ -31,7 +32,7 @@ export const TransferFromErc721 = createController({
         const { tokenAddress, from, to, tokenId } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,
-            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            abi: abis.erc721AutoIdPausableRecoverableUpgradeableAbi,
             functionName: "transferFrom",
             args: [from, to, BigInt(tokenId)],
         }));

package/dist/issuance/index.d.ts

@@ -622,7 +622,6 @@ export declare const IssuanceApi: import("../common/controller.js").IApi<import(
                 json: {
                     tokenAddress: string;
                     to: string;
-                    tokenId: string;
                 };
             };
             output: {
@@ -809,6 +808,365 @@ export declare const IssuanceApi: import("../common/controller.js").IApi<import(
         };
     };
 }, "/setTokenURI">, "/erc721"> | import("hono/types").MergeSchemaPath<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">, "/erc1155"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
     "/": {
         $get: {
             input: {};

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/issuance/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAStB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/issuance/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAUtB,CAAC"}

package/dist/issuance/index.js

@@ -1,6 +1,7 @@
 import { createApi } from "../common/controller.js";
 import { Erc20Controller } from "./erc20/index.js";
 import { Erc721Controller } from "./erc721/index.js";
+import { Erc1155Controller } from "./erc1155/index.js";
 import { ProxyController } from "./proxy/index.js";
 export const IssuanceApi = createApi({
     title: "Issuance API",
@@ -9,5 +10,6 @@ export const IssuanceApi = createApi({
         .createApp()
         .route("/erc20", Erc20Controller.build(factory))
         .route("/erc721", Erc721Controller.build(factory))
+        .route("/erc1155", Erc1155Controller.build(factory))
         .route("/proxy", ProxyController.build(factory)),
 });

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;aAa5C,CAAC;AAoBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;aAQ3B,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4BxB,eAAO,MAAM,uCAAuC;;;;iBASlD,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;aAa5C,CAAC;AAoBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;aAQ3B,CAAC"}

package/dist/issuance/proxy/deploy.js

@@ -5,11 +5,12 @@ import { proxyAdminAbi, proxyAdminBytecode } from "@evergonlabs/tmi-evm-contract
 import { transparentUpgradeableProxyAbi, transparentUpgradeableProxyBytecode, } from "@evergonlabs/tmi-protocol-contracts/transparentProxy";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, DeployTransactionSchema, HexStringSchema } from "../../common/index.js";
+import { proxyTag } from "./tag.js";
 // Issue generic TUP contract
 const deployTransparentProxyRoute = describeRoute({
     summary: "Deploy TransparentUpgradeableProxy",
     description: "Returns transaction data for deploying a TransparentUpgradeableProxy",
-    tags: ["Issuance"],
+    tags: [proxyTag.tag],
     responses: {
         200: {
             description: "Returns transaction data for deploying a TransparentUpgradeableProxy",
@@ -46,7 +47,7 @@ export const CreateTransparentUpgradeableProxy = createController({
 const deployProxyAdminRoute = describeRoute({
     summary: "Deploy ProxyAdmin",
     description: "Returns transaction data for deploying a ProxyAdmin contract",
-    tags: ["Issuance"],
+    tags: [proxyTag.tag],
     responses: {
         200: {
             description: "Returns transaction data for deploying a ProxyAdmin contract",

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

@@ -0,0 +1,4 @@
+export declare const proxyTag: {
+    tag: "Proxy";
+};
+//# sourceMappingURL=tag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/tag.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;CAAqB,CAAC"}

package/dist/issuance/proxy/tag.js

@@ -0,0 +1,2 @@
+import { createTag } from "../../common/tag.js";
+export const proxyTag = createTag("Proxy");

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;aAcvB,CAAC"}
+{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/upgrade.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;;;iBAapC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;aAcvB,CAAC"}