@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

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/getInitData.d.ts

@@ -0,0 +1,49 @@
+import { Env } from "hono";
+import { Factory } from "hono/factory";
+import z from "zod";
+export declare const Erc721InitDataResponse: z.ZodObject<{
+    data: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+}, z.core.$strip>;
+export declare const Erc721InitDataParams: z.ZodObject<{
+    tokenName: z.ZodString;
+    tokenSymbol: z.ZodString;
+    admin: 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 function createGetErc721InitData<E extends Env>(factory: Factory<E>): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
+    in: {
+        json: {
+            tokenName: string;
+            tokenSymbol: string;
+            admin: string;
+        };
+    };
+    out: {
+        json: {
+            tokenName: string;
+            tokenSymbol: string;
+            admin: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
+    in: {
+        json: {
+            tokenName: string;
+            tokenSymbol: string;
+            admin: string;
+        };
+    };
+    out: {
+        json: {
+            tokenName: string;
+            tokenSymbol: string;
+            admin: `0x${string}`;
+        };
+    };
+}, Promise<Response & import("hono").TypedResponse<{
+    data: `0x${string}`;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+//# sourceMappingURL=getInitData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getInitData.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/getInitData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB,eAAO,MAAM,sBAAsB;;iBAIC,CAAC;AAErC,eAAO,MAAM,oBAAoB;;;;iBAQC,CAAC;AAqBnC,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAazE"}

package/dist/issuance/erc721/getInitData.js

@@ -0,0 +1,51 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { encodeFunctionData } from "viem";
+import z from "zod";
+import { managedErc721Abi } from "@evergonlabs/tmi-protocol-contracts/managedErc721";
+import { AddressSchema, HexStringSchema } from "../../common/index.js";
+export const Erc721InitDataResponse = z
+    .object({
+    data: HexStringSchema.openapi("Init function call data in hex format"),
+})
+    .openapi("Erc721InitDataResponse");
+export const Erc721InitDataParams = z
+    .object({
+    tokenName: z.string().nonempty().openapi({ description: "Name of the NFT collection" }),
+    tokenSymbol: z.string().nonempty().openapi({ description: "Symbol of the NFT collection" }),
+    admin: AddressSchema.openapi({
+        description: "Address to receive DEFAULT_ADMIN_ROLE, MINTER_ROLE, and URI_SETTER_ROLE",
+    }),
+})
+    .openapi("ERC721InitDataParams");
+const getErc721InitDataRoute = describeRoute({
+    summary: "Get ERC721 Init Data",
+    description: `Returns initialize function call data in hex format for ManagedERC721Upgradeable.
+
+This is useful for providing initData when deploying a TransparentUpgradeableProxy.
+The admin address receives DEFAULT_ADMIN_ROLE, MINTER_ROLE, and URI_SETTER_ROLE.`,
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Init function call data in hex format",
+            content: {
+                "application/json": {
+                    schema: resolver(Erc721InitDataResponse),
+                },
+            },
+        },
+    },
+});
+export function createGetErc721InitData(factory) {
+    return factory.createHandlers(getErc721InitDataRoute, validator("json", Erc721InitDataParams), async (c) => {
+        const data = c.req.valid("json");
+        const initData = encodeFunctionData({
+            abi: managedErc721Abi,
+            functionName: "initialize",
+            args: [data.tokenName, data.tokenSymbol, data.admin],
+        });
+        return c.json({
+            data: initData,
+        });
+    });
+}

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

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
+export declare const GrantRoleErc721RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    role: z.ZodEnum<typeof Erc721TokenRole>;
+    account: 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 GrantRoleErc721: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: Erc721TokenRole;
+                    account: 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=grantRole.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grantRole.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/grantRole.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAgC,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAE3G,eAAO,MAAM,4BAA4B;;;;iBAOvC,CAAC;AAkBH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;QAc1B,CAAC"}

package/dist/issuance/erc721/grantRole.js

@@ -0,0 +1,41 @@
+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 { convertErc721TokenRoleToHash, Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
+export const GrantRoleErc721RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    role: z.nativeEnum(Erc721TokenRole).openapi({
+        description: "The role to grant",
+        example: Erc721TokenRole.MINTER_ROLE,
+    }),
+    account: AddressSchema.openapi({ description: "The address to grant the role to" }),
+});
+const grantRoleRoute = describeRoute({
+    summary: "Grant Role on ERC721",
+    description: "Returns transaction data for granting a role on the ERC721 token contract",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for granting a role",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const GrantRoleErc721 = createController({
+    build: (factory) => factory.createApp().post("/", grantRoleRoute, validator("json", GrantRoleErc721RequestSchema), async (c) => {
+        const { tokenAddress, role, account } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            functionName: "grantRole",
+            args: [convertErc721TokenRoleToHash(role), account],
+        }));
+    }),
+});

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

@@ -0,0 +1,345 @@
+export declare const Erc721Controller: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $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;
+        };
+    };
+}, "/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: {
+                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;
+        };
+    };
+}, "/getDeployEvent"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    to: string;
+                    tokenId: 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;
+        };
+    };
+}, "/approve"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    tokenId: 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;
+        };
+    };
+}, "/burn"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    to: string;
+                    tokenId: 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;
+        };
+    };
+}, "/mint"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    from: string;
+                    to: string;
+                    tokenId: 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;
+        };
+    };
+}, "/transferFrom"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    from: string;
+                    to: string;
+                    tokenId: 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;
+        };
+    };
+}, "/recover"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: import("../../client.js").Erc721TokenRole;
+                    account: 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;
+        };
+    };
+}, "/grantRole"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: import("../../client.js").Erc721TokenRole;
+                    account: 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;
+        };
+    };
+}, "/revokeRole"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: import("../../client.js").Erc721TokenRole;
+                    callerConfirmation: 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;
+        };
+    };
+}, "/renounceRole"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    baseURI: 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;
+        };
+    };
+}, "/setBaseURI"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    tokenId: string;
+                    tokenURI: 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;
+        };
+    };
+}, "/setTokenURI"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $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;
+        };
+    };
+}, "/initialize">, "/">>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,33 @@
+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";
+import { ParseErc721DeployEvent } from "./parseErc721DeployEvent.js";
+import { RecoverErc721 } from "./recover.js";
+import { RenounceRoleErc721 } from "./renounceRole.js";
+import { RevokeRoleErc721 } from "./revokeRole.js";
+import { SetBaseURIErc721 } from "./setBaseURI.js";
+import { SetTokenURIErc721 } from "./setTokenURI.js";
+import { TransferFromErc721 } from "./transferFrom.js";
+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))
+        .route("/mint", MintErc721.build(factory))
+        .route("/transferFrom", TransferFromErc721.build(factory))
+        .route("/recover", RecoverErc721.build(factory))
+        .route("/grantRole", GrantRoleErc721.build(factory))
+        .route("/revokeRole", RevokeRoleErc721.build(factory))
+        .route("/renounceRole", RenounceRoleErc721.build(factory))
+        .route("/setBaseURI", SetBaseURIErc721.build(factory))
+        .route("/setTokenURI", SetTokenURIErc721.build(factory))
+        .route("/initialize", InitializeErc721.build(factory)),
+});

package/dist/issuance/erc721/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 InitializeErc721: 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/initialize.d.ts.map

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