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

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

@@ -65,7 +65,7 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
                 proxy: `0x${string}`;
                 admin: `0x${string}`;
                 minter: `0x${string}`;
-                supplyCap: string;
+                supplyCap: string & import("zod").$brand<"Int256">;
                 name: string;
                 symbol: string;
             };
@@ -142,7 +142,7 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
                 proxy: `0x${string}`;
                 admin: `0x${string}`;
                 minter: `0x${string}`;
-                supplyCap: string;
+                supplyCap: string & import("zod").$brand<"Int256">;
                 name: string;
                 symbol: string;
             };
@@ -155,9 +155,291 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
         $get: {
             input: {};
             output: {
-                bytecode: `0x${string}`;
-                abi: any[];
-                args?: any[] | undefined;
+                bytecode: string;
+                abi: ({
+                    inputs: never[];
+                    stateMutability: "nonpayable";
+                    type: "constructor";
+                } | {
+                    inputs: ({
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    } | {
+                        internalType: string;
+                        name: string;
+                        type: "bytes32";
+                    })[];
+                    name: string;
+                    type: "error";
+                } | {
+                    inputs: ({
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    } | {
+                        internalType: string;
+                        name: string;
+                        type: "uint256";
+                    })[];
+                    name: string;
+                    type: "error";
+                } | {
+                    anonymous: false;
+                    inputs: ({
+                        indexed: true;
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    } | {
+                        indexed: false;
+                        internalType: string;
+                        name: string;
+                        type: "uint256";
+                    })[];
+                    name: string;
+                    type: "event";
+                } | {
+                    anonymous: false;
+                    inputs: {
+                        indexed: false;
+                        internalType: string;
+                        name: string;
+                        type: "uint64";
+                    }[];
+                    name: string;
+                    type: "event";
+                } | {
+                    anonymous: false;
+                    inputs: ({
+                        indexed: false;
+                        internalType: string;
+                        name: string;
+                        type: "uint256";
+                    } | {
+                        indexed: false;
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    } | {
+                        indexed: false;
+                        internalType: string;
+                        name: string;
+                        type: "bytes";
+                    })[];
+                    name: string;
+                    type: "event";
+                } | {
+                    anonymous: false;
+                    inputs: ({
+                        indexed: true;
+                        internalType: string;
+                        name: string;
+                        type: "bytes32";
+                    } | {
+                        indexed: true;
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    })[];
+                    name: string;
+                    type: "event";
+                } | {
+                    inputs: never[];
+                    name: string;
+                    outputs: {
+                        internalType: string;
+                        name: string;
+                        type: "string";
+                    }[];
+                    stateMutability: "view";
+                    type: "function";
+                } | {
+                    inputs: {
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    }[];
+                    name: string;
+                    outputs: {
+                        internalType: string;
+                        name: string;
+                        type: "uint256";
+                    }[];
+                    stateMutability: "view";
+                    type: "function";
+                } | {
+                    inputs: ({
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    } | {
+                        internalType: string;
+                        name: string;
+                        type: "uint256";
+                    })[];
+                    name: string;
+                    outputs: {
+                        internalType: string;
+                        name: string;
+                        type: "bool";
+                    }[];
+                    stateMutability: "nonpayable";
+                    type: "function";
+                } | {
+                    inputs: ({
+                        internalType: string;
+                        name: string;
+                        type: "address[]";
+                    } | {
+                        internalType: string;
+                        name: string;
+                        type: "uint256[]";
+                    })[];
+                    name: string;
+                    outputs: never[];
+                    stateMutability: "nonpayable";
+                    type: "function";
+                } | {
+                    inputs: never[];
+                    name: string;
+                    outputs: {
+                        internalType: string;
+                        name: string;
+                        type: "uint8";
+                    }[];
+                    stateMutability: "view";
+                    type: "function";
+                } | {
+                    inputs: {
+                        components: ({
+                            internalType: string;
+                            name: string;
+                            type: "uint256";
+                        } | {
+                            internalType: string;
+                            name: string;
+                            type: "address";
+                        } | {
+                            internalType: string;
+                            name: string;
+                            type: "bytes";
+                        })[];
+                        internalType: string;
+                        name: string;
+                        type: "tuple";
+                    }[];
+                    name: string;
+                    outputs: {
+                        internalType: string;
+                        name: string;
+                        type: "bytes32";
+                    }[];
+                    stateMutability: "pure";
+                    type: "function";
+                } | {
+                    inputs: {
+                        internalType: string;
+                        name: string;
+                        type: "bytes32";
+                    }[];
+                    name: string;
+                    outputs: {
+                        internalType: string;
+                        name: string;
+                        type: "bytes32";
+                    }[];
+                    stateMutability: "view";
+                    type: "function";
+                } | {
+                    inputs: ({
+                        internalType: string;
+                        name: string;
+                        type: "bytes32";
+                    } | {
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    })[];
+                    name: string;
+                    outputs: never[];
+                    stateMutability: "nonpayable";
+                    type: "function";
+                } | {
+                    inputs: ({
+                        internalType: string;
+                        name: string;
+                        type: "bytes32";
+                    } | {
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    })[];
+                    name: string;
+                    outputs: {
+                        internalType: string;
+                        name: string;
+                        type: "bool";
+                    }[];
+                    stateMutability: "view";
+                    type: "function";
+                } | {
+                    inputs: ({
+                        internalType: string;
+                        name: string;
+                        type: "string";
+                    } | {
+                        internalType: string;
+                        name: string;
+                        type: "uint256";
+                    } | {
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    })[];
+                    name: string;
+                    outputs: never[];
+                    stateMutability: "nonpayable";
+                    type: "function";
+                } | {
+                    inputs: {
+                        internalType: string;
+                        name: string;
+                        type: "bytes4";
+                    }[];
+                    name: string;
+                    outputs: {
+                        internalType: string;
+                        name: string;
+                        type: "bool";
+                    }[];
+                    stateMutability: "view";
+                    type: "function";
+                } | {
+                    inputs: never[];
+                    name: string;
+                    outputs: {
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    }[];
+                    stateMutability: "view";
+                    type: "function";
+                } | {
+                    inputs: ({
+                        internalType: string;
+                        name: string;
+                        type: "address";
+                    } | {
+                        internalType: string;
+                        name: string;
+                        type: "bytes";
+                    })[];
+                    name: string;
+                    outputs: never[];
+                    stateMutability: "payable";
+                    type: "function";
+                })[];
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;
@@ -165,9 +447,9 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
     };
 }, "/deployGatedSimple"> | import("hono/types").MergeSchemaPath<{
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     tokenName: string;
                     tokenSymbol: string;
                     cap: string;

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

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

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

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const MintErc20RequestSchema: z.ZodObject<{
+export declare const MintErc20Request: 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.core.$ZodBranded<z.ZodString, "Int256", "out">;

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

@@ -1 +1 @@
-{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/mint.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}
+{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/mint.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,gBAAgB;;;;iBAMC,CAAC;AAkB/B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}

package/dist/issuance/erc20/mint.js

@@ -6,11 +6,13 @@ import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { erc20Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const MintErc20RequestSchema = z.object({
+export const MintErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
     to: AddressSchema.openapi({ description: "Address to mint tokens to" }),
     amount: Int256Json,
-});
+})
+    .openapi("MintErc20Request");
 const mintRoute = describeRoute({
     summary: "Mint gated ERC20",
     description: "Returns transaction data for minting a gated ERC20 (MINTER_ROLE required)",
@@ -27,7 +29,7 @@ const mintRoute = describeRoute({
     },
 });
 export const MintErc20Token = createController({
-    build: (factory) => factory.createApp().post("/", mintRoute, validator("json", MintErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", mintRoute, validator("json", MintErc20Request), async (c) => {
         const { tokenAddress, to, amount } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const RecoverErc20RequestSchema: z.ZodObject<{
+export declare const RecoverErc20Request: 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/erc20/recover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/recover.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,yBAAyB;;;;;iBAKpC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;aAcvB,CAAC"}
+{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/recover.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,mBAAmB;;;;;iBAOC,CAAC;AAmBlC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;aAcvB,CAAC"}

package/dist/issuance/erc20/recover.js

@@ -6,12 +6,14 @@ import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { erc20Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const RecoverErc20RequestSchema = z.object({
+export const RecoverErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to recover tokens from" }),
     to: AddressSchema.openapi({ description: "Address to recover tokens to" }),
     amount: Int256Json,
-});
+})
+    .openapi("RecoverErc20Request");
 const recoverRoute = describeRoute({
     summary: "Recover gated ERC20",
     description: "Returns transaction data for recovering a gated ERC20 token from one address to another (RECOVER_ROLE required)",
@@ -28,7 +30,7 @@ const recoverRoute = describeRoute({
     },
 });
 export const RecoverErc20 = createController({
-    build: (factory) => factory.createApp().post("/", recoverRoute, validator("json", RecoverErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", recoverRoute, validator("json", RecoverErc20Request), async (c) => {
         const { tokenAddress, from, to, amount } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,6 +1,6 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
-export declare const RenounceRoleErc20RequestSchema: z.ZodObject<{
+export declare const RenounceRoleErc20Request: 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 Erc20GatedRole>;
     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/erc20/renounceRole.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/renounceRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAqB,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAExF,eAAO,MAAM,8BAA8B;;;;iBAOzC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}
+{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/renounceRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAqB,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAExF,eAAO,MAAM,wBAAwB;;;;iBASC,CAAC;AAkBvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc20/renounceRole.js

@@ -6,14 +6,16 @@ import { erc20Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { convertRoleToHash, Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
-export const RenounceRoleErc20RequestSchema = z.object({
+export const RenounceRoleErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
-    role: z.nativeEnum(Erc20GatedRole).openapi({
+    role: z.enum(Erc20GatedRole).openapi({
         description: "The role to renounce",
         example: Erc20GatedRole.MINTER_ROLE,
     }),
     callerConfirmation: AddressSchema.openapi({ description: "The caller's address for confirmation" }),
-});
+})
+    .openapi("RenounceRoleErc20Request");
 const renounceRoleRoute = describeRoute({
     summary: "Renounce role on Gated ERC20",
     description: "Returns transaction data for renouncing a role on a gated ERC20 token contract",
@@ -30,7 +32,7 @@ const renounceRoleRoute = describeRoute({
     },
 });
 export const RenounceRoleErc20 = createController({
-    build: (factory) => factory.createApp().post("/", renounceRoleRoute, validator("json", RenounceRoleErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", renounceRoleRoute, validator("json", RenounceRoleErc20Request), async (c) => {
         const { tokenAddress, role, callerConfirmation } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,6 +1,6 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
-export declare const RevokeRoleErc20RequestSchema: z.ZodObject<{
+export declare const RevokeRoleErc20Request: 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 Erc20GatedRole>;
     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/erc20/revokeRole.d.ts.map

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

package/dist/issuance/erc20/revokeRole.js

@@ -6,14 +6,16 @@ import { erc20Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { convertRoleToHash, Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
-export const RevokeRoleErc20RequestSchema = z.object({
+export const RevokeRoleErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
-    role: z.nativeEnum(Erc20GatedRole).openapi({
+    role: z.enum(Erc20GatedRole).openapi({
         description: "The role to revoke",
         example: Erc20GatedRole.MINTER_ROLE,
     }),
     account: AddressSchema.openapi({ description: "The address to revoke the role from" }),
-});
+})
+    .openapi("RevokeRoleErc20Request");
 const revokeRoleRoute = describeRoute({
     summary: "Revoke role on Gated ERC20",
     description: "Returns transaction data for revoking a role on a gated ERC20 token contract",
@@ -30,7 +32,7 @@ const revokeRoleRoute = describeRoute({
     },
 });
 export const RevokeRoleErc20 = createController({
-    build: (factory) => factory.createApp().post("/", revokeRoleRoute, validator("json", RevokeRoleErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", revokeRoleRoute, validator("json", RevokeRoleErc20Request), async (c) => {
         const { tokenAddress, role, account } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

package/dist/issuance/erc20/transfer.d.ts

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const TransferErc20RequestSchema: z.ZodObject<{
+export declare const TransferErc20Request: 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.core.$ZodBranded<z.ZodString, "Int256", "out">;

package/dist/issuance/erc20/transfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transfer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transfer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,oBAAoB;;;;iBAMC,CAAC;AAkBnC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}

package/dist/issuance/erc20/transfer.js

@@ -6,11 +6,13 @@ import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { erc20Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const TransferErc20RequestSchema = z.object({
+export const TransferErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
     to: AddressSchema,
     amount: Int256Json,
-});
+})
+    .openapi("TransferErc20Request");
 const transferRoute = describeRoute({
     summary: "Transfer gated ERC20",
     description: "Returns transaction data for transferring a gated ERC20 token to another address",
@@ -27,7 +29,7 @@ const transferRoute = describeRoute({
     },
 });
 export const TransferErc20 = createController({
-    build: (factory) => factory.createApp().post("/", transferRoute, validator("json", TransferErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", transferRoute, validator("json", TransferErc20Request), async (c) => {
         const { tokenAddress, to, amount } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

package/dist/issuance/erc20/transferFrom.d.ts

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const TransferFromErc20RequestSchema: z.ZodObject<{
+export declare const TransferFromErc20Request: 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/erc20/transferFrom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transferFrom.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,8BAA8B;;;;;iBAKzC,CAAC;AAmBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}
+{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transferFrom.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,wBAAwB;;;;;iBAOC,CAAC;AAmBvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc20/transferFrom.js

@@ -6,12 +6,14 @@ import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { erc20Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const TransferFromErc20RequestSchema = z.object({
+export const TransferFromErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to transfer tokens from" }),
     to: AddressSchema.openapi({ description: "Address to transfer tokens to" }),
     amount: Int256Json,
-});
+})
+    .openapi("TransferFromErc20Request");
 const transferFromRoute = describeRoute({
     summary: "TransferFrom gated ERC20",
     description: "Returns transaction data for transferring a gated ERC20 token from one address to another (requires approval)",
@@ -28,7 +30,7 @@ const transferFromRoute = describeRoute({
     },
 });
 export const TransferFromErc20 = createController({
-    build: (factory) => factory.createApp().post("/", transferFromRoute, validator("json", TransferFromErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", transferFromRoute, validator("json", TransferFromErc20Request), async (c) => {
         const { tokenAddress, from, to, amount } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const ApproveErc721RequestSchema: z.ZodObject<{
+export declare const ApproveErc721Request: 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}`>>;
     tokenId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;

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

@@ -1 +1 @@
-{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/approve.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}
+{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/approve.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,oBAAoB;;;;iBAMC,CAAC;AAkBnC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}

package/dist/issuance/erc721/approve.js

@@ -6,11 +6,13 @@ 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 ApproveErc721RequestSchema = z.object({
+export const ApproveErc721Request = z
+    .object({
     tokenAddress: AddressSchema,
     to: AddressSchema.openapi({ description: "Address to approve" }),
     tokenId: Int256Json,
-});
+})
+    .openapi("ApproveErc721Request");
 const approveRoute = describeRoute({
     summary: "Approve ERC721",
     description: "[TESTNET ONLY] Returns transaction data for approving an address to transfer a specific ERC721 token",
@@ -27,7 +29,7 @@ const approveRoute = describeRoute({
     },
 });
 export const ApproveErc721 = createController({
-    build: (factory) => factory.createApp().post("/", approveRoute, validator("json", ApproveErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", approveRoute, validator("json", ApproveErc721Request), async (c) => {
         const { tokenAddress, to, tokenId } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const BurnErc721RequestSchema: z.ZodObject<{
+export declare const BurnErc721Request: z.ZodObject<{
     tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     tokenId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
 }, z.core.$strip>;

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

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