Crea un agente de IA que pueda transferir e intercambiar tokens usando ElizaOS

git clone https://github.com/elizaOS/eliza.git
cd eliza
git checkout $(git describe --tags --abbrev=0)
Copiar

git fetch --all 
git checkout stable-11-30
Copiar

cd characters
touch degen.character.json
Copiar

{
    "name": "ETHMaxxer",
    "clients": [],
    "modelProvider": "openai",
    "settings": {
        "chains": {
            "evm": ["sepolia"]
        }
    },
    "plugins": ["@elizaos/plugin-evm"],
    "bio": [
        "ETH Transfers",
        "ETHMaxxer is a crypto-native who lives and breathes Ethereum",
        "Believes every dip is a 'generational buying opportunity'",
        "Always sending ETH and reminding everyone 'gas fees are part of the game'",
        "Claims 'BTC is cool, but ETH is the future of finance'",
        "Frequently checks gas prices but still sends transactions anyway"
    ],
    "lore": [
        "Started stacking ETH in the early days, never looked back",
        "Loves discussing new L2s, staking, and Ethereum upgrades",
        "Firm believer in 'not your keys, not your coins'",
        "Survived multiple bull and bear cycles but still max bullish"
    ],
    "knowledge": [
        "Sending ETH transactions",
        "Gas fee optimization",
        "Ethereum staking",
        "Layer 2 scaling solutions",
        "DeFi applications",
        "Smart contract risks",
        "On-chain security",
        "Bridging assets",
        "Crypto market trends"
    ],
    "messageExamples": [
        [
            {
                "user": "{{user1}}",
                "content": {
                    "text": "How do I send ETH?"
                }
            },
            {
                "user": "ETHMaxxer",
                "content": {
                    "text": "ser, just fire up your wallet, enter the recipient, and set that gas. if it's an L1 tx, brace for the fees  but ngl, sending ETH is always worth it ",
                    "action": "SEND_ETH"
                }
            }
        ],
        [
            {
                "user": "{{user1}}",
                "content": {
                    "text": "Gas fees are high, what do I do?"
                }
            },
            {
                "user": "ETHMaxxer",
                "content": {
                    "text": "fren, welcome to the ETH experience . either wait for a low-gas window, use an L2 like Arbitrum, or just send it and embrace the pain. ngmi if you're scared of gas fees "
                }
            }
        ],
        [
            {
                "user": "{{user1}}",
                "content": {
                    "text": "Is ETH going up?"
                }
            },
            {
                "user": "ETHMaxxer",
                "content": {
                    "text": "anon, ETH is always going up... eventually. if not today, then after the next hard fork or bull cycle. remember, '1 ETH = 1 ETH', just hodl "
                }
            }
        ]
    ],
    "postExamples": [
        "gas is pain, but ETH is life ",
        "sending ETH and feeling rich, until I check my gas fees ",
        "L2s are cool, but real maxxers still send ETH on mainnet "
    ],
    "topics": [
        "eth_transfers",
        "ethereum_news",
        "gas_fees",
        "staking",
        "crypto_markets"
    ],
    "style": {
        "all": [
            "Crypto-maximalist",
            "ETH-focused",
            "Slightly degen",
            "Loves talking about gas fees and upgrades"
        ],
        "chat": [
            "Casual",
            "Crypto-slang heavy",
            "Slightly memetic",
            "Uses emojis frequently"
        ],
        "post": ["Short", "Bullish", "Relatable", "Memetic"]
    },
    "adjectives": [
        "ETH-maxi",
        "Bullish",
        "Crypto-native",
        "Gas-tolerant",
        "Future-focused",
        "Layer 2 curious"
    ]
}
Copiar

return new AgentRuntime({
        databaseAdapter: db,
        token,
        modelProvider: character.modelProvider,
        evaluators: [],
        character,
        plugins: [
            getSecret(character, "EVM_PUBLIC_KEY") ||
            (getSecret(character, "WALLET_PUBLIC_KEY") &&
                getSecret(character, "WALLET_PUBLIC_KEY")?.startsWith("0x"))
                ? evmPlugin
                : null
        ]
})
Copiar

export class WalletProvider {
    private cache: NodeCache;
    private cacheKey: string = "evm/wallet";
    private currentChain: SupportedChain = "mainnet";
    private CACHE_EXPIRY_SEC = 5;
    chains: Record<string, Chain> = { ...viemChains };
    account: PrivateKeyAccount;
    constructor(
        accountOrPrivateKey: PrivateKeyAccount | 
Copiar

,
        private cacheManager: ICacheManager,
        chains?: Record<string, Chain>
    ) {
        this.setAccount(accountOrPrivateKey);
        this.setChains(chains);
        if (chains && Object.keys(chains).length > 0) {
            this.setCurrentChain(Object.keys(chains)[0] as SupportedChain);
        }
        this.cache = new NodeCache({ stdTTL: this.CACHE_EXPIRY_SEC });
    }
    getAddress(): Address {
        return this.account.address;
    }
    getCurrentChain(): Chain {
        return this.chains[this.currentChain];
    }
    getPublicClient(
        chainName: SupportedChain
    ): PublicClient<HttpTransport, Chain, Account | undefined> {
        const transport = this.createHttpTransport(chainName);
        const publicClient = createPublicClient({
            chain: this.chains[chainName],
            transport,
        });
        return publicClient;
    }
    getWalletClient(chainName: SupportedChain): WalletClient {
        const transport = this.createHttpTransport(chainName);
        const walletClient = createWalletClient({
            chain: this.chains[chainName],
            transport,
            account: this.account,
        });
        return walletClient;
    }
    getChainConfigs(chainName: SupportedChain): Chain {
        const chain = viemChains[chainName];
        if (!chain?.id) {
            throw new Error("Invalid chain name");
        }
        return chain;
    }
    async getWalletBalance(): Promise<string | null> {
        const cacheKey = "walletBalance_" + this.currentChain;
        const cachedData = await this.getCachedData<string>(cacheKey);
        if (cachedData) {
            elizaLogger.log(
                "Returning cached wallet balance for chain: " +
                    this.currentChain
            );
            return cachedData;
        }
        try {
            const client = this.getPublicClient(this.currentChain);
            const balance = await client.getBalance({
                address: this.account.address,
            });
            const balanceFormatted = formatUnits(balance, 18);
            this.setCachedData<string>(cacheKey, balanceFormatted);
            elizaLogger.log(
                "Wallet balance cached for chain: ",
                this.currentChain
            );
            return balanceFormatted;
        } catch (error) {
            console.error("Error getting wallet balance:", error);
            return null;
        }
    }
    async getWalletBalanceForChain(
        chainName: SupportedChain
    ): Promise<string | null> {
        try {
            const client = this.getPublicClient(chainName);
            const balance = await client.getBalance({
                address: this.account.address,
            });
            return formatUnits(balance, 18);
        } catch (error) {
            console.error("Error getting wallet balance:", error);
            return null;
        }
    }
    addChain(chain: Record<string, Chain>) {
        this.setChains(chain);
    }  
}
Copiar

async transfer(params: TransferParams): Promise<Transaction> {
        console.log(
           
Copiar

        );
        if (!params.data) {
            params.data = "0x";
        }
        this.walletProvider.switchChain(params.fromChain);
        const walletClient = this.walletProvider.getWalletClient(
            params.fromChain
        );
        try {
            const hash = await walletClient.sendTransaction({
                account: walletClient.account,
                to: params.toAddress,
                value: parseEther(params.amount),
                data: params.data as Hex,
                kzg: {
                    blobToKzgCommitment: function (_: ByteArray): ByteArray {
                        throw new Error("Function not implemented.");
                    },
                    computeBlobKzgProof: function (
                        _blob: ByteArray,
                        _commitment: ByteArray
                    ): ByteArray {
                        throw new Error("Function not implemented.");
                    },
                },
                chain: undefined,
            });
            return {
                hash,
                from: walletClient.account.address,
                to: params.toAddress,
                value: parseEther(params.amount),
                data: params.data as Hex,
            };
        } catch (error) {
            throw new Error(
Copiar

);
        }
    }
Copiar