@evergonlabs/tmi-protocol-api 0.7.0 → 0.8.1

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

@@ -9,9 +9,9 @@ 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 { FactoryChainId } from "../common/factories.js";
+import { FactoryChainIdQuery } from "../common/factories.js";
 const QuerySchema = z.object({
-    chainId: FactoryChainId.Schema.openapi({
+    chainId: FactoryChainIdQuery.openapi({
         param: {
             name: "chainId",
             in: "query",
@@ -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

@@ -8,9 +8,9 @@ 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 { FactoryChainId } from "../common/factories.js";
+import { FactoryChainIdQuery } from "../common/factories.js";
 const QuerySchema = z.object({
-    chainId: FactoryChainId.Schema.openapi({
+    chainId: FactoryChainIdQuery.openapi({
         param: {
             name: "chainId",
             in: "query",
@@ -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 {

package/dist/issuance/index.d.ts

@@ -9,7 +9,6 @@ export declare const IssuanceApi: import("../common/controller.js").IApi<import(
                     supplyCap: string;
                     defaultTokenAdmin: string;
                     minter: string;
-                    gatingSigner?: string | undefined;
                 };
             };
             output: {
@@ -27,6 +26,34 @@ export declare const IssuanceApi: import("../common/controller.js").IApi<import(
         };
     };
 }, "/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 IssuanceApi: import("../common/controller.js").IApi<import(
                 symbol: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/getDeployEvent"> | import("hono/types").MergeSchemaPath<{
@@ -304,7 +331,6 @@ export declare const IssuanceApi: import("../common/controller.js").IApi<import(
                     baseURI: string;
                     defaultTokenAdmin: string;
                     minter: string;
-                    gatingSigner?: string | undefined;
                 };
             };
             output: {
@@ -322,6 +348,34 @@ export declare const IssuanceApi: import("../common/controller.js").IApi<import(
         };
     };
 }, "/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: {
@@ -339,7 +393,7 @@ export declare const IssuanceApi: import("../common/controller.js").IApi<import(
                 baseURI: string;
             };
             outputFormat: "json";
-            status: 200;
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
 }, "/getDeployEvent"> | import("hono/types").MergeSchemaPath<{

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

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

package/dist/stakingTemplates/templates/common/getCreatePoolEvent.js

@@ -30,7 +30,7 @@ export function createGetCreatePoolEventController(template) {
             },
         }), validator("query", SentTransactionParamsSchema), 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 result = parseAssetManagersDeployEvent(template.template, receipt.logs);

package/dist/stakingTemplates/templates/common/getPlatformDeployEvent.js

@@ -28,7 +28,7 @@ export function createGetPlatformDeployEventController(template) {
             },
         }), validator("query", SentTransactionParamsSchema), 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 result = parseDeployDiamondEvent(receipt.logs);

package/dist/stakingTemplates/templates/common/getStakeEvent.js

@@ -34,7 +34,7 @@ export function createGetStakeEventController(template) {
             },
         }), validator("query", SentTransactionParamsSchema), 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 result = parseStakeEvent(template.template, receipt.logs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evergonlabs/tmi-protocol-api",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -39,13 +39,13 @@
     "viem": "^2.23.2",
     "zod": "^4.3.6",
     "zod-openapi": "^5.4.6",
-    "@evergonlabs/tmi-protocol-contracts": "0.7.0",
-    "@evergonlabs/tmi-protocol-fractions-sdk": "0.7.0",
-    "@evergonlabs/tmi-protocol-indexer": "0.7.0",
-    "@evergonlabs/tmi-protocol-shared": "0.7.0",
-    "@evergonlabs/tmi-protocol-staking-sdk": "0.7.0",
-    "@evergonlabs/tmi-protocol-types": "0.7.0",
-    "@evergonlabs/tmi-protocol-utils": "0.7.0"
+    "@evergonlabs/tmi-protocol-contracts": "0.8.1",
+    "@evergonlabs/tmi-protocol-types": "0.8.1",
+    "@evergonlabs/tmi-protocol-indexer": "0.8.1",
+    "@evergonlabs/tmi-protocol-utils": "0.8.1",
+    "@evergonlabs/tmi-protocol-fractions-sdk": "0.8.1",
+    "@evergonlabs/tmi-protocol-shared": "0.8.1",
+    "@evergonlabs/tmi-protocol-staking-sdk": "0.8.1"
   },
   "devDependencies": {
     "@evergonlabs/tmi-eslint-config": "0.3.0",