@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/issuance/erc20/recover.js

@@ -0,0 +1,39 @@
+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";
+export const RecoverErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    from: AddressSchema.openapi({ description: "Address to recover tokens from" }),
+    to: AddressSchema.openapi({ description: "Address to recover tokens to" }),
+    amount: Int256BigInt(z.bigint().nonnegative()),
+});
+const recoverRoute = describeRoute({
+    summary: "Recover Gated ERC20",
+    description: "Returns transaction data for recovering a gated ERC20 token from one address to another (RECOVER_ROLE required)",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for recovering a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const RecoverErc20 = createController({
+    build: (factory) => factory.createApp().post("/", recoverRoute, validator("json", RecoverErc20RequestSchema), async (c) => {
+        const { tokenAddress, from, to, amount } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20WhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "recover",
+            args: [from, to, BigInt(amount)],
+        }));
+    }),
+});

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

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
+export declare const RenounceRoleErc20RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    role: z.ZodEnum<typeof Erc20GatedRole>;
+    callerConfirmation: 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 RenounceRoleErc20: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: Erc20GatedRole;
+                    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;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=renounceRole.d.ts.map

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

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

package/dist/issuance/erc20/renounceRole.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 { convertRoleToHash, Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
+export const RenounceRoleErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    role: z.nativeEnum(Erc20GatedRole).openapi({
+        description: "The role to renounce",
+        example: Erc20GatedRole.MINTER_ROLE,
+    }),
+    callerConfirmation: AddressSchema.openapi({ description: "The caller's address for confirmation" }),
+});
+const renounceRoleRoute = describeRoute({
+    summary: "Renounce Role on Gated ERC20",
+    description: "Returns transaction data for renouncing a role on a gated ERC20 token contract",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for renouncing a role",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const RenounceRoleErc20 = createController({
+    build: (factory) => factory.createApp().post("/", renounceRoleRoute, validator("json", RenounceRoleErc20RequestSchema), async (c) => {
+        const { tokenAddress, role, callerConfirmation } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20WhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "renounceRole",
+            args: [convertRoleToHash(role), callerConfirmation],
+        }));
+    }),
+});

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

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

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

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

package/dist/issuance/erc20/revokeRole.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 { convertRoleToHash, Erc20GatedRole } from "../../common/roles/erc20-gated-roles.js";
+export const RevokeRoleErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    role: z.nativeEnum(Erc20GatedRole).openapi({
+        description: "The role to revoke",
+        example: Erc20GatedRole.MINTER_ROLE,
+    }),
+    account: AddressSchema.openapi({ description: "The address to revoke the role from" }),
+});
+const revokeRoleRoute = describeRoute({
+    summary: "Revoke Role on Gated ERC20",
+    description: "Returns transaction data for revoking a role on a gated ERC20 token contract",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for revoking a role",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const RevokeRoleErc20 = createController({
+    build: (factory) => factory.createApp().post("/", revokeRoleRoute, validator("json", RevokeRoleErc20RequestSchema), async (c) => {
+        const { tokenAddress, role, account } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20WhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "revokeRole",
+            args: [convertRoleToHash(role), account],
+        }));
+    }),
+});

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

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const TransferErc20RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    to: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const TransferErc20: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    to: string;
+                    amount: 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=transfer.d.ts.map

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

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

package/dist/issuance/erc20/transfer.js

@@ -0,0 +1,38 @@
+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";
+export const TransferErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    to: AddressSchema,
+    amount: Int256BigInt(z.bigint().nonnegative()),
+});
+const transferRoute = describeRoute({
+    summary: "Transfer Gated ERC20",
+    description: "Returns transaction data for transferring a gated ERC20 token to another address",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for transferring a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const TransferErc20 = createController({
+    build: (factory) => factory.createApp().post("/", transferRoute, validator("json", TransferErc20RequestSchema), async (c) => {
+        const { tokenAddress, to, amount } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20WhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "transfer",
+            args: [to, BigInt(amount)],
+        }));
+    }),
+});

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

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const TransferFromErc20RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    from: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    to: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    amount: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const TransferFromErc20: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    from: string;
+                    to: string;
+                    amount: 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=transferFrom.d.ts.map

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

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

package/dist/issuance/erc20/transferFrom.js

@@ -0,0 +1,39 @@
+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";
+export const TransferFromErc20RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    from: AddressSchema.openapi({ description: "Address to transfer tokens from" }),
+    to: AddressSchema.openapi({ description: "Address to transfer tokens to" }),
+    amount: Int256BigInt(z.bigint().nonnegative()),
+});
+const transferFromRoute = describeRoute({
+    summary: "TransferFrom Gated ERC20",
+    description: "Returns transaction data for transferring a gated ERC20 token from one address to another (requires approval)",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for transferring a gated ERC20",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const TransferFromErc20 = createController({
+    build: (factory) => factory.createApp().post("/", transferFromRoute, validator("json", TransferFromErc20RequestSchema), async (c) => {
+        const { tokenAddress, from, to, amount } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc20WhitelistGatedPausableRecoverableUpgradeableAbi,
+            functionName: "transferFrom",
+            args: [from, to, BigInt(amount)],
+        }));
+    }),
+});

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

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const ApproveErc721RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    to: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    tokenId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const ApproveErc721: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $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;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=approve.d.ts.map

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

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

package/dist/issuance/erc721/approve.js

@@ -0,0 +1,38 @@
+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";
+export const ApproveErc721RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    to: AddressSchema.openapi({ description: "Address to approve" }),
+    tokenId: Int256BigInt(z.bigint().nonnegative()),
+});
+const approveRoute = describeRoute({
+    summary: "Approve ERC721",
+    description: "Returns transaction data for approving an address to transfer a specific ERC721 token",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for approving an ERC721 token",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const ApproveErc721 = createController({
+    build: (factory) => factory.createApp().post("/", approveRoute, validator("json", ApproveErc721RequestSchema), async (c) => {
+        const { tokenAddress, to, tokenId } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            functionName: "approve",
+            args: [to, BigInt(tokenId)],
+        }));
+    }),
+});

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const BurnErc721RequestSchema: z.ZodObject<{
+    tokenAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    tokenId: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "Int256", "out">, z.ZodTransform<bigint, string & z.core.$brand<"Int256">>>;
+}, z.core.$strip>;
+export declare const BurnErc721: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $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;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=burn.d.ts.map

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

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

package/dist/issuance/erc721/burn.js

@@ -0,0 +1,37 @@
+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";
+export const BurnErc721RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    tokenId: Int256BigInt(z.bigint().nonnegative()),
+});
+const burnRoute = describeRoute({
+    summary: "Burn ERC721",
+    description: "Returns transaction data for burning an ERC721 token",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for burning an ERC721 token",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const BurnErc721 = createController({
+    build: (factory) => factory.createApp().post("/", burnRoute, validator("json", BurnErc721RequestSchema), async (c) => {
+        const { tokenAddress, tokenId } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            functionName: "burn",
+            args: [BigInt(tokenId)],
+        }));
+    }),
+});

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

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

@@ -0,0 +1,51 @@
+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: `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/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"}