@evergonlabs/tmi-protocol-api 0.7.0 → 0.8.0

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

@@ -6,7 +6,6 @@ export declare const DeployErc20RequestSchema: z.ZodObject<{
     supplyCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
     defaultTokenAdmin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
     minter: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    gatingSigner: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
 }, z.core.$strip>;
 export declare const CreateErc20Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
@@ -19,7 +18,6 @@ export declare const CreateErc20Token: import("../../common/controller.js").ICon
                     supplyCap: string;
                     defaultTokenAdmin: string;
                     minter: string;
-                    gatingSigner?: string | undefined;
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,wBAAwB;;;;;;;;iBAUnC,CAAC;AAoBH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAuB3B,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,wBAAwB;;;;;;;iBAOnC,CAAC;AA2BH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;QAe3B,CAAC"}

package/dist/issuance/erc20/deploy.js

@@ -5,7 +5,6 @@ import { abis } from "@evergonlabs/tmi-factories-sdk";
 import { createController } from "../../common/controller.js";
 import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
 import { Int256BigInt } from "../../common/int256.js";
-import { DEFAULT_COMPILOT_SIGNER } from "../../common/models/compilot.js";
 import { FactoryChainId, getFactories } from "../common/factories.js";
 export const DeployErc20RequestSchema = z.object({
     chainId: FactoryChainId.Schema,
@@ -14,19 +13,23 @@ export const DeployErc20RequestSchema = z.object({
     supplyCap: Int256BigInt(z.bigint().nonnegative()),
     defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
     minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
-    gatingSigner: AddressSchema.optional().openapi({
-        description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
-    }),
 });
-const deployRoute = describeRoute({
-    summary: "Deploy Gated ERC20 via Factory",
-    description: `Returns transaction data for deploying a new whitelist-gated ERC20 token via the factory contract.
+const deployErc20Route = describeRoute({
+    summary: "Deploy ERC20 via Factory",
+    description: `Returns transaction data for deploying a new ERC20 token via the factory contract.
+
+Calls deployAndInitializeProxy on the ERC20PausableRecoverableFactory to atomically deploy and initialize a new token proxy.
 
-Calls deployAndInitializeProxy on the ERC20GatedPausableRecoverableFactory to atomically deploy and initialize a new token proxy.`,
+The deployed token supports:
+- mint(to, amount) - Mint tokens (MINTER_ROLE gated)
+- burn(amount) - Burn tokens
+- burnFrom(account, amount) - Burn from account (with allowance)
+- pause() / unpause() - Pause/unpause transfers (PAUSER_ROLE gated)
+- recover(token, to, amount) - Recover tokens (RECOVER_ROLE gated)`,
     tags: ["Issuance"],
     responses: {
         200: {
-            description: "Returns transaction data for deploying a gated ERC20 token via factory",
+            description: "Returns transaction data for deploying an ERC20 token via factory",
             content: {
                 "application/json": {
                     schema: resolver(TransactionSchema),
@@ -36,21 +39,14 @@ Calls deployAndInitializeProxy on the ERC20GatedPausableRecoverableFactory to at
     },
 });
 export const CreateErc20Token = createController({
-    build: (factory) => factory.createApp().post("/", deployRoute, validator("json", DeployErc20RequestSchema), async (c) => {
-        const { chainId, tokenName, tokenSymbol, supplyCap, defaultTokenAdmin, minter, gatingSigner } = c.req.valid("json");
+    build: (factory) => factory.createApp().post("/", deployErc20Route, validator("json", DeployErc20RequestSchema), async (c) => {
+        const { chainId, tokenName, tokenSymbol, supplyCap, defaultTokenAdmin, minter } = c.req.valid("json");
         const factory = getFactories(chainId);
         return c.json(toTransaction({
-            address: factory.ERC20GatedPausableRecoverableFactory,
-            abi: abis.erc20GatedPausableRecoverableFactoryAbi,
+            address: factory.ERC20PausableRecoverableFactory,
+            abi: abis.erc20PausableRecoverableFactoryAbi,
             functionName: "deployAndInitializeProxy",
-            args: [
-                tokenName,
-                tokenSymbol,
-                BigInt(supplyCap),
-                defaultTokenAdmin,
-                minter,
-                gatingSigner ?? DEFAULT_COMPILOT_SIGNER,
-            ],
+            args: [tokenName, tokenSymbol, BigInt(supplyCap), defaultTokenAdmin, minter],
         }));
     }),
 });

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

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const DeployGatedErc20RequestSchema: z.ZodObject<{
+    chainId: z.ZodUnion<[z.ZodLiteral<11155111 | 72080>, z.ZodLiteral<11155111 | 72080>, ...z.ZodLiteral<11155111 | 72080>[]]>;
+    tokenName: z.ZodString;
+    tokenSymbol: z.ZodString;
+    supplyCap: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+    defaultTokenAdmin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    minter: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    gatingSigner: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+}, z.core.$strip>;
+export declare const CreateGatedErc20Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    tokenName: string;
+                    tokenSymbol: string;
+                    supplyCap: string;
+                    defaultTokenAdmin: string;
+                    minter: string;
+                    gatingSigner?: string | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=deployGated.d.ts.map

package/dist/issuance/erc20/deployGated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployGated.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/deployGated.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,6BAA6B;;;;;;;;iBAUxC,CAAC;AAoBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAyBhC,CAAC"}

package/dist/issuance/erc20/deployGated.js

@@ -0,0 +1,58 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { abis } from "@evergonlabs/tmi-factories-sdk";
+import { createController } from "../../common/controller.js";
+import { AddressSchema, toTransaction, TransactionSchema } from "../../common/index.js";
+import { Int256BigInt } from "../../common/int256.js";
+import { DEFAULT_COMPILOT_SIGNER } from "../../common/models/compilot.js";
+import { FactoryChainId, getFactories } from "../common/factories.js";
+export const DeployGatedErc20RequestSchema = z.object({
+    chainId: FactoryChainId.Schema,
+    tokenName: z.string().nonempty().openapi({ description: "Name of the ERC20 token" }),
+    tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the ERC20 token" }),
+    supplyCap: Int256BigInt(z.bigint().nonnegative()),
+    defaultTokenAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
+    minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
+    gatingSigner: AddressSchema.optional().openapi({
+        description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
+    }),
+});
+const deployGatedErc20Route = describeRoute({
+    summary: "Deploy Gated ERC20 via Factory",
+    description: `Returns transaction data for deploying a new whitelist-gated ERC20 token via the factory contract.
+
+Calls deployAndInitializeProxy on the ERC20GatedPausableRecoverableFactory to atomically deploy and initialize a new token proxy.`,
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a gated ERC20 token via factory",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateGatedErc20Token = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", deployGatedErc20Route, validator("json", DeployGatedErc20RequestSchema), async (c) => {
+        const { chainId, tokenName, tokenSymbol, supplyCap, defaultTokenAdmin, minter, gatingSigner } = c.req.valid("json");
+        const factory = getFactories(chainId);
+        return c.json(toTransaction({
+            address: factory.ERC20GatedPausableRecoverableFactory,
+            abi: abis.erc20GatedPausableRecoverableFactoryAbi,
+            functionName: "deployAndInitializeProxy",
+            args: [
+                tokenName,
+                tokenSymbol,
+                BigInt(supplyCap),
+                defaultTokenAdmin,
+                minter,
+                gatingSigner ?? DEFAULT_COMPILOT_SIGNER,
+            ],
+        }));
+    }),
+});

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

@@ -9,7 +9,6 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
                     supplyCap: string;
                     defaultTokenAdmin: string;
                     minter: string;
-                    gatingSigner?: string | undefined;
                 };
             };
             output: {
@@ -27,6 +26,34 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
         };
     };
 }, "/deploy"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    tokenName: string;
+                    tokenSymbol: string;
+                    supplyCap: string;
+                    defaultTokenAdmin: string;
+                    minter: string;
+                    gatingSigner?: string | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deployGated"> | import("hono/types").MergeSchemaPath<{
     "/": {
         $get: {
             input: {
@@ -44,7 +71,7 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
                 symbol: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/getDeployEvent"> | import("hono/types").MergeSchemaPath<{

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/index.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgB1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/index.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiB1B,CAAC"}

package/dist/issuance/erc20/index.js

@@ -2,6 +2,7 @@ import { createController } from "../../common/controller.js";
 import { ApproveErc20Token } from "./approve.js";
 import { BurnErc20Token } from "./burn.js";
 import { CreateErc20Token } from "./deploy.js";
+import { CreateGatedErc20Token } from "./deployGated.js";
 import { GrantRoleErc20 } from "./grantRole.js";
 import { InitializeErc20 } from "./initialize.js";
 import { MintErc20Token } from "./mint.js";
@@ -15,6 +16,7 @@ export const Erc20Controller = createController({
     build: (factory) => factory
         .createApp()
         .route("/deploy", CreateErc20Token.build(factory))
+        .route("/deployGated", CreateGatedErc20Token.build(factory))
         .route("/getDeployEvent", ParseErc20DeployEvent.build(factory))
         .route("/approve", ApproveErc20Token.build(factory))
         .route("/burn", BurnErc20Token.build(factory))

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

@@ -16,7 +16,7 @@ export declare const ParseErc20DeployEvent: import("../../common/controller.js")
                 symbol: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/">>;

package/dist/issuance/erc20/parseErc20DeployEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseErc20DeployEvent.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/parseErc20DeployEvent.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;QAuDhC,CAAC"}
+{"version":3,"file":"parseErc20DeployEvent.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/parseErc20DeployEvent.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;QAoDhC,CAAC"}

package/dist/issuance/erc20/parseErc20DeployEvent.js

@@ -48,7 +48,7 @@ export const ParseErc20DeployEvent = createController({
         },
     }), validator("query", QuerySchema), async (c) => {
         const params = c.req.valid("query");
-        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId), {
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,
         });
         const [event] = parseEventLogs({
@@ -66,7 +66,7 @@ export const ParseErc20DeployEvent = createController({
             supplyCap: event.args.supplyCap.toString(),
             name: event.args.name,
             symbol: event.args.symbol,
-        }, 200);
+        });
     }),
 });
 class UnableParseErc20DeployEvent extends HttpError {

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

@@ -6,7 +6,6 @@ export declare const DeployErc721RequestSchema: z.ZodObject<{
     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}`>>;
     minter: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
-    gatingSigner: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
 }, z.core.$strip>;
 export declare const CreateErc721Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
     "/": {
@@ -19,7 +18,6 @@ export declare const CreateErc721Token: import("../../common/controller.js").ICo
                     baseURI: string;
                     defaultTokenAdmin: string;
                     minter: string;
-                    gatingSigner?: string | undefined;
                 };
             };
             output: {

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

@@ -1 +1 @@
-{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,yBAAyB;;;;;;;;iBAUpC,CAAC;AA2BH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAc5B,CAAC"}
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;;;;;iBAOpC,CAAC;AA2BH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;QAc5B,CAAC"}

package/dist/issuance/erc721/deploy.js

@@ -4,7 +4,6 @@ import { z } from "zod";
 import { abis } from "@evergonlabs/tmi-factories-sdk";
 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 "../common/factories.js";
 export const DeployErc721RequestSchema = z.object({
     chainId: FactoryChainId.Schema,
@@ -13,9 +12,6 @@ export const DeployErc721RequestSchema = z.object({
     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" }),
-    gatingSigner: AddressSchema.optional().openapi({
-        description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
-    }),
 });
 const deployErc721Route = describeRoute({
     summary: "Deploy ERC721 via Factory",
@@ -43,13 +39,13 @@ The deployed token supports:
 });
 export const CreateErc721Token = createController({
     build: (factory) => factory.createApp().post("/", deployErc721Route, validator("json", DeployErc721RequestSchema), async (c) => {
-        const { chainId, tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter, gatingSigner } = c.req.valid("json");
+        const { chainId, tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter } = c.req.valid("json");
         const factory = getFactories(chainId);
         return c.json(toTransaction({
-            address: factory.ERC721GatedPausableRecoverableFactory,
-            abi: abis.erc721GatedPausableRecoverableFactoryAbi,
+            address: factory.ERC721PausableRecoverableFactory,
+            abi: abis.erc721PausableRecoverableFactoryAbi,
             functionName: "deployAndInitializeProxy",
-            args: [tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter, gatingSigner ?? DEFAULT_COMPILOT_SIGNER],
+            args: [tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter],
         }));
     }),
 });

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

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const DeployGatedErc721RequestSchema: z.ZodObject<{
+    chainId: z.ZodUnion<[z.ZodLiteral<11155111 | 72080>, z.ZodLiteral<11155111 | 72080>, ...z.ZodLiteral<11155111 | 72080>[]]>;
+    tokenName: z.ZodString;
+    tokenSymbol: z.ZodString;
+    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}`>>;
+    minter: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    gatingSigner: z.ZodOptional<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>>;
+}, z.core.$strip>;
+export declare const CreateGatedErc721Token: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    tokenName: string;
+                    tokenSymbol: string;
+                    baseURI: string;
+                    defaultTokenAdmin: string;
+                    minter: string;
+                    gatingSigner?: string | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=deployGated.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deployGated.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/deployGated.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,8BAA8B;;;;;;;;iBAUzC,CAAC;AA4BH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiBjC,CAAC"}

package/dist/issuance/erc721/deployGated.js

@@ -0,0 +1,58 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { abis } from "@evergonlabs/tmi-factories-sdk";
+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 "../common/factories.js";
+export const DeployGatedErc721RequestSchema = z.object({
+    chainId: FactoryChainId.Schema,
+    tokenName: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
+    tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the NFT collection" }),
+    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" }),
+    gatingSigner: AddressSchema.optional().openapi({
+        description: "Address of the gating signer for whitelist verification. Defaults to the ComPilot signer.",
+    }),
+});
+const deployGatedErc721Route = describeRoute({
+    summary: "Deploy Gated ERC721 via Factory",
+    description: `Returns transaction data for deploying a new gated ERC721 token via the factory contract.
+
+Calls deployAndInitializeProxy on the ERC721GatedPausableRecoverableFactory to atomically deploy and initialize a new token proxy with whitelist gating.
+
+The deployed token supports:
+- mint(to, tokenId) - Mint token (MINTER_ROLE gated)
+- burn(tokenId) - Burn token (owner, approved, or MINTER_ROLE)
+- setBaseURI(uri) - Set base URI (URI_SETTER_ROLE gated)
+- setTokenURI(tokenId, uri) - Set token-specific URI (URI_SETTER_ROLE gated)
+- setContractURI(uri) - Set contract metadata URI (URI_SETTER_ROLE gated)
+- Whitelist gating via gatingSigner for transfer verification`,
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying a gated ERC721 token via factory",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateGatedErc721Token = createController({
+    build: (factory) => factory
+        .createApp()
+        .post("/", deployGatedErc721Route, validator("json", DeployGatedErc721RequestSchema), async (c) => {
+        const { chainId, tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter, gatingSigner } = c.req.valid("json");
+        const factory = getFactories(chainId);
+        return c.json(toTransaction({
+            address: factory.ERC721GatedPausableRecoverableFactory,
+            abi: abis.erc721GatedPausableRecoverableFactoryAbi,
+            functionName: "deployAndInitializeProxy",
+            args: [tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter, gatingSigner ?? DEFAULT_COMPILOT_SIGNER],
+        }));
+    }),
+});

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

@@ -9,7 +9,6 @@ export declare const Erc721Controller: import("../../common/controller.js").ICon
                     baseURI: string;
                     defaultTokenAdmin: string;
                     minter: string;
-                    gatingSigner?: string | undefined;
                 };
             };
             output: {
@@ -27,6 +26,34 @@ export declare const Erc721Controller: import("../../common/controller.js").ICon
         };
     };
 }, "/deploy"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: 11155111 | 72080;
+                    tokenName: string;
+                    tokenSymbol: string;
+                    baseURI: string;
+                    defaultTokenAdmin: string;
+                    minter: string;
+                    gatingSigner?: string | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deployGated"> | import("hono/types").MergeSchemaPath<{
     "/": {
         $get: {
             input: {
@@ -44,7 +71,7 @@ export declare const Erc721Controller: import("../../common/controller.js").ICon
                 baseURI: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/getDeployEvent"> | import("hono/types").MergeSchemaPath<{

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/index.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiB3B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/index.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkB3B,CAAC"}

package/dist/issuance/erc721/index.js

@@ -2,6 +2,7 @@ import { createController } from "../../common/controller.js";
 import { ApproveErc721 } from "./approve.js";
 import { BurnErc721 } from "./burn.js";
 import { CreateErc721Token } from "./deploy.js";
+import { CreateGatedErc721Token } from "./deployGated.js";
 import { GrantRoleErc721 } from "./grantRole.js";
 import { InitializeErc721 } from "./initialize.js";
 import { MintErc721 } from "./mint.js";
@@ -16,6 +17,7 @@ export const Erc721Controller = createController({
     build: (factory) => factory
         .createApp()
         .route("/deploy", CreateErc721Token.build(factory))
+        .route("/deployGated", CreateGatedErc721Token.build(factory))
         .route("/getDeployEvent", ParseErc721DeployEvent.build(factory))
         .route("/approve", ApproveErc721.build(factory))
         .route("/burn", BurnErc721.build(factory))

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

@@ -16,7 +16,7 @@ export declare const ParseErc721DeployEvent: import("../../common/controller.js"
                 baseURI: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/">>;

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

@@ -1 +1 @@
-{"version":3,"file":"parseErc721DeployEvent.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/parseErc721DeployEvent.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;QAuDjC,CAAC"}
+{"version":3,"file":"parseErc721DeployEvent.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/parseErc721DeployEvent.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;QAoDjC,CAAC"}

package/dist/issuance/erc721/parseErc721DeployEvent.js

@@ -47,7 +47,7 @@ export const ParseErc721DeployEvent = createController({
         },
     }), validator("query", QuerySchema), async (c) => {
         const params = c.req.valid("query");
-        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId), {
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
             hash: params.hash,
         });
         const [event] = parseEventLogs({
@@ -65,7 +65,7 @@ export const ParseErc721DeployEvent = createController({
             name: event.args.name,
             symbol: event.args.symbol,
             baseURI: event.args.baseURI,
-        }, 200);
+        });
     }),
 });
 class UnableParseErc721DeployEvent extends HttpError {