@evergonlabs/tmi-protocol-api 0.10.1 → 0.11.0-rc.1

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

@@ -1,10 +1,10 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const RecoverErc1155RequestSchema: z.ZodObject<{
     tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     from: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     to: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    id: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
-    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    id: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+    amount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
 }, z.core.$strip>;
 export declare const RecoverErc1155: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,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,2BAA2B;;;;;;iBAMtC,CAAC;AAmBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}

package/dist/issuance/erc1155/recover.js

@@ -1,17 +1,17 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+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";
-import { Int256BigInt } from "../../common/int256.js";
-import { erc1155Tag } from "./tag.js";
 export const RecoverErc1155RequestSchema = z.object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to recover the tokens from" }),
     to: AddressSchema.openapi({ description: "Address to recover the tokens to" }),
-    id: Int256BigInt(z.bigint().nonnegative()).openapi({ description: "Token ID to recover" }),
-    amount: Int256BigInt(z.bigint().nonnegative()).openapi({ description: "Amount of tokens to recover" }),
+    id: Int256Json.openapi({ description: "Token ID to recover" }),
+    amount: Int256Json.openapi({ description: "Amount of tokens to recover" }),
 });
 const recoverRoute = describeRoute({
     summary: "Recover ERC1155",

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

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

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAiC,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAG5G,eAAO,MAAM,gCAAgC;;;;iBAO3C,CAAC;AAkBH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;aAc9B,CAAC"}
+{"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"}

package/dist/issuance/erc1155/renounceRole.js

@@ -1,11 +1,11 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+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";
 import { convertErc1155TokenRoleToHash, Erc1155TokenRole } from "../../common/roles/erc1155-token-roles.js";
-import { erc1155Tag } from "./tag.js";
 export const RenounceRoleErc1155RequestSchema = z.object({
     tokenAddress: AddressSchema,
     role: z.nativeEnum(Erc1155TokenRole).openapi({

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

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Erc1155TokenRole } from "../../common/roles/erc1155-token-roles.js";
 export declare const RevokeRoleErc1155RequestSchema: z.ZodObject<{
     tokenAddress: 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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAiC,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAG5G,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,8BAA8B;;;;iBAOzC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc1155/revokeRole.js

@@ -1,11 +1,11 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+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";
 import { convertErc1155TokenRoleToHash, Erc1155TokenRole } from "../../common/roles/erc1155-token-roles.js";
-import { erc1155Tag } from "./tag.js";
 export const RevokeRoleErc1155RequestSchema = z.object({
     tokenAddress: AddressSchema,
     role: z.nativeEnum(Erc1155TokenRole).openapi({

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

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

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,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,qCAAqC;;;;iBAIhD,CAAC;AAkBH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;aAgBnC,CAAC"}

package/dist/issuance/erc1155/setApprovalForAll.js

@@ -1,10 +1,10 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+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";
-import { erc1155Tag } from "./tag.js";
 export const SetApprovalForAllErc1155RequestSchema = z.object({
     tokenAddress: AddressSchema,
     operator: AddressSchema.openapi({ description: "Address to grant/revoke approval for all tokens" }),

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

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

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,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,8BAA8B;;;iBAGzC,CAAC;AAmBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc1155/setBaseURI.js

@@ -1,10 +1,10 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+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";
-import { erc1155Tag } from "./tag.js";
 export const SetBaseURIErc1155RequestSchema = z.object({
     tokenAddress: AddressSchema,
     baseURI: z.string().nonempty().openapi({ description: "New base URI for token metadata" }),

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

@@ -1,7 +1,7 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const SetTokenURIErc1155RequestSchema: 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.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    id: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     tokenURI: z.ZodString;
 }, z.core.$strip>;
 export declare const SetTokenURIErc1155: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,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,+BAA+B;;;;iBAI1C,CAAC;AAmBH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}

package/dist/issuance/erc1155/setTokenURI.js

@@ -1,14 +1,14 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+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";
-import { Int256BigInt } from "../../common/int256.js";
-import { erc1155Tag } from "./tag.js";
 export const SetTokenURIErc1155RequestSchema = z.object({
     tokenAddress: AddressSchema,
-    id: Int256BigInt(z.bigint().nonnegative()),
+    id: Int256Json,
     tokenURI: z.string().nonempty().openapi({ description: "URI for the specific token metadata" }),
 });
 const setTokenURIRoute = describeRoute({

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

@@ -1,8 +1,8 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const ApproveErc20RequestSchema: 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.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    amount: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
 }, z.core.$strip>;
 export declare const ApproveErc20Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,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,yBAAyB;;;;iBAIpC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc20/approve.js

@@ -1,15 +1,15 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+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";
-import { Int256BigInt } from "../../common/int256.js";
-import { erc20Tag } from "./tag.js";
 export const ApproveErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     spender: AddressSchema,
-    amount: Int256BigInt(z.bigint().nonnegative()),
+    amount: Int256Json,
 });
 const approveRoute = describeRoute({
     summary: "Approve gated ERC20",

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

@@ -1,7 +1,7 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const BurnErc20RequestSchema: 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.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    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}`>>;
 }, z.core.$strip>;
 export declare const BurnErc20Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,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,sBAAsB;;;;iBAIjC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}

package/dist/issuance/erc20/burn.js

@@ -1,14 +1,14 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+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";
-import { Int256BigInt } from "../../common/int256.js";
-import { erc20Tag } from "./tag.js";
 export const BurnErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
-    amount: Int256BigInt(z.bigint().nonnegative()),
+    amount: Int256Json,
     burnFrom: AddressSchema,
 });
 const burnRoute = describeRoute({

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

@@ -1,9 +1,9 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const DeployErc20RequestSchema: z.ZodObject<{
-    chainId: z.ZodUnion<[z.ZodLiteral<11155111 | 72080>, z.ZodLiteral<11155111 | 72080>, ...z.ZodLiteral<11155111 | 72080>[]]>;
+    chainId: z.ZodUnion<[z.ZodLiteral<11155111 | 84532 | 72080>, z.ZodLiteral<11155111 | 84532 | 72080>, ...z.ZodLiteral<11155111 | 84532 | 72080>[]]>;
     tokenName: z.ZodString;
     tokenSymbol: z.ZodString;
-    supplyCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    supplyCap: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     defaultTokenAdmin: 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}`>>;
 }, z.core.$strip>;
@@ -12,7 +12,7 @@ export declare const CreateErc20Token: import("../../../common/controller.js").I
         $post: {
             input: {
                 json: {
-                    chainId: 11155111 | 72080;
+                    chainId: 11155111 | 84532 | 72080;
                     tokenName: string;
                     tokenSymbol: string;
                     supplyCap: string;

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,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,wBAAwB;;;;;;;iBAOnC,CAAC;AA6BH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAe3B,CAAC"}

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

@@ -1,17 +1,17 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+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";
-import { Int256BigInt } from "../../../common/int256.js";
-import { FactoryChainId, getFactories } from "../../common/factories.js";
-import { erc20Tag } from "../tag.js";
+import { FactoryChainId, getFactories } from "../../../issuance/common/factories.js";
 export const DeployErc20RequestSchema = 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: Int256BigInt(z.bigint().nonnegative()),
+    supplyCap: Int256Json,
     defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
 });

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

@@ -1,9 +1,9 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const InitializeDefaultErc20RequestSchema: 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;
-    cap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    cap: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     defaultAdmin: 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}`>>;
 }, z.core.$strip>;

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,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,mCAAmC;;;;;;;iBAO9C,CAAC;AAkBH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAgBjC,CAAC"}

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

@@ -1,16 +1,16 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+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";
-import { Int256BigInt } from "../../../common/int256.js";
-import { erc20Tag } from "../tag.js";
 export const InitializeDefaultErc20RequestSchema = 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: Int256BigInt(z.bigint().nonnegative()),
+    cap: Int256Json,
     defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
 });

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

@@ -3,8 +3,8 @@ export declare const ParseDefaultErc20DeployEvent: import("../../../common/contr
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {

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":"AA6BA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;aAoDvC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/default/parseDeployEvent.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;aAoDvC,CAAC"}

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

@@ -2,28 +2,18 @@ import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { parseEventLogs } from "viem";
 import { waitForTransactionReceipt } from "viem/actions";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Int256Json } 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 "../../common/factories.js";
-import { erc20Tag } from "../tag.js";
+import { FactoryChainIdQuery } from "../../../issuance/common/factories.js";
 const QuerySchema = z.object({
-    chainId: FactoryChainIdQuery.openapi({
-        param: {
-            name: "chainId",
-            in: "query",
-        },
-    }),
-    hash: HashSchema.openapi({
-        param: {
-            name: "hash",
-            in: "query",
-        },
-    }),
+    chainId: FactoryChainIdQuery.openapi({ param: { name: "chainId", in: "query" } }),
+    hash: HashSchema.openapi({ param: { name: "hash", in: "query" } }),
 });
 export const ParseDefaultErc20DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({

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

@@ -1,9 +1,9 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const DeployGatedErc20RequestSchema: z.ZodObject<{
-    chainId: z.ZodUnion<[z.ZodLiteral<11155111 | 72080>, z.ZodLiteral<11155111 | 72080>, ...z.ZodLiteral<11155111 | 72080>[]]>;
+    chainId: z.ZodUnion<[z.ZodLiteral<11155111 | 84532 | 72080>, z.ZodLiteral<11155111 | 84532 | 72080>, ...z.ZodLiteral<11155111 | 84532 | 72080>[]]>;
     tokenName: z.ZodString;
     tokenSymbol: z.ZodString;
-    supplyCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    supplyCap: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     defaultTokenAdmin: 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}`>>;
     gatingSigner: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
@@ -13,7 +13,7 @@ export declare const CreateGatedErc20Token: import("../../../common/controller.j
         $post: {
             input: {
                 json: {
-                    chainId: 11155111 | 72080;
+                    chainId: 11155111 | 84532 | 72080;
                     tokenName: string;
                     tokenSymbol: string;
                     supplyCap: string;

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,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,6BAA6B;;;;;;;;iBAUxC,CAAC;AAsBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAyBhC,CAAC"}

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

@@ -1,18 +1,18 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+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";
-import { Int256BigInt } from "../../../common/int256.js";
 import { DEFAULT_COMPILOT_SIGNER } from "../../../common/models/compilot.js";
-import { FactoryChainId, getFactories } from "../../common/factories.js";
-import { erc20Tag } from "../tag.js";
+import { FactoryChainId, getFactories } from "../../../issuance/common/factories.js";
 export const DeployGatedErc20RequestSchema = 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: Int256BigInt(z.bigint().nonnegative()),
+    supplyCap: Int256Json,
     defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
     gatingSigner: AddressSchema.optional().openapi({

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

@@ -1,9 +1,9 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const InitializeGatedErc20RequestSchema: 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;
-    cap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    cap: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     defaultAdmin: 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}`>>;
     gatingSigner: z.ZodOptional<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/gated/initialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gated/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,iCAAiC;;;;;;;;iBAU5C,CAAC;AAkBH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAc/B,CAAC"}
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gated/initialize.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,iCAAiC;;;;;;;;iBAU5C,CAAC;AAkBH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAc/B,CAAC"}

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

@@ -1,17 +1,17 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+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";
-import { Int256BigInt } from "../../../common/int256.js";
 import { DEFAULT_COMPILOT_SIGNER } from "../../../common/models/compilot.js";
-import { erc20Tag } from "../tag.js";
 export const InitializeGatedErc20RequestSchema = 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: Int256BigInt(z.bigint().nonnegative()),
+    cap: Int256Json,
     defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
     gatingSigner: AddressSchema.optional().openapi({

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

@@ -3,8 +3,8 @@ export declare const ParseGatedErc20DeployEvent: import("../../../common/control
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gated/parseDeployEvent.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;aAoDrC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gated/parseDeployEvent.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;aAoDrC,CAAC"}

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

@@ -2,28 +2,18 @@ import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { parseEventLogs } from "viem";
 import { waitForTransactionReceipt } from "viem/actions";
-import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { Int256Json } 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 "../../common/factories.js";
-import { erc20Tag } from "../tag.js";
+import { FactoryChainIdQuery } from "../../../issuance/common/factories.js";
 const QuerySchema = z.object({
-    chainId: FactoryChainIdQuery.openapi({
-        param: {
-            name: "chainId",
-            in: "query",
-        },
-    }),
-    hash: HashSchema.openapi({
-        param: {
-            name: "hash",
-            in: "query",
-        },
-    }),
+    chainId: FactoryChainIdQuery.openapi({ param: { name: "chainId", in: "query" } }),
+    hash: HashSchema.openapi({ param: { name: "hash", in: "query" } }),
 });
 export const ParseGatedErc20DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({

package/dist/issuance/erc20/gatedSimple/deploy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gatedSimple/deploy.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;aAQtC,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gatedSimple/deploy.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;aAQtC,CAAC"}

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

@@ -1,9 +1,9 @@
 import { describeRoute } from "hono-openapi";
 import { resolver } from "hono-openapi";
 import { erc20GatedAbi, erc20GatedBytecode } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
+import { erc20Tag } from "../tag.js";
 import { createController } from "../../../common/controller.js";
 import { DeployTransactionSchema } from "../../../common/index.js";
-import { erc20Tag } from "../tag.js";
 const deployGatedSimpleRoute = describeRoute({
     summary: "Get gated ERC20",
     description: "Returns transaction data for deploying a gated ERC20. This is an audited contract.",

package/dist/issuance/erc20/gatedSimple/getInitData.d.ts

@@ -1,11 +1,11 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const Erc20InitDataResponse: z.ZodObject<{
     data: 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 Erc20InitDataParams: z.ZodObject<{
     tokenName: z.ZodString;
     tokenSymbol: z.ZodString;
-    cap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    cap: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
     defaultAdmin: 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}`>>;
 }, z.core.$strip>;