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

package/dist/issuance/erc1155/mint.js

@@ -6,12 +6,14 @@ import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { erc1155Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const MintErc1155RequestSchema = z.object({
+export const MintErc1155Request = z
+    .object({
     tokenAddress: AddressSchema,
     to: AddressSchema.openapi({ description: "Address to mint tokens to" }),
     amount: Int256Json.openapi({ description: "Amount of tokens to mint" }),
     data: z.string().optional().default("0x").openapi({ description: "Additional data (hex string)" }),
-});
+})
+    .openapi("MintErc1155Request");
 const mintRoute = describeRoute({
     summary: "Mint ERC1155",
     description: "[TESTNET ONLY] Returns transaction data for minting ERC1155 tokens with an auto-generated token ID (MINTER_ROLE required)",
@@ -28,7 +30,7 @@ const mintRoute = describeRoute({
     },
 });
 export const MintErc1155 = createController({
-    build: (factory) => factory.createApp().post("/", mintRoute, validator("json", MintErc1155RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", mintRoute, validator("json", MintErc1155Request), async (c) => {
         const { tokenAddress, to, amount, data } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

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

@@ -1 +1 @@
-{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/recover.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,2BAA2B;;;;;;iBAMtC,CAAC;AAmBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}
+{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/recover.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,qBAAqB;;;;;;iBAQC,CAAC;AAmBpC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}

package/dist/issuance/erc1155/recover.js

@@ -6,13 +6,15 @@ import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { erc1155Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const RecoverErc1155RequestSchema = z.object({
+export const RecoverErc1155Request = z
+    .object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to recover the tokens from" }),
     to: AddressSchema.openapi({ description: "Address to recover the tokens to" }),
     id: Int256Json.openapi({ description: "Token ID to recover" }),
     amount: Int256Json.openapi({ description: "Amount of tokens to recover" }),
-});
+})
+    .openapi("RecoverErc1155Request");
 const recoverRoute = describeRoute({
     summary: "Recover ERC1155",
     description: "[TESTNET ONLY] Returns transaction data for recovering ERC1155 tokens from one address to another (RECOVER_ROLE required)",
@@ -29,7 +31,7 @@ const recoverRoute = describeRoute({
     },
 });
 export const RecoverErc1155 = createController({
-    build: (factory) => factory.createApp().post("/", recoverRoute, validator("json", RecoverErc1155RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", recoverRoute, validator("json", RecoverErc1155Request), async (c) => {
         const { tokenAddress, from, to, id, amount } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,6 +1,6 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Erc1155TokenRole } from "../../common/roles/erc1155-token-roles.js";
-export declare const RenounceRoleErc1155RequestSchema: z.ZodObject<{
+export declare const RenounceRoleErc1155Request: z.ZodObject<{
     tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     role: z.ZodEnum<typeof Erc1155TokenRole>;
     callerConfirmation: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;

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

@@ -1 +1 @@
-{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/renounceRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAiC,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAExG,eAAO,MAAM,gCAAgC;;;;iBAO3C,CAAC;AAkBH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;aAc9B,CAAC"}
+{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/renounceRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAiC,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAExG,eAAO,MAAM,0BAA0B;;;;iBASC,CAAC;AAkBzC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;aAc9B,CAAC"}

package/dist/issuance/erc1155/renounceRole.js

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

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

@@ -1,6 +1,6 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Erc1155TokenRole } from "../../common/roles/erc1155-token-roles.js";
-export declare const RevokeRoleErc1155RequestSchema: z.ZodObject<{
+export declare const RevokeRoleErc1155Request: z.ZodObject<{
     tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     role: z.ZodEnum<typeof Erc1155TokenRole>;
     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/erc1155/revokeRole.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"revokeRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/revokeRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAiC,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAExG,eAAO,MAAM,8BAA8B;;;;iBAOzC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}
+{"version":3,"file":"revokeRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/revokeRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAiC,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAExG,eAAO,MAAM,wBAAwB;;;;iBASC,CAAC;AAkBvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc1155/revokeRole.js

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"setApprovalForAll.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/setApprovalForAll.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,qCAAqC;;;;iBAIhD,CAAC;AAkBH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;aAgBnC,CAAC"}
+{"version":3,"file":"setApprovalForAll.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/setApprovalForAll.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,+BAA+B;;;;iBAMC,CAAC;AAkB9C,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;aAgBnC,CAAC"}

package/dist/issuance/erc1155/setApprovalForAll.js

@@ -5,11 +5,13 @@ import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { erc1155Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const SetApprovalForAllErc1155RequestSchema = z.object({
+export const SetApprovalForAllErc1155Request = z
+    .object({
     tokenAddress: AddressSchema,
     operator: AddressSchema.openapi({ description: "Address to grant/revoke approval for all tokens" }),
     approved: z.boolean().openapi({ description: "True to approve, false to revoke" }),
-});
+})
+    .openapi("SetApprovalForAllErc1155Request");
 const setApprovalForAllRoute = describeRoute({
     summary: "Set approval for all ERC1155",
     description: "[TESTNET ONLY] Returns transaction data for granting or revoking approval for all ERC1155 tokens",
@@ -28,7 +30,7 @@ const setApprovalForAllRoute = describeRoute({
 export const SetApprovalForAllErc1155 = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", setApprovalForAllRoute, validator("json", SetApprovalForAllErc1155RequestSchema), async (c) => {
+        .post("/", setApprovalForAllRoute, validator("json", SetApprovalForAllErc1155Request), async (c) => {
         const { tokenAddress, operator, approved } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"setBaseURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/setBaseURI.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAC;AAmBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}
+{"version":3,"file":"setBaseURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/setBaseURI.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,wBAAwB;;;iBAKC,CAAC;AAmBvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc1155/setBaseURI.js

@@ -5,10 +5,12 @@ import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { erc1155Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const SetBaseURIErc1155RequestSchema = z.object({
+export const SetBaseURIErc1155Request = z
+    .object({
     tokenAddress: AddressSchema,
     baseURI: z.string().nonempty().openapi({ description: "New base URI for token metadata" }),
-});
+})
+    .openapi("SetBaseURIErc1155Request");
 const setBaseURIRoute = describeRoute({
     summary: "Set base URI for ERC1155",
     description: "[TESTNET ONLY] Returns transaction data for setting the base URI for ERC1155 metadata (DEFAULT_ADMIN_ROLE gated)",
@@ -25,7 +27,7 @@ const setBaseURIRoute = describeRoute({
     },
 });
 export const SetBaseURIErc1155 = createController({
-    build: (factory) => factory.createApp().post("/", setBaseURIRoute, validator("json", SetBaseURIErc1155RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", setBaseURIRoute, validator("json", SetBaseURIErc1155Request), async (c) => {
         const { tokenAddress, baseURI } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"setTokenURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/setTokenURI.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,+BAA+B;;;;iBAI1C,CAAC;AAmBH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}
+{"version":3,"file":"setTokenURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/setTokenURI.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,yBAAyB;;;;iBAMC,CAAC;AAmBxC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}

package/dist/issuance/erc1155/setTokenURI.js

@@ -6,11 +6,13 @@ import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { erc1155Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const SetTokenURIErc1155RequestSchema = z.object({
+export const SetTokenURIErc1155Request = z
+    .object({
     tokenAddress: AddressSchema,
     id: Int256Json,
     tokenURI: z.string().nonempty().openapi({ description: "URI for the specific token metadata" }),
-});
+})
+    .openapi("SetTokenURIErc1155Request");
 const setTokenURIRoute = describeRoute({
     summary: "Set token URI for ERC1155",
     description: "[TESTNET ONLY] Returns transaction data for setting the URI for a specific ERC1155 token ID (DEFAULT_ADMIN_ROLE required)",
@@ -27,7 +29,7 @@ const setTokenURIRoute = describeRoute({
     },
 });
 export const SetTokenURIErc1155 = createController({
-    build: (factory) => factory.createApp().post("/", setTokenURIRoute, validator("json", SetTokenURIErc1155RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", setTokenURIRoute, validator("json", SetTokenURIErc1155Request), async (c) => {
         const { tokenAddress, id, tokenURI } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const ApproveErc20RequestSchema: z.ZodObject<{
+export declare const ApproveErc20Request: z.ZodObject<{
     tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     spender: 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/approve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/approve.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}
+{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/approve.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,mBAAmB;;;;iBAMC,CAAC;AAkBlC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc20/approve.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 ApproveErc20RequestSchema = z.object({
+export const ApproveErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
     spender: AddressSchema,
     amount: Int256Json,
-});
+})
+    .openapi("ApproveErc20Request");
 const approveRoute = describeRoute({
     summary: "Approve gated ERC20",
     description: "Returns transaction data for approving spender to use a gated ERC20",
@@ -27,7 +29,7 @@ const approveRoute = describeRoute({
     },
 });
 export const ApproveErc20Token = createController({
-    build: (factory) => factory.createApp().post("/", approveRoute, validator("json", ApproveErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", approveRoute, validator("json", ApproveErc20Request), async (c) => {
         const { tokenAddress, spender, amount } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const BurnErc20RequestSchema: z.ZodObject<{
+export declare const BurnErc20Request: z.ZodObject<{
     tokenAddress: 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">;
     burnFrom: 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/burn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/burn.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":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/burn.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/burn.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 BurnErc20RequestSchema = z.object({
+export const BurnErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
     amount: Int256Json,
     burnFrom: AddressSchema,
-});
+})
+    .openapi("BurnErc20Request");
 const burnRoute = describeRoute({
     summary: "Burn gated ERC20",
     description: "Returns transaction data for burning a gated ERC20",
@@ -27,7 +29,7 @@ const burnRoute = describeRoute({
     },
 });
 export const BurnErc20Token = createController({
-    build: (factory) => factory.createApp().post("/", burnRoute, validator("json", BurnErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", burnRoute, validator("json", BurnErc20Request), async (c) => {
         const { tokenAddress, amount, burnFrom } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

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

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/default/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,wBAAwB;;;;;;;iBAOnC,CAAC;AA6BH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAe3B,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/default/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,kBAAkB;;;;;;;iBASC,CAAC;AA6BjC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAe3B,CAAC"}

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

@@ -7,14 +7,16 @@ import { erc20Tag } 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 DeployErc20RequestSchema = z.object({
+export const DeployErc20Request = z
+    .object({
     chainId: FactoryChainId.Schema,
     tokenName: z.string().nonempty().openapi({ description: "Name of the ERC20 token" }),
     tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the ERC20 token" }),
     supplyCap: Int256Json,
     defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
-});
+})
+    .openapi("DeployErc20Request");
 const deployErc20Route = describeRoute({
     summary: "Deploy ERC20 via factory",
     description: `Returns transaction data for deploying a new ERC20 token via the factory contract.
@@ -42,7 +44,7 @@ The deployed token supports:
     },
 });
 export const CreateErc20Token = createController({
-    build: (factory) => factory.createApp().post("/", deployErc20Route, validator("json", DeployErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", deployErc20Route, validator("json", DeployErc20Request), async (c) => {
         const { chainId, tokenName, tokenSymbol, supplyCap, defaultTokenAdmin, minter } = c.req.valid("json");
         const factory = getFactories(chainId);
         return c.json(toTransaction({

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

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

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/default/initialize.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,mCAAmC;;;;;;;iBAO9C,CAAC;AAkBH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAgBjC,CAAC"}
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/default/initialize.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,6BAA6B;;;;;;;iBASC,CAAC;AAkB5C,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAcjC,CAAC"}

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

@@ -6,14 +6,16 @@ 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 InitializeDefaultErc20RequestSchema = z.object({
+export const InitializeDefaultErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
     name: z.string().nonempty().openapi({ description: "Name of the ERC20 token" }),
     symbol: z.string().nonempty().openapi({ description: "Symbol of the ERC20 token" }),
     cap: Int256Json,
     defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
-});
+})
+    .openapi("InitializeDefaultErc20Request");
 const initializeRoute = describeRoute({
     summary: "Initialize ERC20",
     description: "Returns transaction data for initializing an ERC20 token proxy contract",
@@ -30,9 +32,7 @@ const initializeRoute = describeRoute({
     },
 });
 export const InitializeDefaultErc20 = createController({
-    build: (factory) => factory
-        .createApp()
-        .post("/", initializeRoute, validator("json", InitializeDefaultErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeDefaultErc20Request), async (c) => {
         const { tokenAddress, name, symbol, cap, defaultAdmin, minter } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,3 +1,16 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const ParseDefaultErc20DeployEventQuery: 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 ParseDefaultErc20DeployEventResponse: 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}`>>;
+    supplyCap: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    name: z.ZodString;
+    symbol: z.ZodString;
+}, z.core.$strip>;
 export declare const ParseDefaultErc20DeployEvent: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $get: {
@@ -11,7 +24,7 @@ export declare const ParseDefaultErc20DeployEvent: import("../../../common/contr
                 proxy: `0x${string}`;
                 admin: `0x${string}`;
                 minter: `0x${string}`;
-                supplyCap: string;
+                supplyCap: string & z.core.$brand<"Int256">;
                 name: string;
                 symbol: string;
             };

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

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/default/parseDeployEvent.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;aAoDvC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/default/parseDeployEvent.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAUxD,eAAO,MAAM,iCAAiC;;;iBAKC,CAAC;AAEhD,eAAO,MAAM,oCAAoC;;;;;;;iBASC,CAAC;AAEnD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;aA8CvC,CAAC"}

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

@@ -4,17 +4,29 @@ import { parseEventLogs } from "viem";
 import { waitForTransactionReceipt } from "viem/actions";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { erc20Tag } from "../tag.js";
 import { getPublicClient } from "../../../common/blockchain.js";
 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 ParseDefaultErc20DeployEventQuery = z
+    .object({
     chainId: FactoryChainIdQuery.openapi({ param: { name: "chainId", in: "query" } }),
     hash: HashSchema.openapi({ param: { name: "hash", in: "query" } }),
-});
+})
+    .openapi("ParseDefaultErc20DeployEventQuery");
+export const ParseDefaultErc20DeployEventResponse = z
+    .object({
+    proxy: AddressSchema,
+    admin: AddressSchema,
+    minter: AddressSchema,
+    supplyCap: Int256Json,
+    name: z.string(),
+    symbol: z.string(),
+})
+    .openapi("ParseDefaultErc20DeployEventResponse");
 export const ParseDefaultErc20DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get ERC20 TokenProxyConfigured event",
@@ -25,19 +37,12 @@ export const ParseDefaultErc20DeployEvent = createController({
                 description: "Returns parsed event log",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            proxy: AddressSchema,
-                            admin: AddressSchema,
-                            minter: AddressSchema,
-                            supplyCap: Int256Json,
-                            name: z.string(),
-                            symbol: z.string(),
-                        })),
+                        schema: resolver(ParseDefaultErc20DeployEventResponse),
                     },
                 },
             },
         },
-    }), validator("query", QuerySchema), async (c) => {
+    }), validator("query", ParseDefaultErc20DeployEventQuery), async (c) => {
         const params = c.req.valid("query");
         const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,
@@ -48,23 +53,18 @@ export const ParseDefaultErc20DeployEvent = createController({
             logs: receipt.logs,
         });
         if (!event) {
-            throw new UnableParseDefaultErc20DeployEvent();
+            throw new HttpError(500, {
+                message: `Can't parse TokenProxyConfigured event. Make sure you're passing a transaction generated by the ERC20 factory \`deployAndInitializeProxy\` action`,
+                name: "UnableParseDefaultErc20DeployEvent",
+            });
         }
         return c.json({
             proxy: event.args.proxy,
             admin: event.args.admin,
             minter: event.args.minter,
-            supplyCap: event.args.supplyCap.toString(),
+            supplyCap: toInt256Json(event.args.supplyCap),
             name: event.args.name,
             symbol: event.args.symbol,
         });
     }),
 });
-class UnableParseDefaultErc20DeployEvent extends HttpError {
-    constructor() {
-        super(500, {
-            message: `Can't parse TokenProxyConfigured event. Make sure you're passing a transaction generated by the ERC20 factory \`deployAndInitializeProxy\` action`,
-            name: "UnableParseDefaultErc20DeployEvent",
-        });
-    }
-}

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

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

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gated/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,6BAA6B;;;;;;;;iBAUxC,CAAC;AAsBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAyBhC,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gated/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,uBAAuB;;;;;;;;iBAYC,CAAC;AAsBtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuBhC,CAAC"}

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

@@ -8,7 +8,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 DeployGatedErc20RequestSchema = z.object({
+export const DeployGatedErc20Request = z
+    .object({
     chainId: FactoryChainId.Schema,
     tokenName: z.string().nonempty().openapi({ description: "Name of the ERC20 token" }),
     tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the ERC20 token" }),
@@ -18,7 +19,8 @@ export const DeployGatedErc20RequestSchema = z.object({
     gatingSigner: AddressSchema.optional().openapi({
         description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
     }),
-});
+})
+    .openapi("DeployGatedErc20Request");
 const deployGatedErc20Route = describeRoute({
     summary: "Deploy gated ERC20 via factory",
     description: `Returns transaction data for deploying a new whitelist-gated ERC20 token via the factory contract.
@@ -39,9 +41,7 @@ Calls deployAndInitializeProxy on the ERC20GatedPausableRecoverableFactory to at
     },
 });
 export const CreateGatedErc20Token = createController({
-    build: (factory) => factory
-        .createApp()
-        .post("/", deployGatedErc20Route, validator("json", DeployGatedErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", deployGatedErc20Route, validator("json", DeployGatedErc20Request), async (c) => {
         const { chainId, tokenName, tokenSymbol, supplyCap, defaultTokenAdmin, minter, gatingSigner } = c.req.valid("json");
         const factory = getFactories(chainId);
         return c.json(toTransaction({

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

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