# Building an Autonomous Token Deployment Agent on Celo

Creating and deploying tokens on blockchain networks often involves multiple manual steps and technical knowledge. What if we could automate this process with an AI agent that handles everything from token naming to deployment?

In this tutorial, we'll build an autonomous agent that can deploy ERC20 tokens on the Celo blockchain using ContractKit and AI-powered name generation.

## What We're Building

Our agent can:
- Generate creative token names using AI (with a fallback mechanism)
- Automatically configure tokenomics
- Deploy ERC20 tokens to Celo's testnet
- Handle all blockchain interactions autonomously
- Pay gas fees in A-CELO (Celo's native token)

## Key Technologies

- **Celo ContractKit**: For blockchain interactions
- **Gaia's Public Nodes**: For AI-powered name generation
- **OpenZeppelin**: For secure ERC20 implementation
- **Web3.js**: For blockchain communication

## The Architecture

Our agent consists of three main components:

1. **Token Generator**: The AI brain that creates token names
2. **Token Deployer**: The blockchain interaction layer
3. **Smart Contract**: The token implementation

Let's break down each component:

### 1. The AI Token Generator

export async function generateTokenName() {
    try {
        const completion = await openai.chat.completions.create({
            model: "llama",
            messages: [{
                role: "system",
                content: "You are a creative assistant that generates meme token names."
            }, {
                role: "user",
                content: "Generate a creative and funny meme token name and symbol."
            }],
            max_tokens: 50,
            temperature: 0.7,
            stop: ["\n"]
        });

        // Process AI response
        if (completion.choices && completion.choices[0]?.message?.content) {
            const suggestion = completion.choices[0].message.content.trim();
            const [name, symbol] = suggestion.split('|').map(s => s.trim());
            return { name, symbol };
        }
    } catch (error) {
        // Fallback to random generation
        const adjectives = ['Super', 'Mega', 'Ultra', 'Hyper', 'Epic'];
        const nouns = ['Moon', 'Rocket', 'Star', 'Doge', 'Pepe'];
        const name = `${adjectives[Math.floor(Math.random() * adjectives.length)]} ${
            nouns[Math.floor(Math.random() * nouns.length)]}`;
        const symbol = name.split(' ').map(word => word[0]).join('');
        return { name, symbol };
    }
}

The generator uses AI to create token names, with a clever fallback mechanism for reliability.

### 2. The ContractKit Deployer

export class TokenDeployer {
    constructor(privateKey, rpcUrl) {
        const web3 = new Web3(rpcUrl);
        this.kit = newKitFromWeb3(web3);
        this.kit.addAccount(privateKey);
    }

    async deployToken(name, symbol, initialSupply) {
        const accounts = await this.kit.web3.eth.getAccounts();
        const defaultAccount = accounts[0];
        
        // Create and deploy contract
        const contract = new this.kit.web3.eth.Contract(this.contractAbi);
        const deploy = contract.deploy({
            data: this.contractBytecode,
            arguments: [name, symbol, initialSupply]
        });

        const tx = await new Promise((resolve, reject) => {
            deploy.send({
                from: defaultAccount,
                gas: await deploy.estimateGas()
            })
            .on('transactionHash', hash => console.log('Tx Hash:', hash))
            .on('receipt', receipt => resolve(receipt))
            .on('error', error => reject(error));
        });

        return tx;
    }
}

The deployer handles all blockchain interactions using Celo's ContractKit, making it easy to deploy and manage tokens.

### 3. The Smart Contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MemeToken is ERC20 {
    constructor(
        string memory name,
        string memory symbol,
        uint256 initialSupply
    ) ERC20(name, symbol) {
        _mint(msg.sender, initialSupply * (10 ** decimals()));
    }
    
    // Explicitly define the decimals to avoid any potential overrides
    function decimals() public pure override returns (uint8) {
        return 18;
    }
}

We use OpenZeppelin's battle-tested ERC20 implementation for security and reliability.

## Why This Matters

This autonomous agent demonstrates several key innovations:

1. **AI Integration**: Using AI for creative tasks in blockchain deployments
2. **Automation**: Reducing manual steps in token deployment
3. **Error Handling**: Robust fallback mechanisms for reliability
4. **User Experience**: Simplified token deployment process

## Future Improvements

The agent could be enhanced with:
- Multi-chain deployment support
- Advanced tokenomics configuration
- Token verification automation
- Custom token feature selection
- Market analysis for token parameters

## Getting Started

Want to try it yourself? The complete code is available in our [GitHub repository](https://github.com/harishkotra/celo-token-agent).

To test it out:

1. Get some test tokens from [Celo's faucet](https://faucet.celo.org/alfajores)
2. Clone the repository
3. Configure your `.env` file
4. Run `npm install`
5. Execute `node deploy.js`

By combining AI with Celo's powerful ContractKit, we've created an agent that autonomously handles token creation and deployment. This approach not only simplifies the token deployment process but also demonstrates how AI can be integrated into blockchain workflows.

The possibilities for autonomous blockchain agents are vast, and this is just the beginning. What will you build next?

### Example Responses

AI generated token: { name: "Satoshi's Catnip", symbol: 'SCP' }
Reading artifacts from: /Users/shk/experiments/onchainkit-gaia/artifacts/contracts/MemeToken.sol/MemeToken.json
Deploying from account: 0xbDe71618Ef4Da437b0406DA72C16E80b08d6cD45
Account balance:
A-CELO: 10.353296994614 A-CELO
Sending deployment transaction...
Transaction sent! Hash: 0xd5b17d8ce38ddf50ca7366cf658b3d24d6d9a1d0e3bce6e50b870bd50e961792
Deployment confirmed in block: 35794429
Token deployed successfully!
{
  name: "Satoshi's Catnip",
  symbol: 'SCP',
  address: '0x0563109c80733Ea484F86b653262ecA50b8a06d6',
  transactionHash: '0xd5b17d8ce38ddf50ca7366cf658b3d24d6d9a1d0e3bce6e50b870bd50e961792',
  explorer: 'https://alfajores.celoscan.io/address/0x0563109c80733Ea484F86b653262ecA50b8a06d6'
}

AI generated token: { name: 'LolToken', symbol: 'LOL' }
Reading artifacts from: /Users/shk/experiments/onchainkit-gaia/artifacts/contracts/MemeToken.sol/MemeToken.json
Deploying from account: 0xbDe71618Ef4Da437b0406DA72C16E80b08d6cD45
Account balance:
A-CELO: 10.337778442114 A-CELO
Sending deployment transaction...
Transaction sent! Hash: 0xfe83c066173362374b1c6a420c2fdc37f7fd4f923bd3d8a3b94e384988cbde13
Deployment confirmed in block: 35797227
Token deployed successfully!
{
  name: 'LolToken',
  symbol: 'LOL',
  address: '0x47442330f26B58D7C1b7D13ed20fE1244aE58Dbe',
  transactionHash: '0xfe83c066173362374b1c6a420c2fdc37f7fd4f923bd3d8a3b94e384988cbde13',
  explorer: 'https://alfajores.celoscan.io/address/0x47442330f26B58D7C1b7D13ed20fE1244aE58Dbe'
}

---

Find the complete code and documentation at:
[GitHub Repository](https://github.com/harishkotra/celo-token-agent)