@evergonlabs/tmi-protocol-api 0.8.0 → 0.9.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"parseDeployEvent.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc20/gatedSimple/parseDeployEvent.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;aAuC3C,CAAC"}

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

@@ -0,0 +1,63 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { waitForTransactionReceipt } from "viem/actions";
+import { z } from "zod";
+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 "../../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 ParseGatedSimpleErc20DeployEvent = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get Gated Simple ERC20 Deploy Event",
+        description: `Gets the contract deployment transaction by hash and extracts the deployed contract address from the receipt.
+
+Provided transaction must be a contract creation transaction for the gated simple ERC20 token.`,
+        tags: ["Issuance"],
+        responses: {
+            200: {
+                description: "Returns the deployed contract address",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            contractAddress: AddressSchema,
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", QuerySchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
+            hash: params.hash,
+        });
+        if (!receipt.contractAddress) {
+            throw new UnableParseGatedSimpleErc20DeployEvent();
+        }
+        return c.json({
+            contractAddress: receipt.contractAddress,
+        });
+    }),
+});
+class UnableParseGatedSimpleErc20DeployEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't extract contract address from transaction receipt. Make sure you're passing a contract creation transaction for the gated simple ERC20 token`,
+            name: "UnableParseGatedSimpleErc20DeployEvent",
+        });
+    }
+}

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

@@ -29,5 +29,5 @@ export declare const GrantRoleErc20: import("../../common/controller.js").IContr
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=grantRole.d.ts.map

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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAE5F,eAAO,MAAM,2BAA2B;;;;iBAOtC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;QAczB,CAAC"}
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/grantRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAE5F,eAAO,MAAM,2BAA2B;;;;iBAOtC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;aAczB,CAAC"}

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

@@ -26,6 +26,54 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
         };
     };
 }, "/deploy"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    name: string;
+                    symbol: string;
+                    cap: string;
+                    defaultAdmin: string;
+                    minter: string;
+                };
+            };
+            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;
+        };
+    };
+}, "/initialize"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                proxy: `0x${string}`;
+                admin: `0x${string}`;
+                minter: `0x${string}`;
+                supplyCap: string;
+                name: string;
+                symbol: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/getDeployEvent"> | import("hono/types").MergeSchemaPath<{
     "/": {
         $post: {
             input: {
@@ -54,6 +102,34 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
         };
     };
 }, "/deployGated"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    name: string;
+                    symbol: string;
+                    cap: string;
+                    defaultAdmin: 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;
+        };
+    };
+}, "/initializeGated"> | import("hono/types").MergeSchemaPath<{
     "/": {
         $get: {
             input: {
@@ -74,7 +150,55 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/getDeployEvent"> | import("hono/types").MergeSchemaPath<{
+}, "/getDeployEventGated"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {};
+            output: {
+                bytecode: `0x${string}`;
+                abi: any[];
+                args?: any[] | undefined;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/deployGatedSimple"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenName: string;
+                    tokenSymbol: string;
+                    cap: string;
+                    defaultAdmin: string;
+                    minter: string;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/getInitData"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                contractAddress: `0x${string}`;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/getDeployEventGatedSimple"> | import("hono/types").MergeSchemaPath<{
     "/": {
         $post: {
             input: {
@@ -292,33 +416,5 @@ export declare const Erc20Controller: import("../../common/controller.js").ICont
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/renounceRole"> | import("hono/types").MergeSchemaPath<{
-    "/": {
-        $post: {
-            input: {
-                json: {
-                    tokenAddress: string;
-                    name: string;
-                    symbol: string;
-                    cap: string;
-                    defaultAdmin: 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;
-        };
-    };
-}, "/initialize">, "/">>;
+}, "/renounceRole">, "/", "/">>;
 //# sourceMappingURL=index.d.ts.map

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":"AAeA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiB1B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/index.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BA0B1B,CAAC"}

package/dist/issuance/erc20/index.js

@@ -1,12 +1,17 @@
 import { createController } from "../../common/controller.js";
+import { CreateErc20Token } from "./default/deploy.js";
+import { InitializeDefaultErc20 } from "./default/initialize.js";
+import { ParseDefaultErc20DeployEvent } from "./default/parseDeployEvent.js";
+import { CreateGatedErc20Token } from "./gated/deploy.js";
+import { InitializeGatedErc20 } from "./gated/initialize.js";
+import { ParseGatedErc20DeployEvent } from "./gated/parseDeployEvent.js";
+import { DeployErc20GatedSimpleToken } from "./gatedSimple/deploy.js";
+import { GetErc20InitData } from "./gatedSimple/getInitData.js";
+import { ParseGatedSimpleErc20DeployEvent } from "./gatedSimple/parseDeployEvent.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";
-import { ParseErc20DeployEvent } from "./parseErc20DeployEvent.js";
 import { RecoverErc20 } from "./recover.js";
 import { RenounceRoleErc20 } from "./renounceRole.js";
 import { RevokeRoleErc20 } from "./revokeRole.js";
@@ -15,9 +20,19 @@ import { TransferFromErc20 } from "./transferFrom.js";
 export const Erc20Controller = createController({
     build: (factory) => factory
         .createApp()
+        // Default (non-gated) variant
         .route("/deploy", CreateErc20Token.build(factory))
+        .route("/initialize", InitializeDefaultErc20.build(factory))
+        .route("/getDeployEvent", ParseDefaultErc20DeployEvent.build(factory))
+        // Gated variant
         .route("/deployGated", CreateGatedErc20Token.build(factory))
-        .route("/getDeployEvent", ParseErc20DeployEvent.build(factory))
+        .route("/initializeGated", InitializeGatedErc20.build(factory))
+        .route("/getDeployEventGated", ParseGatedErc20DeployEvent.build(factory))
+        // Gated Simple (audited) variant
+        .route("/deployGatedSimple", DeployErc20GatedSimpleToken.build(factory))
+        .route("/getInitData", GetErc20InitData.build(factory))
+        .route("/getDeployEventGatedSimple", ParseGatedSimpleErc20DeployEvent.build(factory))
+        // Common actions
         .route("/approve", ApproveErc20Token.build(factory))
         .route("/burn", BurnErc20Token.build(factory))
         .route("/mint", MintErc20Token.build(factory))
@@ -26,6 +41,5 @@ export const Erc20Controller = createController({
         .route("/recover", RecoverErc20.build(factory))
         .route("/grantRole", GrantRoleErc20.build(factory))
         .route("/revokeRole", RevokeRoleErc20.build(factory))
-        .route("/renounceRole", RenounceRoleErc20.build(factory))
-        .route("/initialize", InitializeErc20.build(factory)),
+        .route("/renounceRole", RenounceRoleErc20.build(factory)),
 });

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

@@ -28,5 +28,5 @@ export declare const MintErc20Token: import("../../common/controller.js").IContr
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=mint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/mint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;QAczB,CAAC"}
+{"version":3,"file":"mint.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/mint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAkBH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;aAczB,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",

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

@@ -30,5 +30,5 @@ export declare const RecoverErc20: import("../../common/controller.js").IControl
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=recover.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/recover.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;;;iBAKpC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;QAcvB,CAAC"}
+{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/recover.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;;;iBAKpC,CAAC;AAmBH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;aAcvB,CAAC"}

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

@@ -29,5 +29,5 @@ export declare const RenounceRoleErc20: import("../../common/controller.js").ICo
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=renounceRole.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/renounceRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAE5F,eAAO,MAAM,8BAA8B;;;;iBAOzC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;QAc5B,CAAC"}
+{"version":3,"file":"renounceRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/renounceRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAE5F,eAAO,MAAM,8BAA8B;;;;iBAOzC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

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

@@ -29,5 +29,5 @@ export declare const RevokeRoleErc20: import("../../common/controller.js").ICont
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=revokeRole.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"revokeRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/revokeRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAE5F,eAAO,MAAM,4BAA4B;;;;iBAOvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;QAc1B,CAAC"}
+{"version":3,"file":"revokeRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/revokeRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAqB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAE5F,eAAO,MAAM,4BAA4B;;;;iBAOvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;aAc1B,CAAC"}

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

@@ -28,5 +28,5 @@ export declare const TransferErc20: import("../../common/controller.js").IContro
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=transfer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transfer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;QAcxB,CAAC"}
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transfer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}

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

@@ -30,5 +30,5 @@ export declare const TransferFromErc20: import("../../common/controller.js").ICo
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=transferFrom.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transferFrom.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,8BAA8B;;;;;iBAKzC,CAAC;AAmBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;QAc5B,CAAC"}
+{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc20/transferFrom.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,8BAA8B;;;;;iBAKzC,CAAC;AAmBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;aAc5B,CAAC"}

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

@@ -28,5 +28,5 @@ export declare const ApproveErc721: import("../../common/controller.js").IContro
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=approve.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/approve.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;QAcxB,CAAC"}
+{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/approve.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAkBH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;aAcxB,CAAC"}

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

@@ -26,5 +26,5 @@ export declare const BurnErc721: import("../../common/controller.js").IControlle
             status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-}, "/">>;
+}, "/", "/">>;
 //# sourceMappingURL=burn.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/burn.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAkBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;QAcrB,CAAC"}
+{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/burn.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAkBH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;aAcrB,CAAC"}

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const DeployErc721RequestSchema: 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}`>>;
+}, z.core.$strip>;
+export declare const CreateErc721Token: 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;
+                };
+            };
+            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=deploy.d.ts.map

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

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

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

@@ -0,0 +1,53 @@
+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 { FactoryChainId, getFactories } from "../../common/factories.js";
+export const DeployErc721RequestSchema = 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" }),
+});
+const deployErc721Route = describeRoute({
+    summary: "Deploy ERC721 via Factory",
+    description: `This contract has not been audited.
+
+Returns transaction data for deploying a new ERC721 token via the factory contract.
+
+Calls deployAndInitializeProxy on the ERC721PausableRecoverableFactory to atomically deploy and initialize a new token proxy.
+
+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)`,
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for deploying an ERC721 token via factory",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const CreateErc721Token = createController({
+    build: (factory) => factory.createApp().post("/", deployErc721Route, validator("json", DeployErc721RequestSchema), async (c) => {
+        const { chainId, tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter } = c.req.valid("json");
+        const factory = getFactories(chainId);
+        return c.json(toTransaction({
+            address: factory.ERC721PausableRecoverableFactory,
+            abi: abis.erc721PausableRecoverableFactoryAbi,
+            functionName: "deployAndInitializeProxy",
+            args: [tokenName, tokenSymbol, baseURI, defaultTokenAdmin, minter],
+        }));
+    }),
+});

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const InitializeErc721RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    name: z.ZodString;
+    symbol: z.ZodString;
+    baseURI: z.ZodString;
+    defaultAdmin: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    minter: 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 InitializeDefaultErc721: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    name: string;
+                    symbol: string;
+                    baseURI: string;
+                    defaultAdmin: string;
+                    minter: string;
+                };
+            };
+            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=initialize.d.ts.map

package/dist/issuance/erc721/default/initialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../../src/issuance/erc721/default/initialize.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,6BAA6B;;;;;;;iBAOxC,CAAC;AAkBH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;aAclC,CAAC"}

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

@@ -0,0 +1,40 @@
+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";
+export const InitializeErc721RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    name: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
+    symbol: z.string().nonempty().openapi({ description: "Symbol of the NFT collection" }),
+    baseURI: z.string().openapi({ description: "Base URI for token metadata" }),
+    defaultAdmin: AddressSchema.openapi({ description: "Address to receive DEFAULT_ADMIN_ROLE" }),
+    minter: AddressSchema.openapi({ description: "Address to receive MINTER_ROLE" }),
+});
+const initializeRoute = describeRoute({
+    summary: "Initialize ERC721",
+    description: "Returns transaction data for initializing an ERC721 token proxy contract",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for initializing an ERC721 token",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const InitializeDefaultErc721 = createController({
+    build: (factory) => factory.createApp().post("/", initializeRoute, validator("json", InitializeErc721RequestSchema), async (c) => {
+        const { tokenAddress, name, symbol, baseURI, defaultAdmin, minter } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            functionName: "initialize",
+            args: [name, symbol, baseURI, defaultAdmin, minter],
+        }));
+    }),
+});

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

@@ -0,0 +1,23 @@
+export declare const ParseDefaultErc721DeployEvent: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    hash: string | string[];
+                };
+            };
+            output: {
+                proxy: `0x${string}`;
+                admin: `0x${string}`;
+                minter: `0x${string}`;
+                name: string;
+                symbol: string;
+                baseURI: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/">>;
+//# sourceMappingURL=parseDeployEvent.d.ts.map