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

package/dist/general/searchBalances.d.ts

@@ -1,9 +1,24 @@
+import { TokenTypeEnum } from "@evergonlabs/tmi-protocol-types/evm";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const SearchBalancesResponse: z.ZodObject<{
+    balances: z.ZodArray<z.ZodObject<{
+        tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+        balance: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+        decimals: z.ZodNumber;
+        symbol: z.ZodString;
+        name: z.ZodString;
+        tokenId: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Int256", "out">>;
+        type: z.ZodNullable<z.ZodEnum<typeof TokenTypeEnum>>;
+    }, z.core.$strip>>;
+    totalItems: z.ZodNumber;
+    totalPages: z.ZodNumber;
+    pageNumber: z.ZodNumber;
+}, z.core.$strip>;
 export declare const SearchBalancesV0: import("../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     chainId: "1" | "31337" | "11155111" | "84532" | "72080";
                     address: string;
                 };
@@ -16,7 +31,7 @@ export declare const SearchBalancesV0: import("../common/controller.js").IContro
                     symbol: string;
                     name: string;
                     tokenId: (string & z.core.$brand<"Int256">) | null;
-                    type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
+                    type: TokenTypeEnum | null;
                 }[];
                 totalItems: number;
                 totalPages: number;

package/dist/general/searchBalances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"searchBalances.d.ts","sourceRoot":"","sources":["../../src/general/searchBalances.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAuBxD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAoC3B,CAAC"}
+{"version":3,"file":"searchBalances.d.ts","sourceRoot":"","sources":["../../src/general/searchBalances.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAmBxD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;iBAOC,CAAC;AAkBrC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAoC3B,CAAC"}

package/dist/general/searchBalances.js

@@ -1,11 +1,31 @@
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi";
+import { TokenTypeEnum } from "@evergonlabs/tmi-protocol-types/evm";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { createController } from "../common/controller.js";
 import { AddressSchema, FractionsChainId } from "../common/index.js";
 import { getAccountBalances } from "./balanceClient.js";
-import { BalancesResponseSchema } from "./common.js";
 import { generalTag as tag } from "./tag.js";
+const SearchBalanceEntry = z
+    .object({
+    tokenAddress: AddressSchema,
+    balance: Int256Json,
+    decimals: z.number(),
+    symbol: z.string(),
+    name: z.string(),
+    tokenId: Int256Json.nullable(),
+    type: z.enum(TokenTypeEnum).nullable(),
+})
+    .openapi("SearchBalanceEntry");
+export const SearchBalancesResponse = z
+    .object({
+    balances: z.array(SearchBalanceEntry),
+    totalItems: z.number(),
+    totalPages: z.number(),
+    pageNumber: z.number(),
+})
+    .openapi("SearchBalancesResponse");
 const searchBalancesRoute = describeRoute({
     summary: "Search balances",
     description: "Returns ERC20 balances of a wallet",
@@ -15,14 +35,14 @@ const searchBalancesRoute = describeRoute({
             description: "Returns ERC20 balances of a wallet",
             content: {
                 "application/json": {
-                    schema: resolver(BalancesResponseSchema),
+                    schema: resolver(SearchBalancesResponse),
                 },
             },
         },
     },
 });
 export const SearchBalancesV0 = createController({
-    build: (factory) => factory.createApp().post("/", searchBalancesRoute, validator("json", z
+    build: (factory) => factory.createApp().get("/", searchBalancesRoute, validator("query", z
         .object({
         chainId: FractionsChainId,
         address: AddressSchema.openapi({
@@ -30,7 +50,7 @@ export const SearchBalancesV0 = createController({
         }),
     })
         .openapi("SearchBalancesRequest")), async (c) => {
-        const { chainId, address } = c.req.valid("json");
+        const { chainId, address } = c.req.valid("query");
         const result = await getAccountBalances(address, chainId, c.env.config);
         return c.json({
             balances: result.map((x) => ({

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/burn.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAC;AAkBH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;aActB,CAAC"}
+{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/burn.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,kBAAkB;;;;;iBAOC,CAAC;AAkBjC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;aActB,CAAC"}

package/dist/issuance/erc1155/burn.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 BurnErc1155RequestSchema = z.object({
+export const BurnErc1155Request = z
+    .object({
     tokenAddress: AddressSchema,
     account: AddressSchema.openapi({ description: "Address to burn tokens from" }),
     id: Int256Json.openapi({ description: "Token ID to burn" }),
     amount: Int256Json.openapi({ description: "Amount of tokens to burn" }),
-});
+})
+    .openapi("BurnErc1155Request");
 const burnRoute = describeRoute({
     summary: "Burn ERC1155",
     description: "[TESTNET ONLY] Returns transaction data for burning an ERC1155 token",
@@ -28,7 +30,7 @@ const burnRoute = describeRoute({
     },
 });
 export const BurnErc1155 = createController({
-    build: (factory) => factory.createApp().post("/", burnRoute, validator("json", BurnErc1155RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", burnRoute, validator("json", BurnErc1155Request), async (c) => {
         const { tokenAddress, account, id, amount } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const DeployErc1155RequestSchema: z.ZodObject<{
+export declare const DeployErc1155Request: z.ZodObject<{
     chainId: z.ZodUnion<[z.ZodLiteral<"11155111" | "84532" | "72080">, z.ZodLiteral<"11155111" | "84532" | "72080">, ...z.ZodLiteral<"11155111" | "84532" | "72080">[]]>;
     baseURI: z.ZodString;
     defaultTokenAdmin: 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/default/deploy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/default/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AA+BH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/default/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,oBAAoB;;;;;iBAOC,CAAC;AA+BnC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}

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

@@ -6,12 +6,14 @@ import { erc1155Tag } 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 DeployErc1155RequestSchema = z.object({
+export const DeployErc1155Request = z
+    .object({
     chainId: FactoryChainId.Schema,
     baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
     defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
-});
+})
+    .openapi("DeployErc1155Request");
 const deployErc1155Route = describeRoute({
     summary: "Deploy ERC1155 via factory",
     description: `[TESTNET ONLY] This contract has not been audited.
@@ -41,7 +43,7 @@ The deployed token supports:
     },
 });
 export const CreateErc1155Token = createController({
-    build: (factory) => factory.createApp().post("/", deployErc1155Route, validator("json", DeployErc1155RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", deployErc1155Route, validator("json", DeployErc1155Request), async (c) => {
         const { chainId, baseURI, defaultTokenAdmin, minter } = c.req.valid("json");
         const factory = getFactories(chainId);
         return c.json(toTransaction({

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

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

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/default/initialize.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,8BAA8B;;;;;iBAKzC,CAAC;AAkBH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;aAcnC,CAAC"}
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/default/initialize.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,wBAAwB;;;;;iBAOC,CAAC;AAkBvC,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;aAcnC,CAAC"}

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

@@ -5,12 +5,14 @@ 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 InitializeErc1155RequestSchema = z.object({
+export const InitializeErc1155Request = z
+    .object({
     tokenAddress: AddressSchema,
     baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
     defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
-});
+})
+    .openapi("InitializeErc1155Request");
 const initializeRoute = describeRoute({
     summary: "Initialize ERC1155",
     description: "[TESTNET ONLY] Returns transaction data for initializing an ERC1155 token proxy contract",
@@ -27,7 +29,7 @@ const initializeRoute = describeRoute({
     },
 });
 export const InitializeDefaultErc1155 = createController({
-    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeErc1155RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeErc1155Request), async (c) => {
         const { tokenAddress, baseURI, defaultAdmin, minter } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,3 +1,14 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const ParseDefaultErc1155DeployEventQuery: 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 ParseDefaultErc1155DeployEventResponse: 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}`>>;
+    baseURI: z.ZodString;
+}, z.core.$strip>;
 export declare const ParseDefaultErc1155DeployEvent: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $get: {

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

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/default/parseDeployEvent.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;aAgDzC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/default/parseDeployEvent.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,mCAAmC;;;iBAKC,CAAC;AAElD,eAAO,MAAM,sCAAsC;;;;;iBAOC,CAAC;AAErD,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;aAyCzC,CAAC"}

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

@@ -10,10 +10,20 @@ 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 ParseDefaultErc1155DeployEventQuery = z
+    .object({
     chainId: FactoryChainIdQuery.openapi({ param: { name: "chainId", in: "query" } }),
     hash: HashSchema.openapi({ param: { name: "hash", in: "query" } }),
-});
+})
+    .openapi("ParseDefaultErc1155DeployEventQuery");
+export const ParseDefaultErc1155DeployEventResponse = z
+    .object({
+    proxy: AddressSchema,
+    admin: AddressSchema,
+    minter: AddressSchema,
+    baseURI: z.string(),
+})
+    .openapi("ParseDefaultErc1155DeployEventResponse");
 export const ParseDefaultErc1155DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get ERC1155 TokenProxyConfigured event",
@@ -24,17 +34,12 @@ export const ParseDefaultErc1155DeployEvent = createController({
                 description: "Returns parsed event log",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            proxy: AddressSchema,
-                            admin: AddressSchema,
-                            minter: AddressSchema,
-                            baseURI: z.string(),
-                        })),
+                        schema: resolver(ParseDefaultErc1155DeployEventResponse),
                     },
                 },
             },
         },
-    }), validator("query", QuerySchema), async (c) => {
+    }), validator("query", ParseDefaultErc1155DeployEventQuery), async (c) => {
         const params = c.req.valid("query");
         const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,

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

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const DeployGatedErc1155RequestSchema: z.ZodObject<{
+export declare const DeployGatedErc1155Request: z.ZodObject<{
     chainId: z.ZodUnion<[z.ZodLiteral<"11155111" | "84532" | "72080">, z.ZodLiteral<"11155111" | "84532" | "72080">, ...z.ZodLiteral<"11155111" | "84532" | "72080">[]]>;
     baseURI: z.ZodString;
     defaultTokenAdmin: 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/gated/deploy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/gated/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,+BAA+B;;;;;;iBAQ1C,CAAC;AAiCH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;aAgBlC,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/gated/deploy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAQxD,eAAO,MAAM,yBAAyB;;;;;;iBAUC,CAAC;AAiCxC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;aAclC,CAAC"}

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

@@ -7,7 +7,8 @@ import { createController } from "../../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
 import { DEFAULT_COMPILOT_SIGNER } from "../../../common/models/compilot.js";
 import { FactoryChainId, getFactories } from "../../../issuance/common/factories.js";
-export const DeployGatedErc1155RequestSchema = z.object({
+export const DeployGatedErc1155Request = z
+    .object({
     chainId: FactoryChainId.Schema,
     baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
     defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
@@ -15,7 +16,8 @@ export const DeployGatedErc1155RequestSchema = z.object({
     gatingSigner: AddressSchema.optional().openapi({
         description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
     }),
-});
+})
+    .openapi("DeployGatedErc1155Request");
 const deployGatedErc1155Route = describeRoute({
     summary: "Deploy gated ERC1155 via factory",
     description: `[TESTNET ONLY] This contract has not been audited.
@@ -47,9 +49,7 @@ The deployed token supports:
     },
 });
 export const CreateGatedErc1155Token = createController({
-    build: (factory) => factory
-        .createApp()
-        .post("/", deployGatedErc1155Route, validator("json", DeployGatedErc1155RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", deployGatedErc1155Route, validator("json", DeployGatedErc1155Request), async (c) => {
         const { chainId, baseURI, defaultTokenAdmin, minter, gatingSigner } = c.req.valid("json");
         const factory = getFactories(chainId);
         return c.json(toTransaction({

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

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

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

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

@@ -6,7 +6,8 @@ import { erc1155Tag } from "../tag.js";
 import { createController } from "../../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../../common/index.js";
 import { DEFAULT_COMPILOT_SIGNER } from "../../../common/models/compilot.js";
-export const InitializeGatedErc1155RequestSchema = z.object({
+export const InitializeGatedErc1155Request = z
+    .object({
     tokenAddress: AddressSchema,
     baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
     defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
@@ -14,7 +15,8 @@ export const InitializeGatedErc1155RequestSchema = z.object({
     gatingSigner: AddressSchema.optional().openapi({
         description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
     }),
-});
+})
+    .openapi("InitializeGatedErc1155Request");
 const initializeRoute = describeRoute({
     summary: "Initialize gated ERC1155",
     description: "[TESTNET ONLY] Returns transaction data for initializing a gated ERC1155 token proxy contract",
@@ -31,9 +33,7 @@ const initializeRoute = describeRoute({
     },
 });
 export const InitializeGatedErc1155 = createController({
-    build: (factory) => factory
-        .createApp()
-        .post("/", initializeRoute, validator("json", InitializeGatedErc1155RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeGatedErc1155Request), async (c) => {
         const { tokenAddress, baseURI, defaultAdmin, minter, gatingSigner } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -1,3 +1,14 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const ParseGatedErc1155DeployEventQuery: 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 ParseGatedErc1155DeployEventResponse: 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}`>>;
+    baseURI: z.ZodString;
+}, z.core.$strip>;
 export declare const ParseGatedErc1155DeployEvent: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $get: {

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

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/gated/parseDeployEvent.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;aAgDvC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc1155/gated/parseDeployEvent.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,iCAAiC;;;iBAKC,CAAC;AAEhD,eAAO,MAAM,oCAAoC;;;;;iBAOC,CAAC;AAEnD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;aAyCvC,CAAC"}

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

@@ -10,10 +10,20 @@ 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 ParseGatedErc1155DeployEventQuery = z
+    .object({
     chainId: FactoryChainIdQuery.openapi({ param: { name: "chainId", in: "query" } }),
     hash: HashSchema.openapi({ param: { name: "hash", in: "query" } }),
-});
+})
+    .openapi("ParseGatedErc1155DeployEventQuery");
+export const ParseGatedErc1155DeployEventResponse = z
+    .object({
+    proxy: AddressSchema,
+    admin: AddressSchema,
+    minter: AddressSchema,
+    baseURI: z.string(),
+})
+    .openapi("ParseGatedErc1155DeployEventResponse");
 export const ParseGatedErc1155DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get gated ERC1155 TokenProxyConfigured event",
@@ -24,17 +34,12 @@ export const ParseGatedErc1155DeployEvent = createController({
                 description: "Returns parsed event log",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            proxy: AddressSchema,
-                            admin: AddressSchema,
-                            minter: AddressSchema,
-                            baseURI: z.string(),
-                        })),
+                        schema: resolver(ParseGatedErc1155DeployEventResponse),
                     },
                 },
             },
         },
-    }), validator("query", QuerySchema), async (c) => {
+    }), validator("query", ParseGatedErc1155DeployEventQuery), async (c) => {
         const params = c.req.valid("query");
         const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,

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

@@ -1,3 +1,11 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const GetMintedErc1155TokenIdQuery: 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 GetMintedTokenResponse: z.ZodObject<{
+    tokenId: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
+}, z.core.$strip>;
 export declare const GetMintedTokenId: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
         $get: {
@@ -8,7 +16,7 @@ export declare const GetMintedTokenId: import("../../common/controller.js").ICon
                 };
             };
             output: {
-                tokenId: string;
+                tokenId: string & z.core.$brand<"Int256">;
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;

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

@@ -1 +1 @@
-{"version":3,"file":"getMintedTokenId.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/getMintedTokenId.ts"],"names":[],"mappings":"AA+CA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;aAyC3B,CAAC"}
+{"version":3,"file":"getMintedTokenId.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/getMintedTokenId.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAsCxD,eAAO,MAAM,4BAA4B;;;iBAKC,CAAC;AAE3C,eAAO,MAAM,sBAAsB;;iBAIC,CAAC;AAErC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;aAuC3B,CAAC"}

package/dist/issuance/erc1155/getMintedTokenId.js

@@ -3,6 +3,7 @@ import { resolver, validator } from "hono-openapi";
 import { parseEventLogs } from "viem";
 import { waitForTransactionReceipt } from "viem/actions";
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+import { Int256Json, toInt256Json } from "@evergonlabs/tmi-utils/models";
 import { FactoryChainIdQuery } from "../common/factories.js";
 import { erc1155Tag } from "./tag.js";
 import { getPublicClient } from "../../common/blockchain.js";
@@ -31,12 +32,19 @@ function extractTokenIdFromMintReceipt(receipt) {
     if (!event) {
         throw new Error("Could not extract tokenId from mint transaction receipt");
     }
-    return event.args.id.toString();
+    return toInt256Json(event.args.id);
 }
-const QuerySchema = z.object({
+export const GetMintedErc1155TokenIdQuery = z
+    .object({
     chainId: FactoryChainIdQuery.openapi({ param: { name: "chainId", in: "query" } }),
     hash: HashSchema.openapi({ param: { name: "hash", in: "query" } }),
-});
+})
+    .openapi("GetMintedErc1155TokenIdQuery");
+export const GetMintedTokenResponse = z
+    .object({
+    tokenId: Int256Json,
+})
+    .openapi("GetMintedTokenResponse");
 export const GetMintedTokenId = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get minted ERC1155 token ID",
@@ -47,18 +55,18 @@ export const GetMintedTokenId = createController({
                 description: "Returns the minted token ID",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            tokenId: z.string(),
-                        })),
+                        schema: resolver(GetMintedTokenResponse),
                     },
                 },
             },
         },
-    }), validator("query", QuerySchema), async (c) => {
+    }), validator("query", GetMintedErc1155TokenIdQuery), async (c) => {
         const { chainId, hash } = c.req.valid("query");
         const receipt = await waitForTransactionReceipt(getPublicClient(chainId, c.env.config), { hash });
         try {
-            return c.json({ tokenId: extractTokenIdFromMintReceipt(receipt) });
+            return c.json({
+                tokenId: extractTokenIdFromMintReceipt(receipt),
+            });
         }
         catch (cause) {
             throw new HttpError(500, {

package/dist/issuance/erc1155/grantRole.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 GrantRoleErc1155RequestSchema: z.ZodObject<{
+export declare const GrantRoleErc1155Request: 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/grantRole.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/grantRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAiC,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAExG,eAAO,MAAM,6BAA6B;;;;iBAOxC,CAAC;AAkBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/grantRole.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAKxD,OAAO,EAAiC,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAExG,eAAO,MAAM,uBAAuB;;;;iBASC,CAAC;AAkBtC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}

package/dist/issuance/erc1155/grantRole.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 GrantRoleErc1155RequestSchema = z.object({
+export const GrantRoleErc1155Request = z
+    .object({
     tokenAddress: AddressSchema,
-    role: z.nativeEnum(Erc1155TokenRole).openapi({
+    role: z.enum(Erc1155TokenRole).openapi({
         description: "The role to grant",
         example: Erc1155TokenRole.MINTER_ROLE,
     }),
     account: AddressSchema.openapi({ description: "The address to grant the role to" }),
-});
+})
+    .openapi("GrantRoleErc1155Request");
 const grantRoleRoute = describeRoute({
     summary: "Grant role on ERC1155",
     description: "[TESTNET ONLY] Returns transaction data for granting a role on the ERC1155 token contract",
@@ -30,7 +32,7 @@ const grantRoleRoute = describeRoute({
     },
 });
 export const GrantRoleErc1155 = createController({
-    build: (factory) => factory.createApp().post("/", grantRoleRoute, validator("json", GrantRoleErc1155RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", grantRoleRoute, validator("json", GrantRoleErc1155Request), async (c) => {
         const { tokenAddress, role, account } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

@@ -367,7 +367,7 @@ export declare const Erc1155Controller: import("../../common/controller.js").ICo
                 };
             };
             output: {
-                tokenId: string;
+                tokenId: string & import("zod").$brand<"Int256">;
             };
             outputFormat: "json";
             status: import("hono/utils/http-status").ContentfulStatusCode;

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/mint.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAC;AAmBH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;aActB,CAAC"}
+{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc1155/mint.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,kBAAkB;;;;;iBAOC,CAAC;AAmBjC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;aActB,CAAC"}