Merge pull request #1011 from xwxtwd/feat/add_plugin-nft-generator

feat: Add plugin-nft-generation: create Solana NFT collections.

.env.example

@@ -157,6 +157,10 @@ EVM_PROVIDER_URL=
 # Solana
 SOLANA_PRIVATE_KEY=
 SOLANA_PUBLIC_KEY=
+SOLANA_CLUSTER= # Default: devnet. Solana Cluster: 'devnet' | 'testnet' | 'mainnet-beta'
+SOLANA_ADMIN_PRIVATE_KEY= # This wallet is used to verify NFTs
+SOLANA_ADMIN_PUBLIC_KEY= # This wallet is used to verify NFTs
+SOLANA_VERIFY_TOKEN= # Authentication token for calling the verification API
 
 # Fallback Wallet Configuration (deprecated)
 WALLET_PRIVATE_KEY=

agent/package.json

@@ -39,6 +39,7 @@
         "@ai16z/plugin-goat": "workspace:*",
         "@ai16z/plugin-icp": "workspace:*",
         "@ai16z/plugin-image-generation": "workspace:*",
+        "@ai16z/plugin-nft-generation": "workspace:*",
         "@ai16z/plugin-node": "workspace:*",
         "@ai16z/plugin-solana": "workspace:*",
         "@ai16z/plugin-starknet": "workspace:*",

agent/src/index.ts

@@ -50,6 +50,7 @@ import { solanaPlugin } from "@ai16z/plugin-solana";
 import { TEEMode, teePlugin } from "@ai16z/plugin-tee";
 import { tonPlugin } from "@ai16z/plugin-ton";
 import { zksyncEraPlugin } from "@ai16z/plugin-zksync-era";
+import { nftGenerationPlugin, createNFTApiRouter } from "@ai16z/plugin-nft-generation";
 import Database from "better-sqlite3";
 import fs from "fs";
 import path from "path";
@@ -493,6 +494,14 @@ export async function createAgent(
                 getSecret(character, "WALLET_PUBLIC_KEY")?.startsWith("0x"))
                 ? evmPlugin
                 : null,
+            (getSecret(character, "SOLANA_PUBLIC_KEY") ||
+            (getSecret(character, "WALLET_PUBLIC_KEY") &&
+                !getSecret(character, "WALLET_PUBLIC_KEY")?.startsWith("0x"))) &&
+            getSecret(character, "SOLANA_ADMIN_PUBLIC_KEY") &&
+            getSecret(character, "SOLANA_PRIVATE_KEY") &&
+            getSecret(character, "SOLANA_ADMIN_PRIVATE_KEY")
+                ? nftGenerationPlugin
+                : null,
             getSecret(character, "ZEROG_PRIVATE_KEY") ? zgPlugin : null,
             getSecret(character, "COINBASE_COMMERCE_KEY")
                 ? coinbaseCommercePlugin

packages/core/src/environment.ts

@@ -124,6 +124,11 @@ export const CharacterSchema = z.object({
             nicknames: z.array(z.string()).optional(),
         })
         .optional(),
+    nft: z
+        .object({
+            prompt: z.string().optional(),
+        })
+        .optional(),
 });
 
 // Type inference

packages/core/src/types.ts

@@ -767,6 +767,10 @@ export type Character = {
         bio: string;
         nicknames?: string[];
     };
+    /** Optional NFT prompt */
+    nft?: {
+        prompt: string;
+    }
 };
 
 /**
@@ -1163,6 +1167,7 @@ export interface IPdfService extends Service {
 export interface IAwsS3Service extends Service {
     uploadFile(
         imagePath: string,
+        subDirectory: string,
         useSignedUrl: boolean,
         expiresIn: number
     ): Promise<{

packages/plugin-nft-generation/.npmignore

@@ -0,0 +1,6 @@
+*
+
+!dist/**
+!package.json
+!readme.md
+!tsup.config.ts

packages/plugin-nft-generation/eslint.config.mjs

@@ -0,0 +1,3 @@
+import eslintGlobalConfig from "../../eslint.config.mjs";
+
+export default [...eslintGlobalConfig];

packages/plugin-nft-generation/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@ai16z/plugin-nft-generation",
+    "version": "0.1.5-alpha.5",
+    "main": "dist/index.js",
+    "type": "module",
+    "types": "dist/index.d.ts",
+    "dependencies": {
+        "@ai16z/eliza": "workspace:*",
+        "@ai16z/plugin-image-generation": "workspace:*",
+        "@ai16z/plugin-node": "workspace:*",
+        "@metaplex-foundation/mpl-token-metadata": "^3.3.0",
+        "@metaplex-foundation/mpl-toolbox": "^0.9.4",
+        "@metaplex-foundation/umi": "^0.9.2",
+        "@metaplex-foundation/umi-bundle-defaults": "^0.9.2",
+        "@solana-developers/helpers": "^2.5.6",
+        "@solana/web3.js": "1.95.5",
+        "bs58": "6.0.0",
+        "express": "4.21.1",
+        "node-cache": "5.1.2",
+        "tsup": "8.3.5"
+    },
+    "scripts": {
+        "build": "tsup --format esm --dts",
+        "dev": "tsup --format esm --dts --watch",
+        "lint": "eslint . --fix"
+    },
+    "peerDependencies": {
+        "whatwg-url": "7.1.0"
+    }
+}

packages/plugin-nft-generation/src/api.ts

@@ -0,0 +1,165 @@
+import express from "express";
+
+import { AgentRuntime } from "@ai16z/eliza";
+import { createCollection } from "./handlers/createCollection.ts";
+import { createNFT, createNFTMetadata } from "./handlers/createNFT.ts";
+import { verifyNFT } from "./handlers/verifyNFT.ts";
+
+export function createNFTApiRouter(agents: Map<string, AgentRuntime>) {
+    const router = express.Router();
+
+    router.post(
+        "/api/nft-generation/create-collection",
+        async (req: express.Request, res: express.Response) => {
+            const agentId = req.body.agentId;
+            const fee = req.body.fee || 0;
+            const runtime = agents.get(agentId);
+            if (!runtime) {
+                res.status(404).send("Agent not found");
+                return;
+            }
+            try {
+                const collectionAddressRes = await createCollection({
+                    runtime,
+                    collectionName: runtime.character.name,
+                    fee
+                });
+
+                res.json({
+                    success: true,
+                    data: collectionAddressRes,
+                });
+            } catch (e: any) {
+                console.log(e);
+                res.json({
+                    success: false,
+                    data: JSON.stringify(e),
+                });
+            }
+        }
+    );
+
+
+    router.post(
+        "/api/nft-generation/create-nft-metadata",
+        async (req: express.Request, res: express.Response) => {
+            const agentId = req.body.agentId;
+            const collectionName = req.body.collectionName;
+            const collectionAddress = req.body.collectionAddress;
+            const collectionAdminPublicKey = req.body.collectionAdminPublicKey;
+            const collectionFee = req.body.collectionFee;
+            const tokenId = req.body.tokenId;
+            const runtime = agents.get(agentId);
+            if (!runtime) {
+                res.status(404).send("Agent not found");
+                return;
+            }
+
+            try {
+                const nftInfo = await createNFTMetadata({
+                    runtime,
+                    collectionName,
+                    collectionAdminPublicKey,
+                    collectionFee,
+                    tokenId,
+                });
+
+                res.json({
+                    success: true,
+                    data: {
+                        ...nftInfo,
+                        collectionAddress,
+                    },
+                });
+            } catch (e: any) {
+                console.log(e);
+                res.json({
+                    success: false,
+                    data: JSON.stringify(e),
+                });
+            }
+        }
+    );
+
+    router.post(
+        "/api/nft-generation/create-nft",
+        async (req: express.Request, res: express.Response) => {
+            const agentId = req.body.agentId;
+            const collectionName = req.body.collectionName;
+            const collectionAddress = req.body.collectionAddress;
+            const collectionAdminPublicKey = req.body.collectionAdminPublicKey;
+            const collectionFee = req.body.collectionFee;
+            const tokenId = req.body.tokenId;
+            const runtime = agents.get(agentId);
+            if (!runtime) {
+                res.status(404).send("Agent not found");
+                return;
+            }
+
+            try {
+                const nftRes = await createNFT({
+                    runtime,
+                    collectionName,
+                    collectionAddress,
+                    collectionAdminPublicKey,
+                    collectionFee,
+                    tokenId,
+                });
+
+                res.json({
+                    success: true,
+                    data: nftRes,
+                });
+            } catch (e: any) {
+                console.log(e);
+                res.json({
+                    success: false,
+                    data: JSON.stringify(e),
+                });
+            }
+        }
+    );
+
+
+    router.post(
+        "/api/nft-generation/verify-nft",
+        async (req: express.Request, res: express.Response) => {
+            const agentId = req.body.agentId;
+            const collectionAddress = req.body.collectionAddress;
+            const NFTAddress = req.body.nftAddress;
+            const token = req.body.token;
+
+            const runtime = agents.get(agentId);
+            if (!runtime) {
+                res.status(404).send("Agent not found");
+                return;
+            }
+            const verifyToken = runtime.getSetting('SOLANA_VERIFY_TOKEN')
+            if (token !== verifyToken) {
+                res.status(401).send(" Access denied for translation");
+                return;
+            }
+            try {
+               const {success} = await verifyNFT({
+                    runtime,
+                    collectionAddress,
+                    NFTAddress,
+                });
+
+                res.json({
+                    success: true,
+                    data: success ? 'verified' : 'unverified',
+                });
+            } catch (e: any) {
+                console.log(e);
+                res.json({
+                    success: false,
+                    data: JSON.stringify(e),
+                });
+            }
+        }
+    );
+
+
+    return router;
+}