Blockchain AI Agent

Blockchain AI Agent is an open-source framework that enables developers to integrate AI-powered agents with Solana and EVM (Ethereum Virtual Machine) blockchains. With built-in tools and streamlined APIs, the agent empowers developers to perform advanced blockchain operations autonomously using AI models

🌟 Features

🚀 Blockchain Operations

Solana Integration

• Token Management
  • Mint SPL tokens
  • Transfer assets
  • Stake SOL
  • Execute compressed airdrops
• NFT Utilities
  • Create and list NFTs with Metaplex
  • Build collections and marketplaces
• DeFi Protocols
  • Swap tokens with Jupiter
  • Manage liquidity with Raydium and Orca
  • Lend and borrow assets on Solana platforms
• Market Data
  • Fetch Pyth price feeds
  • Resolve domains with SNS
• Advanced Actions
  • Execute transactions via Jito bundles
  • Manage perpetuals with Drift Protocol

EVM Integration

• Smart Contract Interaction
  • Deploy, call, and manage Solidity-based contracts
  • Execute ERC20/721 operations
• Token Management
  • Launch tokens (ERC20) with custom parameters
  • Transfer assets across wallets
• DeFi Protocols
  • Trade tokens on Uniswap, PancakeSwap, and other DEXs
  • Stake assets on popular EVM protocols
  • Fetch market data using Chainlink price oracles
• NFT Operations
  • Mint, transfer, and list NFTs for sale
  • Manage metadata and royalties

🤖 AI Features

• Autonomous Execution
  • AI agents can independently perform blockchain actions
  • Configurable decision-making and execution intervals
• LangChain Integration
  • Prebuilt tools for natural language command execution
  • Support for memory and persistent interactions
• Multi-Blockchain Compatibility
  • Seamless switching between Solana and EVM blockchains
• Customizable Workflows
  • Extendable modules for task-specific AI agents
  • Fully typed APIs for TypeScript developers

📦 Installation

Install the library via npm:

npm install blockchain-ai-agent

🔧 Configuration

To initialize the agent for Solana and EVM, provide your wallet credentials and the respective RPC URLs.

import { BlockchainAIAgent } from "blockchain-ai-agent";

const agent = new BlockchainAIAgent({
  solana: {
    privateKey: "your-solana-wallet-private-key",
    rpcUrl: "https://api.mainnet-beta.solana.com",
  },
  evm: {
    privateKey: "your-evm-wallet-private-key",
    rpcUrl: "https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID",
  },
  aiApiKey: "your-openai-api-key", // Optional for AI-driven actions
});

📃 Usage Examples

1. Mint and Transfer Tokens (Solana)

const tokenMint = await agent.solana.mintToken({
  name: "AI Token",
  symbol: "AIT",
  uri: "https://example.com/metadata.json",
  decimals: 9,
  supply: 1000000,
});

await agent.solana.transfer({
  mint: tokenMint,
  to: "recipient-wallet-address",
  amount: 100,
});

2. Swap Tokens (EVM)

const tx = await agent.evm.swapTokens({
  dex: "uniswap",
  inputToken: "USDT",
  outputToken: "ETH",
  amount: 100, // USDT amount
  slippage: 1, // 1%
});
console.log("Swap Transaction Hash:", tx);

3. Deploy an NFT Collection

Solana

const collection = await agent.solana.createCollection({
  name: "AI Art",
  symbol: "AIA",
  uri: "https://example.com/collection-metadata.json",
});

EVM

const nft = await agent.evm.deployNFT({
  name: "AI Art NFT",
  symbol: "AIA",
  baseUri: "https://example.com/nft-metadata/",
});

4. Fetch Market Data

Solana

const solPrice = await agent.solana.getPrice("SOL/USD");
console.log("Current SOL Price:", solPrice);

EVM

const ethPrice = await agent.evm.getPrice("ETH/USD", "chainlink");
console.log("Current ETH Price:", ethPrice);

🤖 AI Agent Integration

Natural Language Commands

Integrate AI for processing blockchain tasks via natural language commands.

const result = await agent.ai.executeCommand("Create an NFT on Solana with 5% royalties");
console.log("AI Response:", result);

NFT Artwork Generation

Use DALL-E to generate custom NFT artwork.

const nftImage = await agent.ai.generateNFTArtwork({
  prompt: "A futuristic AI in a neon city",
});
console.log("NFT Image URL:", nftImage);

🌐 Supported Platforms

Blockchain Networks:

• Solana
• EVM-Compatible Chains:
  • Ethereum
  • Binance Smart Chain
  • Polygon
  • Avalanche
  • Fantom
  • Arbitrum
  • Optimism

AI Frameworks:

• OpenAI (ChatGPT, GPT-4)
• LangChain
• DALL-E

📚 Documentation

Explore the full documentation at docs.blockchain-ai-agent.com.

🛠️ Contributing

We welcome contributions! Please follow the guidelines in CONTRIBUTING.md to submit a PR.

🛡️ Security

Important: This toolkit involves sensitive operations like private key handling. Always use it in a secure environment.

🧧 Funding

If you’d like to support this open-source project, please donate to the treasury wallet:

• Solana Address: 5AhN9khvQDbepm3DyotLefYhE9AD5RnDSsHWpaJiGuq1
• EVM Address: 0xf7Da17CC5f2F7e8667c0dC2BbA50BFe08D277e43

Contact

👤 Author

Telegram: Meta0xFlip

Github: Meta0xFlip

https://t.me/Meta0xFlip

Let me know if you'd like to tweak any section or add further customizations!

AI-OnChain-Agent

Description

Blockchain Assistant is a powerful tool designed to interact with blockchain networks, specifically tailored for Ethereum-compatible chains. It leverages OpenAI's GPT-4o-mini model to provide a conversational interface for users to perform various blockchain operations, such as checking wallet balances, sending transactions, and deploying smart contracts. The assistant embodies the persona of Darth Vader, delivering responses with a commanding and cryptic tone.

Features

• Conversational Interface: Engage with the assistant to perform blockchain operations through natural language.
• Wallet Operations: Check wallet balances and retrieve connected wallet addresses.
• Transaction Management: Send transactions with customizable parameters.
• Smart Contract Interaction: Deploy ERC20 tokens and interact with existing contracts.
• Error Handling: Robust error handling and feedback for failed operations.

Getting Started

Prerequisites

• Node.js (version 14 or higher)
• TypeScript
• OpenAI API key
• Environment variables for wallet private key and other configurations

Installation

1. Clone the repository:

   git clone https://github.com/dieharye/blochain-AI-Agent.git
   cd blockchain-AI-Agent/evm

2. Install dependencies:

   bun install

3. Set up environment variables:
   Create a .env file in the root directory and add your OpenAI API key and wallet private key:

   OPENAI_API_KEY=your_openai_api_key
   WALLET_PRIVATE_KEY=your_wallet_private_key

Usage

To start the assistant, run:

bun run src/index.ts

You can then interact with the assistant in the command line. Type "exit" to end the conversation.

Tools

The assistant has access to various tools for performing blockchain operations:

Read Operations

• get_balance: Check wallet balances on the Avalanche Fuji testnet
• get_wallet_address: Retrieve the connected wallet's address

Write Operations

• send_transaction: Send transactions with customizable parameters including:
  • Transaction value in ETH
  • Custom data for contract interactions
  • Gas price settings
  • EIP-2930 access lists
  • Factory dependencies
  • Paymaster configurations
• deploy_erc20: Deploy new ERC20 token contracts with:
  • Customizable token name and symbol
  • Configurable initial supply
  • Standard ERC20 functionality

Codebase Flow

The following sequence diagram illustrates the core flow of the application:

sequenceDiagram
    participant User
    participant Main
    participant Assistant
    participant Thread
    participant Tools
    participant Blockchain

    User->>Main: Start Application
    Main->>Assistant: Create Assistant
    Main->>Thread: Create Thread
    
    loop Chat Session
        User->>Main: Enter Command
        alt Command == "exit"
            Main->>User: End Session
        else Valid Command
            Main->>Thread: Add Message
            Thread->>Assistant: Process Message
            
            opt Requires Blockchain Action
                Assistant->>Tools: Call Tool
                Tools->>Blockchain: Execute Operation
                Blockchain-->>Tools: Return Result
                Tools-->>Assistant: Return Response
            end
            
            Assistant-->>Thread: Update Thread
            Thread-->>Main: Return Response
            Main->>User: Display Response
        end
    end

Diagram Explanation

The sequence diagram above shows the interaction flow between different components:

1. Initialization:

   • Application starts with creating an OpenAI Assistant
   • A new Thread is created for the conversation

2. Chat Session Loop:

   • User enters commands through the CLI
   • Commands are processed through the Thread and Assistant
   • For blockchain operations, specific Tools are called
   • Results are returned through the chain of components

3. Blockchain Integration:

   • Tools interface with the blockchain through Viem clients
   • Operations are executed on the Avalanche Fuji testnet
   • Results are propagated back to the user

4. Session Management:

   • Users can exit the application at any time
   • Each command is processed in a sequential manner
   • Responses are displayed back to the user

Contributing

Contributions are welcome! Please open an issue or submit a pull request for any enhancements or bug fixes.

License

This project is licensed under the MIT License. See the LICENSE file for details.

Acknowledgments

• OpenAI for providing the GPT-4o-mini model.
• Viem for blockchain interaction utilities.

Contact

https://t.me/meta0xflip