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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"setBaseURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/setBaseURI.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAkBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}
+{"version":3,"file":"setBaseURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/setBaseURI.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,iBAAiB;;;iBAKO,CAAC;AAkBtC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}

package/dist/issuance/erc721/setBaseURI.js

@@ -5,10 +5,12 @@ 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";
-export const SetBaseURIRequestSchema = z.object({
+export const SetBaseURIRequest = z
+    .object({
     tokenAddress: AddressSchema,
     baseURI: z.string().nonempty().openapi({ description: "New base URI for token metadata" }),
-});
+})
+    .openapi("SetBaseURIErc721Request");
 const setBaseURIRoute = describeRoute({
     summary: "Set ERC721 base URI",
     description: "[TESTNET ONLY] Returns transaction data for setting the base URI on an ERC721 token",
@@ -25,7 +27,7 @@ const setBaseURIRoute = describeRoute({
     },
 });
 export const SetBaseURIErc721 = createController({
-    build: (factory) => factory.createApp().post("/", setBaseURIRoute, validator("json", SetBaseURIRequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", setBaseURIRoute, validator("json", SetBaseURIRequest), async (c) => {
         const { tokenAddress, baseURI } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"setTokenURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/setTokenURI.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,wBAAwB;;;;iBAInC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}
+{"version":3,"file":"setTokenURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/setTokenURI.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,kBAAkB;;;;iBAMO,CAAC;AAkBvC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

package/dist/issuance/erc721/setTokenURI.js

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/transferFrom.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,+BAA+B;;;;;iBAK1C,CAAC;AAkBH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}
+{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/transferFrom.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAOxD,eAAO,MAAM,yBAAyB;;;;;iBAOC,CAAC;AAkBxC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC"}

package/dist/issuance/erc721/transferFrom.js

@@ -6,12 +6,14 @@ import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { erc721Tag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const TransferFromErc721RequestSchema = z.object({
+export const TransferFromErc721Request = z
+    .object({
     tokenAddress: AddressSchema,
     from: AddressSchema.openapi({ description: "Address to transfer the token from" }),
     to: AddressSchema.openapi({ description: "Address to transfer the token to" }),
     tokenId: Int256Json,
-});
+})
+    .openapi("TransferFromErc721Request");
 const transferFromRoute = describeRoute({
     summary: "Transfer ERC721",
     description: "[TESTNET ONLY] Returns transaction data for transferring an ERC721 token from one address to another",
@@ -28,7 +30,7 @@ const transferFromRoute = describeRoute({
     },
 });
 export const TransferFromErc721 = createController({
-    build: (factory) => factory.createApp().post("/", transferFromRoute, validator("json", TransferFromErc721RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", transferFromRoute, validator("json", TransferFromErc721Request), async (c) => {
         const { tokenAddress, from, to, tokenId } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

package/dist/issuance/index.d.ts

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

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

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

package/dist/issuance/proxy/deploy.d.ts

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const DeployTransparentUpgradeableProxySchema: z.ZodObject<{
+export declare const DeployTransparentUpgradeableProxyRequest: z.ZodObject<{
     implementation: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     proxyAdminOwner: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     initData: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
@@ -15,7 +15,7 @@ export declare const CreateTransparentUpgradeableProxy: import("../../common/con
                 };
             };
             output: {
-                bytecode: `0x${string}`;
+                bytecode: string;
                 abi: any[];
                 args?: any[] | undefined;
             };
@@ -29,7 +29,7 @@ export declare const CreateProxyAdmin: import("../../common/controller.js").ICon
         $get: {
             input: {};
             output: {
-                bytecode: `0x${string}`;
+                bytecode: string;
                 abi: any[];
                 args?: any[] | undefined;
             };

package/dist/issuance/proxy/deploy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/deploy.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAwBxD,eAAO,MAAM,uCAAuC;;;;iBASlD,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;aAa5C,CAAC;AAoBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;aAQ3B,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/deploy.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAwBxD,eAAO,MAAM,wCAAwC;;;;iBAWC,CAAC;AAEvD,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;aAkB5C,CAAC;AAoBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;aAQ3B,CAAC"}

package/dist/issuance/proxy/deploy.js

@@ -22,7 +22,8 @@ const deployTransparentProxyRoute = describeRoute({
         },
     },
 });
-export const DeployTransparentUpgradeableProxySchema = z.object({
+export const DeployTransparentUpgradeableProxyRequest = z
+    .object({
     implementation: AddressSchema.openapi("The address of the implementation contract"),
     proxyAdminOwner: AddressSchema.openapi("The address of the proxy admin who is eligible to upgrade implementation"),
     initData: HexStringSchema.openapi(`Encoded function call hex data for underlying implementation contract initialization.
@@ -30,11 +31,12 @@ export const DeployTransparentUpgradeableProxySchema = z.object({
     Can be combined with "encodeFunctionData" of viem.
     NOTE: The underlying implementation contract must have initialization function.
     `),
-});
+})
+    .openapi("DeployTransparentUpgradeableProxyRequest");
 export const CreateTransparentUpgradeableProxy = createController({
     build: (factory) => factory
         .createApp()
-        .post("/", deployTransparentProxyRoute, validator("json", DeployTransparentUpgradeableProxySchema), async (c) => {
+        .post("/", deployTransparentProxyRoute, validator("json", DeployTransparentUpgradeableProxyRequest), async (c) => {
         const { implementation, proxyAdminOwner, initData } = c.req.valid("json");
         return c.json({
             bytecode: transparentUpgradeableProxyBytecode,

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

@@ -3,7 +3,7 @@ export declare const ProxyController: import("../../common/controller.js").ICont
         $get: {
             input: {};
             output: {
-                bytecode: `0x${string}`;
+                bytecode: string;
                 abi: any[];
                 args?: any[] | undefined;
             };
@@ -22,7 +22,7 @@ export declare const ProxyController: import("../../common/controller.js").ICont
                 };
             };
             output: {
-                bytecode: `0x${string}`;
+                bytecode: string;
                 abi: any[];
                 args?: any[] | undefined;
             };

package/dist/issuance/proxy/upgrade.d.ts

@@ -1,5 +1,5 @@
 import { z } from "@evergonlabs/tmi-protocol-utils/zod";
-export declare const UpgradeProxyRequestSchema: z.ZodObject<{
+export declare const UpgradeProxyRequest: z.ZodObject<{
     proxyAdminAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     proxyAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     newImplementation: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;

package/dist/issuance/proxy/upgrade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/upgrade.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,yBAAyB;;;;;iBAapC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;aAcvB,CAAC"}
+{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../../src/issuance/proxy/upgrade.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAMxD,eAAO,MAAM,mBAAmB;;;;;iBAeC,CAAC;AAmBlC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;aAcvB,CAAC"}

package/dist/issuance/proxy/upgrade.js

@@ -5,7 +5,8 @@ import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 import { proxyTag } from "./tag.js";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, HexStringSchema, toTransaction, TransactionSchema } from "../../common/index.js";
-export const UpgradeProxyRequestSchema = z.object({
+export const UpgradeProxyRequest = z
+    .object({
     proxyAdminAddress: AddressSchema.openapi({
         description: "The address of the ProxyAdmin contract that manages the proxy",
     }),
@@ -18,7 +19,8 @@ export const UpgradeProxyRequestSchema = z.object({
     data: HexStringSchema.optional().openapi({
         description: "Initialization data",
     }),
-});
+})
+    .openapi("UpgradeProxyRequest");
 const upgradeRoute = describeRoute({
     summary: "Upgrade transparent proxy implementation",
     description: "Returns transaction data for upgrading the implementation of a transparent proxy contract using ProxyAdmin",
@@ -35,7 +37,7 @@ const upgradeRoute = describeRoute({
     },
 });
 export const UpgradeProxy = createController({
-    build: (factory) => factory.createApp().post("/", upgradeRoute, validator("json", UpgradeProxyRequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", upgradeRoute, validator("json", UpgradeProxyRequest), async (c) => {
         const { proxyAdminAddress, proxyAddress, newImplementation, data } = c.req.valid("json");
         return c.json(toTransaction({
             address: proxyAdminAddress,