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

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

@@ -1 +1 @@
-{"version":3,"file":"getInitData.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gatedSimple/getInitData.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,qBAAqB;;iBAIC,CAAC;AAEpC,eAAO,MAAM,mBAAmB;;;;;;iBAQC,CAAC;AAkBlC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}
+{"version":3,"file":"getInitData.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gatedSimple/getInitData.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,qBAAqB;;iBAIC,CAAC;AAEpC,eAAO,MAAM,mBAAmB;;;;;;iBAQC,CAAC;AAkBlC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}

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

@@ -1,13 +1,13 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { encodeFunctionData } from "viem";
-import { z } from "zod";
 import { erc20GatedAbi } from "@evergonlabs/tmi-protocol-contracts/erc20Gated";
+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, HexStringSchema } 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 Erc20InitDataResponse = z
     .object({
     data: HexStringSchema.openapi("Init function call data in hex format"),
@@ -17,7 +17,7 @@ export const Erc20InitDataParams = z
     .object({
     tokenName: z.string().nonempty(),
     tokenSymbol: z.string().nonempty(),
-    cap: Int256BigInt().openapi("Max. token supply"),
+    cap: Int256Json.openapi("Max. token supply"),
     defaultAdmin: AddressSchema,
     minter: AddressSchema,
 })

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gatedSimple/parseDeployEvent.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;aAuC3C,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gatedSimple/parseDeployEvent.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;aAuC3C,CAAC"}

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

@@ -1,26 +1,16 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
 import { waitForTransactionReceipt } from "viem/actions";
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+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 ParseGatedSimpleErc20DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({

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

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

@@ -1 +1 @@
-{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/grantRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAG5F,eAAO,MAAM,2BAA2B;;;;iBAOtC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/grantRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAqB,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAExF,eAAO,MAAM,2BAA2B;;;;iBAOtC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}

package/dist/issuance/erc20/grantRole.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 { 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";
-import { erc20Tag } from "./tag.js";
 export const GrantRoleErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     role: z.nativeEnum(Erc20GatedRole).openapi({

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

@@ -3,7 +3,7 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
         $post: {
             input: {
                 json: {
-                    chainId: 11155111 | 72080;
+                    chainId: 11155111 | 84532 | 72080;
                     tokenName: string;
                     tokenSymbol: string;
                     supplyCap: string;
@@ -57,8 +57,8 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {
@@ -78,7 +78,7 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
         $post: {
             input: {
                 json: {
-                    chainId: 11155111 | 72080;
+                    chainId: 11155111 | 84532 | 72080;
                     tokenName: string;
                     tokenSymbol: string;
                     supplyCap: string;
@@ -134,8 +134,8 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {
@@ -187,8 +187,8 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
         $get: {
             input: {
                 query: {
-                    chainId: string | string[];
-                    hash: string | string[];
+                    chainId: "11155111" | "84532" | "72080";
+                    hash: string;
                 };
             };
             output: {

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":"AAoBA,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/index.js

@@ -1,4 +1,3 @@
-import { createController } from "../../common/controller.js";
 import { CreateErc20Token } from "./default/deploy.js";
 import { InitializeDefaultErc20 } from "./default/initialize.js";
 import { ParseDefaultErc20DeployEvent } from "./default/parseDeployEvent.js";
@@ -17,6 +16,7 @@ import { RenounceRoleErc20 } from "./renounceRole.js";
 import { RevokeRoleErc20 } from "./revokeRole.js";
 import { TransferErc20 } from "./transfer.js";
 import { TransferFromErc20 } from "./transferFrom.js";
+import { createController } from "../../common/controller.js";
 export const Erc20Controller = createController({
     build: (factory) => factory
         .createApp()

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

@@ -1,8 +1,8 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const MintErc20RequestSchema: 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.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 MintErc20Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {

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

package/dist/issuance/erc20/mint.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 MintErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     to: AddressSchema.openapi({ description: "Address to mint tokens to" }),
-    amount: Int256BigInt(z.bigint().nonnegative()),
+    amount: Int256Json,
 });
 const mintRoute = describeRoute({
     summary: "Mint gated ERC20",

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

@@ -1,9 +1,9 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const RecoverErc20RequestSchema: 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}`>>;
-    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 RecoverErc20: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,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,yBAAyB;;;;;iBAKpC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;aAcvB,CAAC"}

package/dist/issuance/erc20/recover.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 RecoverErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to recover tokens from" }),
     to: AddressSchema.openapi({ description: "Address to recover tokens to" }),
-    amount: Int256BigInt(z.bigint().nonnegative()),
+    amount: Int256Json,
 });
 const recoverRoute = describeRoute({
     summary: "Recover gated ERC20",

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

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

@@ -1 +1 @@
-{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/renounceRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAG5F,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,8BAA8B;;;;iBAOzC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc20/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 { 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";
-import { erc20Tag } from "./tag.js";
 export const RenounceRoleErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     role: z.nativeEnum(Erc20GatedRole).openapi({

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

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

@@ -1 +1 @@
-{"version":3,"file":"revokeRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/revokeRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAG5F,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,4BAA4B;;;;iBAOvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;aAc1B,CAAC"}

package/dist/issuance/erc20/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 { 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";
-import { erc20Tag } from "./tag.js";
 export const RevokeRoleErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     role: z.nativeEnum(Erc20GatedRole).openapi({

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

@@ -1,8 +1,8 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const TransferErc20RequestSchema: 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.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 TransferErc20: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,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,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}

package/dist/issuance/erc20/transfer.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 TransferErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     to: AddressSchema,
-    amount: Int256BigInt(z.bigint().nonnegative()),
+    amount: Int256Json,
 });
 const transferRoute = describeRoute({
     summary: "Transfer gated ERC20",

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

@@ -1,9 +1,9 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const TransferFromErc20RequestSchema: 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}`>>;
-    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 TransferFromErc20: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {

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

package/dist/issuance/erc20/transferFrom.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 TransferFromErc20RequestSchema = z.object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to transfer tokens from" }),
     to: AddressSchema.openapi({ description: "Address to transfer tokens to" }),
-    amount: Int256BigInt(z.bigint().nonnegative()),
+    amount: Int256Json,
 });
 const transferFromRoute = describeRoute({
     summary: "TransferFrom gated ERC20",

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

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

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,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,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}

package/dist/issuance/erc721/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 { erc721Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-import { Int256BigInt } from "../../common/int256.js";
-import { erc721Tag } from "./tag.js";
 export const ApproveErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     to: AddressSchema.openapi({ description: "Address to approve" }),
-    tokenId: Int256BigInt(z.bigint().nonnegative()),
+    tokenId: Int256Json,
 });
 const approveRoute = describeRoute({
     summary: "Approve ERC721",

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

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

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,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,uBAAuB;;;iBAGlC,CAAC;AAkBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;aAcrB,CAAC"}

package/dist/issuance/erc721/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 { erc721Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-import { Int256BigInt } from "../../common/int256.js";
-import { erc721Tag } from "./tag.js";
 export const BurnErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
-    tokenId: Int256BigInt(z.bigint().nonnegative()),
+    tokenId: Int256Json,
 });
 const burnRoute = describeRoute({
     summary: "Burn ERC721",

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

@@ -1,6 +1,6 @@
-import { z } from "zod";
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const DeployErc721RequestSchema: 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;
     baseURI: z.ZodString;
@@ -12,7 +12,7 @@ export declare const CreateErc721Token: import("../../../common/controller.js").
         $post: {
             input: {
                 json: {
-                    chainId: 11155111 | 72080;
+                    chainId: 11155111 | 84532 | 72080;
                     tokenName: string;
                     tokenSymbol: string;
                     baseURI: string;

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

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

package/dist/issuance/erc721/default/deploy.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 { erc721Tag } from "../tag.js";
 import { createController } from "../../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
-import { FactoryChainId, getFactories } from "../../common/factories.js";
-import { erc721Tag } from "../tag.js";
+import { FactoryChainId, getFactories } from "../../../issuance/common/factories.js";
 export const DeployErc721RequestSchema = z.object({
     chainId: FactoryChainId.Schema,
     tokenName: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),

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

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

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

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

package/dist/issuance/erc721/default/initialize.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 { erc721Tag } from "../tag.js";
 import { createController } from "../../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
-import { erc721Tag } from "../tag.js";
 export const InitializeErc721RequestSchema = z.object({
     tokenAddress: AddressSchema,
     name: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/parseDeployEvent.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;aAoDxC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/parseDeployEvent.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;aAoDxC,CAAC"}

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

@@ -2,27 +2,17 @@ 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 { erc721Tag } 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 { erc721Tag } 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 ParseDefaultErc721DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({