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

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

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

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

@@ -7,7 +7,8 @@ import { erc20Tag } 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 InitializeGatedErc20RequestSchema = z.object({
+export const InitializeGatedErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
     name: z.string().nonempty().openapi({ description: "Name of the ERC20 token" }),
     symbol: z.string().nonempty().openapi({ description: "Symbol of the ERC20 token" }),
@@ -17,7 +18,8 @@ export const InitializeGatedErc20RequestSchema = z.object({
     gatingSigner: AddressSchema.optional().openapi({
         description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
     }),
-});
+})
+    .openapi("InitializeGatedErc20Request");
 const initializeRoute = describeRoute({
     summary: "Initialize gated ERC20",
     description: "Returns transaction data for initializing a gated ERC20 token proxy contract",
@@ -34,7 +36,7 @@ const initializeRoute = describeRoute({
     },
 });
 export const InitializeGatedErc20 = createController({
-    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeGatedErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeGatedErc20Request), async (c) => {
         const { tokenAddress, name, symbol, cap, defaultAdmin, minter, gatingSigner } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gated/parseDeployEvent.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;aAoDrC,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gated/parseDeployEvent.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AAUxD,eAAO,MAAM,iCAAiC;;;iBASD,CAAC;AAE9C,eAAO,MAAM,kCAAkC;;;;;;;iBASC,CAAC;AAEjD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;aA8CrC,CAAC"}

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

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

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

@@ -3,9 +3,291 @@ export declare const DeployErc20GatedSimpleToken: import("../../../common/contro
         $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;

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

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

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

@@ -2,7 +2,7 @@ import { z } from "@evergonlabs/tmi-protocol-utils/zod";
 export declare const Erc20InitDataResponse: z.ZodObject<{
     data: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
 }, z.core.$strip>;
-export declare const Erc20InitDataParams: z.ZodObject<{
+export declare const Erc20InitDataQuery: z.ZodObject<{
     tokenName: z.ZodString;
     tokenSymbol: z.ZodString;
     cap: z.core.$ZodBranded<z.ZodString, "Int256", "out">;
@@ -11,9 +11,9 @@ export declare const Erc20InitDataParams: z.ZodObject<{
 }, z.core.$strip>;
 export declare const GetErc20InitData: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
-        $post: {
+        $get: {
             input: {
-                json: {
+                query: {
                     tokenName: string;
                     tokenSymbol: string;
                     cap: string;

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":"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"}
+{"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,kBAAkB;;;;;;iBAcC,CAAC;AAkBjC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;aAc3B,CAAC"}

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

@@ -13,15 +13,21 @@ export const Erc20InitDataResponse = z
     data: HexStringSchema.openapi("Init function call data in hex format"),
 })
     .openapi("Erc20InitDataResponse");
-export const Erc20InitDataParams = z
+export const Erc20InitDataQuery = z
     .object({
-    tokenName: z.string().nonempty(),
-    tokenSymbol: z.string().nonempty(),
-    cap: Int256Json.openapi("Max. token supply"),
-    defaultAdmin: AddressSchema,
-    minter: AddressSchema,
+    tokenName: z
+        .string()
+        .nonempty()
+        .openapi({ param: { name: "tokenName", in: "query" } }),
+    tokenSymbol: z
+        .string()
+        .nonempty()
+        .openapi({ param: { name: "tokenSymbol", in: "query" } }),
+    cap: Int256Json.openapi({ description: "Max. token supply", param: { name: "cap", in: "query" } }),
+    defaultAdmin: AddressSchema.openapi({ param: { name: "defaultAdmin", in: "query" } }),
+    minter: AddressSchema.openapi({ param: { name: "minter", in: "query" } }),
 })
-    .openapi("ERC20InitDataParams");
+    .openapi("Erc20InitDataQuery");
 const getErc20InitDataRoute = describeRoute({
     summary: "Get ERC20 Init Data",
     description: `Returns init function call data in hex format. This is useful for using as initData in TransparentUpgradeableProxy`,
@@ -38,8 +44,8 @@ const getErc20InitDataRoute = describeRoute({
     },
 });
 export const GetErc20InitData = createController({
-    build: (factory) => factory.createApp().post("/", getErc20InitDataRoute, validator("json", Erc20InitDataParams), async (c) => {
-        const data = c.req.valid("json");
+    build: (factory) => factory.createApp().get("/", getErc20InitDataRoute, validator("query", Erc20InitDataQuery), async (c) => {
+        const data = c.req.valid("query");
         const initData = encodeFunctionData({
             abi: erc20GatedAbi,
             functionName: "init",

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

@@ -1,3 +1,11 @@
+import { z } from "@evergonlabs/tmi-protocol-utils/zod";
+export declare const ParseGatedSimpleErc20DeployEventQuery: 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 ParseGatedSimpleErc20DeployEventResponse: z.ZodObject<{
+    contractAddress: 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 ParseGatedSimpleErc20DeployEvent: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
     "/": {
         $get: {

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":"AAiBA,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;aAuC3C,CAAC"}
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gatedSimple/parseDeployEvent.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,qCAAqC,CAAC;AASxD,eAAO,MAAM,qCAAqC;;;iBAKC,CAAC;AAEpD,eAAO,MAAM,wCAAwC;;iBAIC,CAAC;AAEvD,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;aAmC3C,CAAC"}

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

@@ -8,10 +8,17 @@ 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 ParseGatedSimpleErc20DeployEventQuery = z
+    .object({
     chainId: FactoryChainIdQuery.openapi({ param: { name: "chainId", in: "query" } }),
     hash: HashSchema.openapi({ param: { name: "hash", in: "query" } }),
-});
+})
+    .openapi("ParseGatedSimpleErc20DeployEventQuery");
+export const ParseGatedSimpleErc20DeployEventResponse = z
+    .object({
+    contractAddress: AddressSchema,
+})
+    .openapi("ParseGatedSimpleErc20DeployEventResponse");
 export const ParseGatedSimpleErc20DeployEvent = createController({
     build: (factory) => factory.createApp().get("/", describeRoute({
         summary: "Get gated simple ERC20 deploy event",
@@ -24,14 +31,12 @@ Provided transaction must be a contract creation transaction for the gated simpl
                 description: "Returns the deployed contract address",
                 content: {
                     "application/json": {
-                        schema: resolver(z.object({
-                            contractAddress: AddressSchema,
-                        })),
+                        schema: resolver(ParseGatedSimpleErc20DeployEventResponse),
                     },
                 },
             },
         },
-    }), validator("query", QuerySchema), async (c) => {
+    }), validator("query", ParseGatedSimpleErc20DeployEventQuery), async (c) => {
         const params = c.req.valid("query");
         const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,

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

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

@@ -1 +1 @@
-{"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"}
+{"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,qBAAqB;;;;iBASC,CAAC;AAkBpC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}

package/dist/issuance/erc20/grantRole.js

@@ -6,14 +6,16 @@ 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";
-export const GrantRoleErc20RequestSchema = z.object({
+export const GrantRoleErc20Request = z
+    .object({
     tokenAddress: AddressSchema,
-    role: z.nativeEnum(Erc20GatedRole).openapi({
+    role: z.enum(Erc20GatedRole).openapi({
         description: "The role to grant",
         example: Erc20GatedRole.MINTER_ROLE,
     }),
     account: AddressSchema.openapi({ description: "The address to grant the role to" }),
-});
+})
+    .openapi("GrantRoleErc20Request");
 const grantRoleRoute = describeRoute({
     summary: "Grant role on Gated ERC20",
     description: "Returns transaction data for granting a role on a gated ERC20 token contract",
@@ -30,7 +32,7 @@ const grantRoleRoute = describeRoute({
     },
 });
 export const GrantRoleErc20 = createController({
-    build: (factory) => factory.createApp().post("/", grantRoleRoute, validator("json", GrantRoleErc20RequestSchema), async (c) => {
+    build: (factory) => factory.createApp().post("/", grantRoleRoute, validator("json", GrantRoleErc20Request), async (c) => {
         const { tokenAddress, role, account } = c.req.valid("json");
         return c.json(toTransaction({
             address: tokenAddress,