Merge pull request #313 from o-on-x/main

added working pumpfun.ts

Author: o-on-x

.env.example

@@ -29,6 +29,9 @@ X_SERVER_URL=
 XAI_API_KEY=
 XAI_MODEL=
 
+#USE IMAGE GEN
+IMAGE_GEN= #TRUE
+
 #Leave blank to use local embeddings 
 USE_OPENAI_EMBEDDING=  #TRUE
 

packages/client-discord/src/index.ts

@@ -73,6 +73,7 @@ export class DiscordClient extends EventEmitter {
         this.runtime.registerAction(transcribe_media);
         this.runtime.registerAction(download_media);
 
+
         this.runtime.providers.push(channelStateProvider);
         this.runtime.providers.push(voiceStateProvider);
     }

packages/plugin-image-generation/src/index.ts

@@ -9,9 +9,34 @@ import {
 } from "@ai16z/eliza/src/types.ts";
 import { generateCaption, generateImage } from "@ai16z/eliza/src/generation.ts";
 
+import fs from 'fs';
+import path from 'path';
+
+export function saveBase64Image(base64Data: string, filename: string): string {
+    // Create generatedImages directory if it doesn't exist
+    const imageDir = path.join(process.cwd(), 'generatedImages');
+    if (!fs.existsSync(imageDir)) {
+        fs.mkdirSync(imageDir, { recursive: true });
+    }
+
+    // Remove the data:image/png;base64 prefix if it exists
+    const base64Image = base64Data.replace(/^data:image\/\w+;base64,/, '');
+    
+    // Create a buffer from the base64 string
+    const imageBuffer = Buffer.from(base64Image, 'base64');
+    
+    // Create full file path
+    const filepath = path.join(imageDir, `${filename}.png`);
+    
+    // Save the file
+    fs.writeFileSync(filepath, imageBuffer);
+    
+    return filepath;
+}
+
 const imageGeneration: Action = {
     name: "GENERATE_IMAGE",
-    similes: ["IMAGE_GENERATION", "IMAGE_GEN", "CREATE_IMAGE", "MAKE_PICTURE"],
+    similes: ["IMAGE_GENERATION", "IMAGE_GEN", "CREATE_IMAGE", "MAKE_PICTURE",],
     description: "Generate an image to go along with the message.",
     validate: async (runtime: IAgentRuntime, message: Memory) => {
         const anthropicApiKeyOk = !!runtime.getSetting("ANTHROPIC_API_KEY");
@@ -58,36 +83,62 @@ const imageGeneration: Action = {
             );
             for (let i = 0; i < images.data.length; i++) {
                 const image = images.data[i];
-                elizaLogger.log(`Processing image ${i + 1}:`, image);
+                
+                const base64Image = images.data[i];
+                // Save the image and get filepath
+                const filename = `generated_${Date.now()}_${i}`;
+                const filepath = saveBase64Image(base64Image, filename);
+                elizaLogger.log(`Processing image ${i + 1}:`, filename);
 
-                const caption = await generateCaption(
+                //just dont even add a caption or a description just have it generate & send
+                /*
+                try {
+                    const imageService = runtime.getService(ServiceType.IMAGE_DESCRIPTION);
+                    if (imageService && typeof imageService.describeImage === 'function') {
+                        const caption = await imageService.describeImage({ imageUrl: filepath });
+                        captionText = caption.description;
+                        captionTitle = caption.title;
+                    }
+                } catch (error) {
+                    elizaLogger.error("Caption generation failed, using default caption:", error);
+                }*/
+                
+                const caption = "...";
+                /*= await generateCaption(
                     {
                         imageUrl: image,
                     },
                     runtime
-                );
+                );*/
+
+                res.push({ image: filepath, caption: "..."});//caption.title });
 
                 elizaLogger.log(
                     `Generated caption for image ${i + 1}:`,
-                    caption.title
+                    "..."//caption.title
                 );
-                res.push({ image: image, caption: caption.title });
+                //res.push({ image: image, caption: caption.title });
 
                 callback(
                     {
-                        text: caption.description,
+                        text: "...",//caption.description,
                         attachments: [
                             {
                                 id: crypto.randomUUID(),
-                                url: image,
+                                url: filepath,
                                 title: "Generated image",
                                 source: "imageGeneration",
-                                description: caption.title,
-                                text: caption.description,
+                                description: "...",//caption.title,
+                                text: "...",//caption.description,
                             },
                         ],
                     },
-                    []
+                    [  
+                            {
+                            attachment: filepath,
+                            name: `${filename}.png`
+                        }
+                    ]
                 );
             }
         } else {

packages/plugin-solana/src/actions/pumpfun.ts

@@ -1,5 +1,6 @@
 import { AnchorProvider } from "@coral-xyz/anchor";
 import { Wallet } from "@coral-xyz/anchor";
+import { generateImage } from "@ai16z/eliza/src/generation.ts";
 import { Connection, Keypair, PublicKey } from "@solana/web3.js";
 import {
     CreateTokenMetadata,
@@ -14,40 +15,53 @@ import settings from "@ai16z/eliza/src/settings.ts";
 import {
     ActionExample,
     Content,
+    HandlerCallback,
     IAgentRuntime,
     Memory,
+    ModelClass,
+    State,
     type Action,
 } from "@ai16z/eliza/src/types.ts";
+import { composeContext } from "@ai16z/eliza/src/context.ts";
+import { generateObject } from "@ai16z/eliza/src/generation.ts";
+
+import {
+    walletProvider,
+    //WalletProvider,
+} from "../providers/wallet.ts";
+
+import { bs58 } from "@coral-xyz/anchor/dist/cjs/utils/bytes/index.js";
+
 
 export interface CreateAndBuyContent extends Content {
-    deployerPrivateKey: string;
-    tokenMetadata: CreateTokenMetadata;
-    buyAmountSol: string | number;
-    priorityFee: {
-        unitLimit: number;
-        unitPrice: number;
+    tokenMetadata: {
+        name: string;
+        symbol: string;
+        description: string;
+        image_description: string; 
     };
-    allowOffCurve: boolean;
+    buyAmountSol: string | number;
 }
 
+
 export function isCreateAndBuyContent(
     runtime: IAgentRuntime,
     content: any
 ): content is CreateAndBuyContent {
+    console.log("Content for create & buy", content)
     return (
-        typeof content.deployerPrivateKey === "string" &&
         typeof content.tokenMetadata === "object" &&
         content.tokenMetadata !== null &&
+        typeof content.tokenMetadata.name === "string" &&
+        typeof content.tokenMetadata.symbol === "string" &&
+        typeof content.tokenMetadata.description === "string" &&
+        typeof content.tokenMetadata.image_description === "string" &&
         (typeof content.buyAmountSol === "string" ||
-            typeof content.buyAmountSol === "number") &&
-        typeof content.priorityFee === "object" &&
-        content.priorityFee !== null &&
-        typeof content.priorityFee.unitLimit === "number" &&
-        typeof content.priorityFee.unitPrice === "number" &&
-        typeof content.allowOffCurve === "boolean"
+            typeof content.buyAmountSol === "number")
     );
 }
 
+
 export const createAndBuyToken = async ({
     deployer,
     mint,
@@ -88,6 +102,9 @@ export const createAndBuyToken = async ({
         priorityFee,
         commitment
     );
+
+    console.log("Create Results: ", createResults);
+
     if (createResults.success) {
         console.log(
             "Success:",
@@ -111,9 +128,21 @@ export const createAndBuyToken = async ({
         } else {
             console.log(`${deployer.publicKey.toBase58()}:`, amount);
         }
+
+        return {
+            success: true,
+            ca: mint.publicKey.toBase58(),    
+            creator: deployer.publicKey.toBase58()        
+        };
+
     } else {
         console.log("Create and Buy failed");
-    }
+        return {
+            success: false,
+            ca: mint.publicKey.toBase58(),
+            error: createResults.error || "Transaction failed"
+        };
+    } 
 };
 
 export const buyToken = async ({
@@ -213,6 +242,7 @@ export const sellToken = async ({
 };
 
 const promptConfirmation = async (): Promise<boolean> => {
+    return true;
     if (typeof window !== "undefined" && typeof window.confirm === "function") {
         return window.confirm(
             "Confirm the creation and purchase of the token?"
@@ -221,109 +251,275 @@ const promptConfirmation = async (): Promise<boolean> => {
     return true;
 };
 
+// Save the base64 data to a file
+import * as fs from 'fs';
+import * as path from 'path';
+
+
+const pumpfunTemplate = `Respond with a JSON markdown block containing only the extracted values. Use null for any values that cannot be determined.
+
+Example response:
+\`\`\`json
+{
+    "tokenMetadata": {
+        "name": "Test Token",
+        "symbol": "TEST",
+        "description": "A test token",
+        "image_description": "create an image of a rabbit"
+    },
+    "buyAmountSol": "0.00069"
+}
+\`\`\`
+
+{{recentMessages}}
+
+Given the recent messages, extract or generate (come up with if not included) the following information about the requested token creation:
+- Token name
+- Token symbol
+- Token description 
+- Token image description 
+- Amount of SOL to buy
+
+Respond with a JSON markdown block containing only the extracted values.`;
+
+
+
 export default {
     name: "CREATE_AND_BUY_TOKEN",
     similes: ["CREATE_AND_PURCHASE_TOKEN", "DEPLOY_AND_BUY_TOKEN"],
     validate: async (runtime: IAgentRuntime, message: Memory) => {
-        return isCreateAndBuyContent(runtime, message.content);
+        
+        return true;//return isCreateAndBuyContent(runtime, message.content);
     },
     description:
         "Create a new token and buy a specified amount using SOL. Requires deployer private key, token metadata, buy amount in SOL, priority fee, and allowOffCurve flag.",
-    handler: async (
-        runtime: IAgentRuntime,
-        message: Memory
-    ): Promise<boolean> => {
-        const content = message.content;
-        if (!isCreateAndBuyContent(runtime, content)) {
-            console.error("Invalid content for CREATE_AND_BUY_TOKEN action.");
-            return false;
-        }
-        const {
-            deployerPrivateKey,
-            tokenMetadata,
-            buyAmountSol,
-            priorityFee,
-            allowOffCurve,
-        } = content;
-
-        const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY")!;
-        const wallet = new Wallet(
-            Keypair.fromSecretKey(new Uint8Array(JSON.parse(privateKey)))
-        );
-        const connection = new Connection(settings.RPC_URL!);
-        const provider = new AnchorProvider(connection, wallet, {
-            commitment: "finalized",
-        });
-        const sdk = new PumpFunSDK(provider);
-        const slippage = runtime.getSetting("SLIPPAGE");
-
-        try {
-            const deployerKeypair = Keypair.fromSecretKey(
-                Uint8Array.from(Buffer.from(deployerPrivateKey, "base64"))
-            );
+        handler: async (
+            runtime: IAgentRuntime,
+            message: Memory,
+            state: State,
+            _options: { [key: string]: unknown },
+            callback?: HandlerCallback
+        ): Promise<boolean> => {
+            console.log("Starting CREATE_AND_BUY_TOKEN handler...");
+            
+            // Compose state if not provided
+            if (!state) {
+                state = (await runtime.composeState(message)) as State;
+            } else {
+                state = await runtime.updateRecentMessageState(state);
+            }
+        
+            // Get wallet info for context
+            const walletInfo = await walletProvider.get(runtime, message, state);
+            state.walletInfo = walletInfo;
+        
+            // Generate structured content from natural language
+            const pumpContext = composeContext({
+                state,
+                template: pumpfunTemplate,
+            });
+        
+            const content = await generateObject({
+                runtime,
+                context: pumpContext,
+                modelClass: ModelClass.LARGE,
+            });
+            
+            // Validate the generated content
+            if (!isCreateAndBuyContent(runtime, content)) {
+                console.error("Invalid content for CREATE_AND_BUY_TOKEN action.");
+                return false;
+            }
+            
+            const { tokenMetadata, buyAmountSol } = content;
+            /*
+            // Generate image if tokenMetadata.file is empty or invalid
+            if (!tokenMetadata.file || tokenMetadata.file.length < 100) {  // Basic validation
+                try {
+                    const imageResult = await generateImage({
+                        prompt: `logo for ${tokenMetadata.name} (${tokenMetadata.symbol}) token - ${tokenMetadata.description}`,
+                        width: 512,
+                        height: 512,
+                        count: 1
+                    }, runtime);
+        
+                    if (imageResult.success && imageResult.data && imageResult.data.length > 0) {
+                        // Remove the "data:image/png;base64," prefix if present
+                        tokenMetadata.file = imageResult.data[0].replace(/^data:image\/[a-z]+;base64,/, '');
+                    } else {
+                        console.error("Failed to generate image:", imageResult.error);
+                        return false;
+                    }
+                } catch (error) {
+                    console.error("Error generating image:", error);
+                    return false;
+                }
+            } */
 
-            const mintKeypair = Keypair.generate();
+            const imageResult = await generateImage({
+                prompt: `logo for ${tokenMetadata.name} (${tokenMetadata.symbol}) token - ${tokenMetadata.description}`,
+                width: 256,
+                height: 256,
+                count: 1
+            }, runtime);
 
-            const createAndBuyConfirmation = await promptConfirmation();
-            if (!createAndBuyConfirmation) {
-                console.log("Create and buy token canceled by user");
-                return false;
+
+            tokenMetadata.image_description = imageResult.data[0].replace(/^data:image\/[a-z]+;base64,/, '');
+
+
+
+
+            // Convert base64 string to Blob
+            const base64Data = tokenMetadata.image_description;
+            const outputPath = path.join(process.cwd(), `generated_image_${Date.now()}.txt`);
+            fs.writeFileSync(outputPath, base64Data);
+            console.log(`Base64 data saved to: ${outputPath}`);
+
+
+            const byteCharacters = atob(base64Data);
+            const byteNumbers = new Array(byteCharacters.length);
+            for (let i = 0; i < byteCharacters.length; i++) {
+                byteNumbers[i] = byteCharacters.charCodeAt(i);
             }
+            const byteArray = new Uint8Array(byteNumbers);
+            const blob = new Blob([byteArray], { type: 'image/png' });
+        
+            // Add the default decimals and convert file to Blob
+            const fullTokenMetadata: CreateTokenMetadata = {
+                name: tokenMetadata.name,
+                symbol: tokenMetadata.symbol,
+                description: tokenMetadata.description,
+                file: blob,
+            };
 
-            // Execute Create and Buy
-            await createAndBuyToken({
-                deployer: deployerKeypair,
-                mint: mintKeypair,
-                tokenMetadata: tokenMetadata as CreateTokenMetadata,
-                buyAmountSol: BigInt(buyAmountSol),
-                priorityFee: priorityFee as PriorityFee,
-                allowOffCurve: allowOffCurve as boolean,
-                sdk,
-                connection,
-                slippage,
-            });
+            // Default priority fee for high network load
+            const priorityFee = {
+                unitLimit: 100_000_000,
+                unitPrice: 100_000
+            };
+            const slippage = "2000"
+            try {
+                // Get private key from settings and create deployer keypair
+                const privateKeyString = runtime.getSetting("WALLET_PRIVATE_KEY")!;
+                const secretKey = bs58.decode(privateKeyString);
+                const deployerKeypair = Keypair.fromSecretKey(secretKey);
 
-            console.log(
-                `Token created and purchased successfully! View at: https://pump.fun/${mintKeypair.publicKey.toBase58()}`
-            );
-            return true;
-        } catch (error) {
-            console.error("Error during create and buy token:", error);
-            return false;
-        }
+                // Generate new mint keypair
+                const mintKeypair = Keypair.generate();
+                console.log(`Generated mint address: ${mintKeypair.publicKey.toBase58()}`);
+
+                // Setup connection and SDK
+                const connection = new Connection(settings.RPC_URL!, {
+                    commitment: "confirmed",
+                    confirmTransactionInitialTimeout: 500000, // 120 seconds
+                    wsEndpoint: settings.RPC_URL!.replace('https', 'wss')
+                });
+
+                const wallet = new Wallet(deployerKeypair);
+                const provider = new AnchorProvider(connection, wallet, {
+                    commitment: "finalized"
+                });
+                const sdk = new PumpFunSDK(provider);
+               // const slippage = runtime.getSetting("SLIPPAGE");
+
+
+                const createAndBuyConfirmation = await promptConfirmation();
+                if (!createAndBuyConfirmation) {
+                    console.log("Create and buy token canceled by user");
+                return false;
+                }
+
+                // Convert SOL to lamports (1 SOL = 1_000_000_000 lamports)
+                const lamports = Math.floor(Number(buyAmountSol) * 1_000_000_000);
+                
+                console.log("Executing create and buy transaction...");
+                const result = await createAndBuyToken({
+                    deployer: deployerKeypair,
+                    mint: mintKeypair,
+                    tokenMetadata: fullTokenMetadata,
+                    buyAmountSol: BigInt(lamports),
+                    priorityFee,
+                    allowOffCurve: false,
+                    sdk,
+                    connection,
+                    slippage,
+                });
+
+
+                if (callback) {
+                    if (result.success) {
+                        callback({
+                            text: `Token ${tokenMetadata.name} (${tokenMetadata.symbol}) created successfully!\nContract Address: ${result.ca}\nCreator: ${result.creator}\nView at: https://pump.fun/${result.ca}`,
+                            content: {
+                                tokenInfo: {
+                                    symbol: tokenMetadata.symbol,
+                                    address: result.ca,
+                                    creator: result.creator,
+                                    name: tokenMetadata.name,
+                                    description: tokenMetadata.description,
+                                    timestamp: Date.now()
+                                }
+                            }
+                        });
+                    } else {
+                        callback({
+                            text: `Failed to create token: ${result.error}\nAttempted mint address: ${result.ca}`,
+                            content: {
+                                error: result.error,
+                                mintAddress: result.ca
+                            }
+                        });
+                    }
+                }
+                //await trustScoreDb.addToken(tokenInfo);
+                /*
+                // Update runtime state
+                await runtime.updateState({
+                    ...state,
+                    lastCreatedToken: tokenInfo
+                });
+                */
+                // Log success message with token view URL
+                const successMessage = `Token created and purchased successfully! View at: https://pump.fun/${mintKeypair.publicKey.toBase58()}`;
+                console.log(successMessage);
+                return result.success;
+            } catch (error) {
+                if (callback) {
+                    callback({
+                        text: `Error during token creation: ${error.message}`,
+                        content: { error: error.message }
+                    });
+                }
+                return false;
+            }
     },
 
     examples: [
         [
             {
                 user: "{{user1}}",
                 content: {
-                    deployerPrivateKey: "Base64EncodedPrivateKey",
-                    tokenMetadata: {
-                        name: "MyToken",
-                        symbol: "MTK",
-                        description: "My first token",
-                        file: "Base64EncodedFile", // blob file of the image
-                        decimals: DEFAULT_DECIMALS,
-                    },
-                    buyAmountSol: "1000000000", // 1 SOL in lamports
-                    priorityFee: 1000,
-                    allowOffCurve: false,
-                },
+                    text: "Create a new token called GLITCHIZA with symbol GLITCHIZA and generate a description about it. Also come up with a description for it to use for image generation .buy 0.00069 SOL worth."
+                }
             },
             {
                 user: "{{user2}}",
                 content: {
-                    text: "Creating and buying 1 SOL worth of MyToken...",
+                    text: "Token GLITCHIZA (GLITCHIZA) created successfully!\nContract Address: 3kD5DN4bbA3nykb1abjS66VF7cYZkKdirX8bZ6ShJjBB\nCreator: 9jW8FPr6BSSsemWPV22UUCzSqkVdTp6HTyPqeqyuBbCa\nView at: https://pump.fun/EugPwuZ8oUMWsYHeBGERWvELfLGFmA1taDtmY8uMeX6r",
                     action: "CREATE_AND_BUY_TOKEN",
-                },
-            },
-            {
-                user: "{{user2}}",
-                content: {
-                    text: "Token created and purchased successfully! View at: https://pump.fun/MintPublicKey",
-                },
-            },
-        ],
-    ] as ActionExample[][],
+                    content: {
+                        tokenInfo: {
+                            symbol: "GLITCHIZA",
+                            address: "EugPwuZ8oUMWsYHeBGERWvELfLGFmA1taDtmY8uMeX6r",
+                            creator: "9jW8FPr6BSSsemWPV22UUCzSqkVdTp6HTyPqeqyuBbCa",
+                            name: "GLITCHIZA",
+                            description: "A GLITCHIZA token"
+                        }
+                    }
+                }
+            }
+        ]
+    ] as ActionExample[][]
+    
+    ,
 } as Action;