@evergonlabs/tmi-protocol-api 0.11.0-rc.2 → 0.11.0-rc.4

package/dist/issuance/erc721/burn.js

@@ -6,10 +6,12 @@ import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { erc721Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const BurnErc721RequestSchema = z.object({
+export const BurnErc721Request = z
+    .object({
     tokenAddress: AddressSchema,
     tokenId: Int256Json,
-});
+})
+    .openapi("BurnErc721Request");
 const burnRoute = describeRoute({
     summary: "Burn ERC721",
     description: "[TESTNET ONLY] Returns transaction data for burning an ERC721 token",
@@ -26,7 +28,7 @@ const burnRoute = describeRoute({
     },
 });
 export const BurnErc721 = createController({
-    build: (factory) => factory.createApp().post("/", burnRoute, validator("json", BurnErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", burnRoute, validator("json", BurnErc721Request), async (c) => {
         const { tokenAddress, tokenId } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

package/dist/issuance/erc721/default/deploy.d.ts

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const DeployErc721RequestSchema: z.ZodObject<{
+export declare const DeployErc721Request: z.ZodObject<{
     chainId: z.ZodUnion<[z.ZodLiteral<"11155111" | "84532" | "72080">, z.ZodLiteral<"11155111" | "84532" | "72080">, ...z.ZodLiteral<"11155111" | "84532" | "72080">[]]>;
     tokenName: z.ZodString;
     tokenSymbol: z.ZodString;

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

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,yBAAyB;;;;;;;iBAOpC,CAAC;AA6BH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,mBAAmB;;;;;;;iBASC,CAAC;AA6BlC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc721/default/deploy.js

@@ -6,14 +6,16 @@ import { erc721Tag } from "../tag.js";
 import { createController } from "../../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
 import { FactoryChainId, getFactories } from "../../../issuance/common/factories.js";
-export const DeployErc721RequestSchema = z.object({
+export const DeployErc721Request = z
+    .object({
     chainId: FactoryChainId.Schema,
     tokenName: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
     tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the NFT collection" }),
     baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
     defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
-});
+})
+    .openapi("DeployErc721Request");
 const deployErc721Route = describeRoute({
     summary: "Deploy ERC721 via factory",
     description: `[TESTNET ONLY] This contract has not been audited.
@@ -41,7 +43,7 @@ The deployed token supports:
     },
 });
 export const CreateErc721Token = createController({
-    build: (factory) => factory.createApp().post("/", deployErc721Route, validator("json", DeployErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", deployErc721Route, validator("json", DeployErc721Request), async (c) => {
         const { chainId, tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter } = c.req.valid("json");
         const factory = getFactories(chainId);
         return c.json(toTransaction({

package/dist/issuance/erc721/default/initialize.d.ts

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const InitializeErc721RequestSchema: z.ZodObject<{
+export declare const InitializeErc721Request: z.ZodObject<{
     tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     name: z.ZodString;
     symbol: z.ZodString;

package/dist/issuance/erc721/default/initialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/initialize.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,6BAA6B;;;;;;;iBAOxC,CAAC;AAkBH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAclC,CAAC"}
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/initialize.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,uBAAuB;;;;;;;iBASC,CAAC;AAkBtC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAclC,CAAC"}

package/dist/issuance/erc721/default/initialize.js

@@ -5,14 +5,16 @@ import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { erc721Tag } from "../tag.js";
 import { createController } from "../../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
-export const InitializeErc721RequestSchema = z.object({
+export const InitializeErc721Request = z
+    .object({
     tokenAddress: AddressSchema,
     name: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
     symbol: z.string().nonempty().openapi({ description: "Symbol of the NFT collection" }),
     baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
     defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
-});
+})
+    .openapi("InitializeErc721Request");
 const initializeRoute = describeRoute({
     summary: "Initialize ERC721",
     description: "[TESTNET ONLY] Returns transaction data for initializing an ERC721 token proxy contract",
@@ -29,7 +31,7 @@ const initializeRoute = describeRoute({
     },
 });
 export const InitializeDefaultErc721 = createController({
-    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeErc721Request), async (c) => {
         const { tokenAddress, name, symbol, baseURI, defaultAdmin, minter } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

package/dist/issuance/erc721/default/parseDeployEvent.d.ts

@@ -1,3 +1,16 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const ParseDefaultErc721DeployEventQuery: z.ZodObject<{
+    chainId: z.ZodUnion<[z.ZodLiteral<"11155111" | "84532" | "72080">, ...z.ZodLiteral<"11155111" | "84532" | "72080">[]]>;
+    hash: 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 ParseDefaultErc721DeployEventResponse: z.ZodObject<{
+    proxy: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    admin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    minter: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    name: z.ZodString;
+    symbol: z.ZodString;
+    baseURI: z.ZodString;
+}, z.core.$strip>;
 export declare const ParseDefaultErc721DeployEvent: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $get: {

package/dist/issuance/erc721/default/parseDeployEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/parseDeployEvent.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;aAoDxC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/parseDeployEvent.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,kCAAkC;;;iBAKC,CAAC;AAEjD,eAAO,MAAM,qCAAqC;;;;;;;iBASC,CAAC;AAEpD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;aA2CxC,CAAC"}

package/dist/issuance/erc721/default/parseDeployEvent.js

@@ -10,10 +10,22 @@ import { createController } from "../../../common/controller.js";
 import { HttpError } from "../../../common/http-error.js";
 import { AddressSchema, HashSchema } from "../../../common/index.js";
 import { FactoryChainIdQuery } from "../../../issuance/common/factories.js";
-const QuerySchema = z.object({
+export const ParseDefaultErc721DeployEventQuery = z
+    .object({
     chainId: FactoryChainIdQuery.openapi({ param: { name: "chainId", in: "query" } }),
     hash: HashSchema.openapi({ param: { name: "hash", in: "query" } }),
-});
+})
+    .openapi("ParseDefaultErc721DeployEventQuery");
+export const ParseDefaultErc721DeployEventResponse = z
+    .object({
+    proxy: AddressSchema,
+    admin: AddressSchema,
+    minter: AddressSchema,
+    name: z.string(),
+    symbol: z.string(),
+    baseURI: z.string(),
+})
+    .openapi("ParseDefaultErc721DeployEventResponse");
 export const ParseDefaultErc721DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get ERC721 TokenProxyConfigured event",
@@ -24,19 +36,12 @@ export const ParseDefaultErc721DeployEvent = createController({
                 description: "Returns parsed event log",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            proxy: AddressSchema,
-                            admin: AddressSchema,
-                            minter: AddressSchema,
-                            name: z.string(),
-                            symbol: z.string(),
-                            baseURI: z.string(),
-                        })),
+                        schema: resolver(ParseDefaultErc721DeployEventResponse),
                     },
                 },
             },
         },
-    }), validator("query", QuerySchema), async (c) => {
+    }), validator("query", ParseDefaultErc721DeployEventQuery), async (c) => {
         const params = c.req.valid("query");
         const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,

package/dist/issuance/erc721/gated/deploy.d.ts

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const DeployGatedErc721RequestSchema: z.ZodObject<{
+export declare const DeployGatedErc721Request: z.ZodObject<{
     chainId: z.ZodUnion<[z.ZodLiteral<"11155111" | "84532" | "72080">, z.ZodLiteral<"11155111" | "84532" | "72080">, ...z.ZodLiteral<"11155111" | "84532" | "72080">[]]>;
     tokenName: z.ZodString;
     tokenSymbol: z.ZodString;

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

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/gated/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,8BAA8B;;;;;;;;iBAUzC,CAAC;AA8BH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAiBjC,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/gated/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,wBAAwB;;;;;;;;iBAYC,CAAC;AA8BvC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAcjC,CAAC"}

package/dist/issuance/erc721/gated/deploy.js

@@ -7,7 +7,8 @@ import { createController } from "../../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
 import { DEFAULT_COMPILOT_SIGNER } from "../../../common/models/compilot.js";
 import { FactoryChainId, getFactories } from "../../../issuance/common/factories.js";
-export const DeployGatedErc721RequestSchema = z.object({
+export const DeployGatedErc721Request = z
+    .object({
     chainId: FactoryChainId.Schema,
     tokenName: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
     tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the NFT collection" }),
@@ -17,7 +18,8 @@ export const DeployGatedErc721RequestSchema = z.object({
     gatingSigner: AddressSchema.optional().openapi({
         description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
     }),
-});
+})
+    .openapi("DeployGatedErc721Request");
 const deployGatedErc721Route = describeRoute({
     summary: "Deploy gated ERC721 via factory",
     description: `[TESTNET ONLY] This contract has not been audited.
@@ -46,9 +48,7 @@ The deployed token supports:
     },
 });
 export const CreateGatedErc721Token = createController({
-    build: (factory) => factory
-        .createApp()
-        .post("/", deployGatedErc721Route, validator("json", DeployGatedErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", deployGatedErc721Route, validator("json", DeployGatedErc721Request), async (c) => {
         const { chainId, tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter, gatingSigner } = c.req.valid("json");
         const factory = getFactories(chainId);
         return c.json(toTransaction({

package/dist/issuance/erc721/gated/initialize.d.ts

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const InitializeGatedErc721RequestSchema: z.ZodObject<{
+export declare const InitializeGatedErc721Request: z.ZodObject<{
     tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     name: z.ZodString;
     symbol: z.ZodString;

package/dist/issuance/erc721/gated/initialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/gated/initialize.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,kCAAkC;;;;;;;;iBAU7C,CAAC;AAkBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAchC,CAAC"}
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/gated/initialize.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,4BAA4B;;;;;;;;iBAYC,CAAC;AAkB3C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAchC,CAAC"}

package/dist/issuance/erc721/gated/initialize.js

@@ -6,7 +6,8 @@ import { erc721Tag } from "../tag.js";
 import { createController } from "../../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
 import { DEFAULT_COMPILOT_SIGNER } from "../../../common/models/compilot.js";
-export const InitializeGatedErc721RequestSchema = z.object({
+export const InitializeGatedErc721Request = z
+    .object({
     tokenAddress: AddressSchema,
     name: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
     symbol: z.string().nonempty().openapi({ description: "Symbol of the NFT collection" }),
@@ -16,7 +17,8 @@ export const InitializeGatedErc721RequestSchema = z.object({
     gatingSigner: AddressSchema.optional().openapi({
         description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
     }),
-});
+})
+    .openapi("InitializeGatedErc721Request");
 const initializeRoute = describeRoute({
     summary: "Initialize gated ERC721",
     description: "[TESTNET ONLY] Returns transaction data for initializing a gated ERC721 token proxy contract",
@@ -33,7 +35,7 @@ const initializeRoute = describeRoute({
     },
 });
 export const InitializeGatedErc721 = createController({
-    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeGatedErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeGatedErc721Request), async (c) => {
         const { tokenAddress, name, symbol, baseURI, defaultAdmin, minter, gatingSigner } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

package/dist/issuance/erc721/gated/parseDeployEvent.d.ts

@@ -1,3 +1,16 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const ParseGatedErc721DeployEventQuery: z.ZodObject<{
+    chainId: z.ZodUnion<[z.ZodLiteral<"11155111" | "84532" | "72080">, ...z.ZodLiteral<"11155111" | "84532" | "72080">[]]>;
+    hash: 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 ParseGatedErc721DeployEventResponse: z.ZodObject<{
+    proxy: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    admin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    minter: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    name: z.ZodString;
+    symbol: z.ZodString;
+    baseURI: z.ZodString;
+}, z.core.$strip>;
 export declare const ParseGatedErc721DeployEvent: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $get: {

package/dist/issuance/erc721/gated/parseDeployEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/gated/parseDeployEvent.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;aAoDtC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/gated/parseDeployEvent.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,gCAAgC;;;iBAKC,CAAC;AAE/C,eAAO,MAAM,mCAAmC;;;;;;;iBASC,CAAC;AAElD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;aA2CtC,CAAC"}

package/dist/issuance/erc721/gated/parseDeployEvent.js

@@ -10,10 +10,22 @@ import { createController } from "../../../common/controller.js";
 import { HttpError } from "../../../common/http-error.js";
 import { AddressSchema, HashSchema } from "../../../common/index.js";
 import { FactoryChainIdQuery } from "../../../issuance/common/factories.js";
-const QuerySchema = z.object({
+export const ParseGatedErc721DeployEventQuery = z
+    .object({
     chainId: FactoryChainIdQuery.openapi({ param: { name: "chainId", in: "query" } }),
     hash: HashSchema.openapi({ param: { name: "hash", in: "query" } }),
-});
+})
+    .openapi("ParseGatedErc721DeployEventQuery");
+export const ParseGatedErc721DeployEventResponse = z
+    .object({
+    proxy: AddressSchema,
+    admin: AddressSchema,
+    minter: AddressSchema,
+    name: z.string(),
+    symbol: z.string(),
+    baseURI: z.string(),
+})
+    .openapi("ParseGatedErc721DeployEventResponse");
 export const ParseGatedErc721DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get gated ERC721 TokenProxyConfigured event",
@@ -24,19 +36,12 @@ export const ParseGatedErc721DeployEvent = createController({
                 description: "Returns parsed event log",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            proxy: AddressSchema,
-                            admin: AddressSchema,
-                            minter: AddressSchema,
-                            name: z.string(),
-                            symbol: z.string(),
-                            baseURI: z.string(),
-                        })),
+                        schema: resolver(ParseGatedErc721DeployEventResponse),
                     },
                 },
             },
         },
-    }), validator("query", QuerySchema), async (c) => {
+    }), validator("query", ParseGatedErc721DeployEventQuery), async (c) => {
         const params = c.req.valid("query");
         const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,

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

@@ -1,3 +1,11 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetMintedErc721TokenIdQuery: z.ZodObject<{
+    chainId: z.ZodUnion<[z.ZodLiteral<"11155111" | "84532" | "72080">, ...z.ZodLiteral<"11155111" | "84532" | "72080">[]]>;
+    hash: 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 GetMintedErc721TokenIdResponse: z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>;
 export declare const GetMintedTokenId: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $get: {

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

@@ -1 +1 @@
-{"version":3,"file":"getMintedTokenId.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/getMintedTokenId.ts"],"names":[],"mappings":"AA6CA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;aAyC3B,CAAC"}
+{"version":3,"file":"getMintedTokenId.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/getMintedTokenId.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAmCxD,eAAO,MAAM,2BAA2B;;;iBAKC,CAAC;AAE1C,eAAO,MAAM,8BAA8B;;iBAIC,CAAC;AAE7C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;aAuC3B,CAAC"}

package/dist/issuance/erc721/getMintedTokenId.js

@@ -31,10 +31,17 @@ function extractTokenIdFromMintReceipt(receipt) {
     }
     return event.args.tokenId.toString();
 }
-const QuerySchema = z.object({
+export const GetMintedErc721TokenIdQuery = z
+    .object({
     chainId: FactoryChainIdQuery.openapi({ param: { name: "chainId", in: "query" } }),
     hash: HashSchema.openapi({ param: { name: "hash", in: "query" } }),
-});
+})
+    .openapi("GetMintedErc721TokenIdQuery");
+export const GetMintedErc721TokenIdResponse = z
+    .object({
+    tokenId: z.string(),
+})
+    .openapi("GetMintedErc721TokenIdResponse");
 export const GetMintedTokenId = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get minted ERC721 token ID",
@@ -45,14 +52,12 @@ export const GetMintedTokenId = createController({
                 description: "Returns the minted token ID",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            tokenId: z.string(),
-                        })),
+                        schema: resolver(GetMintedErc721TokenIdResponse),
                     },
                 },
             },
         },
-    }), validator("query", QuerySchema), async (c) => {
+    }), validator("query", GetMintedErc721TokenIdQuery), async (c) => {
         const { chainId, hash } = c.req.valid("query");
         const receipt = await waitForTransactionReceipt(getPublicClient(chainId, c.env.config), { hash });
         try {

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

@@ -1,6 +1,6 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
-export declare const GrantRoleErc721RequestSchema: z.ZodObject<{
+export declare const GrantRoleErc721Request: 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 Erc721TokenRole>;
     account: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;

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

@@ -1 +1 @@
-{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/grantRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAgC,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAEvG,eAAO,MAAM,4BAA4B;;;;iBAOvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;aAc1B,CAAC"}
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/grantRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAgC,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAEvG,eAAO,MAAM,sBAAsB;;;;iBASC,CAAC;AAkBrC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;aAc1B,CAAC"}

package/dist/issuance/erc721/grantRole.js

@@ -6,14 +6,16 @@ import { erc721Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { convertErc721TokenRoleToHash, Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
-export const GrantRoleErc721RequestSchema = z.object({
+export const GrantRoleErc721Request = z
+    .object({
     tokenAddress: AddressSchema,
-    role: z.nativeEnum(Erc721TokenRole).openapi({
+    role: z.enum(Erc721TokenRole).openapi({
         description: "The role to grant",
         example: Erc721TokenRole.MINTER_ROLE,
     }),
     account: AddressSchema.openapi({ description: "The address to grant the role to" }),
-});
+})
+    .openapi("GrantRoleErc721Request");
 const grantRoleRoute = describeRoute({
     summary: "Grant role on ERC721",
     description: "[TESTNET ONLY] Returns transaction data for granting a role on the ERC721 token contract",
@@ -30,7 +32,7 @@ const grantRoleRoute = describeRoute({
     },
 });
 export const GrantRoleErc721 = createController({
-    build: (factory) => factory.createApp().post("/", grantRoleRoute, validator("json", GrantRoleErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", grantRoleRoute, validator("json", GrantRoleErc721Request), async (c) => {
         const { tokenAddress, role, account } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const MintErc721RequestSchema: z.ZodObject<{
+export declare const MintErc721Request: 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}`>>;
 }, z.core.$strip>;

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

@@ -1 +1 @@
-{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/mint.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAmBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;aAcrB,CAAC"}
+{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/mint.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,iBAAiB;;;iBAKC,CAAC;AAmBhC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;aAcrB,CAAC"}

package/dist/issuance/erc721/mint.js

@@ -5,10 +5,12 @@ import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { erc721Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const MintErc721RequestSchema = z.object({
+export const MintErc721Request = z
+    .object({
     tokenAddress: AddressSchema,
     to: AddressSchema.openapi({ description: "Address to mint the token to" }),
-});
+})
+    .openapi("MintErc721Request");
 const mintRoute = describeRoute({
     summary: "Mint ERC721",
     description: "[TESTNET ONLY] Returns transaction data for minting an ERC721 token with an auto-generated token ID (MINTER_ROLE required)",
@@ -25,7 +27,7 @@ const mintRoute = describeRoute({
     },
 });
 export const MintErc721 = createController({
-    build: (factory) => factory.createApp().post("/", mintRoute, validator("json", MintErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", mintRoute, validator("json", MintErc721Request), async (c) => {
         const { tokenAddress, to } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const RecoverErc721RequestSchema: z.ZodObject<{
+export declare const RecoverErc721Request: 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}`>>;

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":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,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":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,oBAAoB;;;;;iBAOC,CAAC;AAmBnC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}

package/dist/issuance/erc721/recover.js

@@ -6,12 +6,14 @@ import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { erc721Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const RecoverErc721RequestSchema = z.object({
+export const RecoverErc721Request = z
+    .object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to recover the token from" }),
     to: AddressSchema.openapi({ description: "Address to recover the token to" }),
     tokenId: Int256Json,
-});
+})
+    .openapi("RecoverErc721Request");
 const recoverRoute = describeRoute({
     summary: "Recover ERC721",
     description: "[TESTNET ONLY] Returns transaction data for recovering an ERC721 token from one address to another (RECOVER_ROLE required)",
@@ -28,7 +30,7 @@ const recoverRoute = describeRoute({
     },
 });
 export const RecoverErc721 = createController({
-    build: (factory) => factory.createApp().post("/", recoverRoute, validator("json", RecoverErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", recoverRoute, validator("json", RecoverErc721Request), async (c) => {
         const { tokenAddress, from, to, tokenId } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,6 +1,6 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
-export declare const RenounceRoleErc721RequestSchema: z.ZodObject<{
+export declare const RenounceRoleErc721Request: 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 Erc721TokenRole>;
     callerConfirmation: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;

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":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAgC,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAEvG,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":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAgC,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAEvG,eAAO,MAAM,yBAAyB;;;;iBASC,CAAC;AAkBxC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}

package/dist/issuance/erc721/renounceRole.js

@@ -6,14 +6,16 @@ import { erc721Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { convertErc721TokenRoleToHash, Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
-export const RenounceRoleErc721RequestSchema = z.object({
+export const RenounceRoleErc721Request = z
+    .object({
     tokenAddress: AddressSchema,
-    role: z.nativeEnum(Erc721TokenRole).openapi({
+    role: z.enum(Erc721TokenRole).openapi({
         description: "The role to renounce",
         example: Erc721TokenRole.MINTER_ROLE,
     }),
     callerConfirmation: AddressSchema.openapi({ description: "The caller's address for confirmation" }),
-});
+})
+    .openapi("RenounceRoleErc721Request");
 const renounceRoleRoute = describeRoute({
     summary: "Renounce role on ERC721",
     description: "[TESTNET ONLY] Returns transaction data for renouncing a role on the ERC721 token contract",
@@ -30,7 +32,7 @@ const renounceRoleRoute = describeRoute({
     },
 });
 export const RenounceRoleErc721 = createController({
-    build: (factory) => factory.createApp().post("/", renounceRoleRoute, validator("json", RenounceRoleErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", renounceRoleRoute, validator("json", RenounceRoleErc721Request), async (c) => {
         const { tokenAddress, role, callerConfirmation } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,6 +1,6 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
-export declare const RevokeRoleErc721RequestSchema: z.ZodObject<{
+export declare const RevokeRoleErc721Request: 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 Erc721TokenRole>;
     account: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;

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":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAgC,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAEvG,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":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAgC,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAEvG,eAAO,MAAM,uBAAuB;;;;iBASC,CAAC;AAkBtC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}

package/dist/issuance/erc721/revokeRole.js

@@ -6,14 +6,16 @@ import { erc721Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { convertErc721TokenRoleToHash, Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
-export const RevokeRoleErc721RequestSchema = z.object({
+export const RevokeRoleErc721Request = z
+    .object({
     tokenAddress: AddressSchema,
-    role: z.nativeEnum(Erc721TokenRole).openapi({
+    role: z.enum(Erc721TokenRole).openapi({
         description: "The role to revoke",
         example: Erc721TokenRole.MINTER_ROLE,
     }),
     account: AddressSchema.openapi({ description: "The address to revoke the role from" }),
-});
+})
+    .openapi("RevokeRoleErc721Request");
 const revokeRoleRoute = describeRoute({
     summary: "Revoke role on ERC721",
     description: "[TESTNET ONLY] Returns transaction data for revoking a role on the ERC721 token contract",
@@ -30,7 +32,7 @@ const revokeRoleRoute = describeRoute({
     },
 });
 export const RevokeRoleErc721 = createController({
-    build: (factory) => factory.createApp().post("/", revokeRoleRoute, validator("json", RevokeRoleErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", revokeRoleRoute, validator("json", RevokeRoleErc721Request), async (c) => {
         const { tokenAddress, role, account } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,