@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/issuance/erc721/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 InitializeErc721 = 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/mint.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const MintErc721RequestSchema: 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 MintErc721: 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=mint.d.ts.map

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

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

package/dist/issuance/erc721/mint.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 MintErc721RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    to: AddressSchema.openapi({ description: "Address to mint the token to" }),
+    tokenId: Int256BigInt(z.bigint().nonnegative()),
+});
+const mintRoute = describeRoute({
+    summary: "Mint ERC721",
+    description: "Returns transaction data for minting an ERC721 token (MINTER_ROLE required)",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for minting an ERC721 token",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const MintErc721 = createController({
+    build: (factory) => factory.createApp().post("/", mintRoute, validator("json", MintErc721RequestSchema), async (c) => {
+        const { tokenAddress, to, tokenId } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            functionName: "mint",
+            args: [to, BigInt(tokenId)],
+        }));
+    }),
+});

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

@@ -0,0 +1,23 @@
+export declare const ParseErc721DeployEvent: 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=parseErc721DeployEvent.d.ts.map

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

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

@@ -0,0 +1,78 @@
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi";
+import { parseEventLogs } from "viem";
+import { waitForTransactionReceipt } from "viem/actions";
+import { z } from "zod";
+import { abis } from "@evergonlabs/tmi-factories-sdk";
+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";
+const QuerySchema = z.object({
+    chainId: FactoryChainId.Schema.openapi({
+        param: {
+            name: "chainId",
+            in: "query",
+        },
+    }),
+    hash: HashSchema.openapi({
+        param: {
+            name: "hash",
+            in: "query",
+        },
+    }),
+});
+export const ParseErc721DeployEvent = createController({
+    build: (factory) => factory.createApp().get("/", describeRoute({
+        summary: "Get ERC721 TokenProxyConfigured Event",
+        description: `Gets the transaction by hash and parses emitted logs.\n\nProvided transaction must be a transaction emitted by the ERC721 factory \`deployAndInitializeProxy\` action`,
+        tags: ["Issuance"],
+        responses: {
+            200: {
+                description: "Returns parsed event log",
+                content: {
+                    "application/json": {
+                        schema: resolver(z.object({
+                            proxy: AddressSchema,
+                            admin: AddressSchema,
+                            minter: AddressSchema,
+                            name: z.string(),
+                            symbol: z.string(),
+                            baseURI: z.string(),
+                        })),
+                    },
+                },
+            },
+        },
+    }), validator("query", QuerySchema), async (c) => {
+        const params = c.req.valid("query");
+        const receipt = await waitForTransactionReceipt(getPublicClient(params.chainId, c.env.config), {
+            hash: params.hash,
+        });
+        const [event] = parseEventLogs({
+            abi: abis.erc721GatedPausableRecoverableFactoryAbi,
+            eventName: "TokenProxyConfigured",
+            logs: receipt.logs,
+        });
+        if (!event) {
+            throw new UnableParseErc721DeployEvent();
+        }
+        return c.json({
+            proxy: event.args.proxy,
+            admin: event.args.admin,
+            minter: event.args.minter,
+            name: event.args.name,
+            symbol: event.args.symbol,
+            baseURI: event.args.baseURI,
+        });
+    }),
+});
+class UnableParseErc721DeployEvent extends HttpError {
+    constructor() {
+        super(500, {
+            message: `Can't parse TokenProxyConfigured event. Make sure you're passing a transaction generated by the ERC721 factory \`deployAndInitializeProxy\` action`,
+            name: "UnableParseErc721DeployEvent",
+        });
+    }
+}

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

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

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

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

package/dist/issuance/erc721/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 RecoverErc721RequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    from: AddressSchema.openapi({ description: "Address to recover the token from" }),
+    to: AddressSchema.openapi({ description: "Address to recover the token to" }),
+    tokenId: Int256BigInt(z.bigint().nonnegative()),
+});
+const recoverRoute = describeRoute({
+    summary: "Recover ERC721",
+    description: "Returns transaction data for recovering an ERC721 token from one address to another (RECOVER_ROLE required)",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for recovering an ERC721 token",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const RecoverErc721 = createController({
+    build: (factory) => factory.createApp().post("/", recoverRoute, validator("json", RecoverErc721RequestSchema), async (c) => {
+        const { tokenAddress, from, to, tokenId } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            functionName: "recover",
+            args: [from, to, BigInt(tokenId)],
+        }));
+    }),
+});

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

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
+export declare const RenounceRoleErc721RequestSchema: 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>;
+    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 RenounceRoleErc721: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    tokenAddress: string;
+                    role: 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;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=renounceRole.d.ts.map

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

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

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

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

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { Erc721TokenRole } from "../../common/roles/erc721-factory-roles.js";
+export declare const RevokeRoleErc721RequestSchema: 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 RevokeRoleErc721: 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=revokeRole.d.ts.map

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

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

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

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

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

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

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

package/dist/issuance/erc721/setBaseURI.js

@@ -0,0 +1,36 @@
+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 SetBaseURIRequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    baseURI: z.string().nonempty().openapi({ description: "New base URI for token metadata" }),
+});
+const setBaseURIRoute = describeRoute({
+    summary: "Set ERC721 Base URI",
+    description: "Returns transaction data for setting the base URI on an ERC721 token",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for setting the base URI",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const SetBaseURIErc721 = createController({
+    build: (factory) => factory.createApp().post("/", setBaseURIRoute, validator("json", SetBaseURIRequestSchema), async (c) => {
+        const { tokenAddress, baseURI } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            functionName: "setBaseURI",
+            args: [baseURI],
+        }));
+    }),
+});

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

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const SetTokenURIRequestSchema: 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">>>;
+    tokenURI: z.ZodString;
+}, z.core.$strip>;
+export declare const SetTokenURIErc721: import("../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../common/context.js").AppContext, {
+    "/": {
+        $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;
+        };
+    };
+}, "/">>;
+//# sourceMappingURL=setTokenURI.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setTokenURI.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/setTokenURI.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,wBAAwB;;;;iBAInC,CAAC;AAkBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;QAc5B,CAAC"}

package/dist/issuance/erc721/setTokenURI.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 SetTokenURIRequestSchema = z.object({
+    tokenAddress: AddressSchema,
+    tokenId: Int256BigInt(z.bigint().nonnegative()),
+    tokenURI: z.string().nonempty().openapi({ description: "URI for the specific token metadata" }),
+});
+const setTokenURIRoute = describeRoute({
+    summary: "Set ERC721 Token URI",
+    description: "Returns transaction data for setting a token-specific URI on an ERC721 token",
+    tags: ["Issuance"],
+    responses: {
+        200: {
+            description: "Returns transaction data for setting a token URI",
+            content: {
+                "application/json": {
+                    schema: resolver(TransactionSchema),
+                },
+            },
+        },
+    },
+});
+export const SetTokenURIErc721 = createController({
+    build: (factory) => factory.createApp().post("/", setTokenURIRoute, validator("json", SetTokenURIRequestSchema), async (c) => {
+        const { tokenAddress, tokenId, tokenURI } = c.req.valid("json");
+        return c.json(toTransaction({
+            address: tokenAddress,
+            abi: abis.erc721PausableRecoverableUpgradeableAbi,
+            functionName: "setTokenURI",
+            args: [BigInt(tokenId), tokenURI],
+        }));
+    }),
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"transferFrom.d.ts","sourceRoot":"","sources":["../../../src/issuance/erc721/transferFrom.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,+BAA+B;;;;;iBAK1C,CAAC;AAkBH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;QAc7B,CAAC"}