---
title: "Lanza una memecoin en Robinhood Chain"
description: "Escribe y despliega un ERC20 de suministro fijo en Robinhood Chain mainnet con Foundry y Alchemy RPC, o delega todo el lanzamiento a un coding agent con el Alchemy CLI."
---

# Lanza una memecoin en Robinhood Chain

<ImageBlock
  src="https://media.alchemy.com/blog/launch-a-memecoin-on-robinhood-chain-hero.png"
  alt="Lanza una memecoin en Robinhood Chain"
  width={1920}
  height={900}
/>

Robinhood construyó su chain para acciones tokenizadas, pero el despliegue es permissionless, así que cualquiera puede lanzar lo que quiera en ella. La mainnet salió en vivo el 1 de julio de 2026, y en dos semanas [el volumen de DEX en la chain saltó de alrededor de $200K a más de $500M](https://defillama.com/chain/robinhood-chain), liderado por meme tokens como CASHCAT.

Una memecoin es un contrato ERC20 con una historia. El contrato es la mitad fácil, y en Robinhood Chain funciona exactamente igual que en cualquier chain EVM. Puedes desplegar uno tú mismo con Foundry en unos veinte minutos, o dejarle todo el flujo a un agente de código. Ambos caminos están abajo, incluyendo un prompt copiar-y-pegar que le permite a cualquier agente capaz de ejecutar comandos de shell manejar el lanzamiento con el CLI de Alchemy.

## ¿Qué es Robinhood Chain?

[Robinhood](https://www.alchemy.com/rpc/robinhood) Chain es una layer 2 de Ethereum construida sobre el stack de Arbitrum Orbit, operada por Robinhood y diseñada para activos reales tokenizados. Liquida en Ethereum, usa ETH para gas, y corre bajo el [chain ID 4663](https://robinhood.com/us/en/support/articles/robinhood-chain-mainnet/). Es totalmente compatible con EVM, y el despliegue es permissionless.

[Robinhood Chain mainnet está disponible en Alchemy](https://www.alchemy.com/blog/robinhood-chain-mainnet-is-live-on-alchemy) con [RPC](https://www.alchemy.com/rpc-api) y WebSockets, [webhooks](https://www.alchemy.com/webhooks), [gas sponsorship](https://www.alchemy.com/gasless-transactions), y la [Data API](https://www.alchemy.com/docs/data). Los endpoints están en la página de Robinhood Chain.

Si ya desplegaste en Ethereum, Arbitrum o Base antes, nada de esto te sorprenderá. Mismas herramientas, mismo bytecode, distinto chain ID.

## ¿Cómo se despliega el token?

Necesitas tres cosas antes de tocar la chain:

- **Una wallet con fondos.** El gas se paga en ETH
- **El contrato del token.** Para una memecoin, un ERC20 mínimo de suministro fijo es la forma estándar. Nuestra [guía del estándar ERC-20 en Solidity](https://www.alchemy.com/overviews/erc20-solidity) explica qué hace cada función.
- **Un endpoint RPC.** Crea una app gratuita en el [dashboard](https://dashboard.alchemy.com/) y selecciona Robinhood Chain. El [quickstart de la API de Robinhood Chain](https://www.alchemy.com/docs/reference/robinhood-chain-api-quickstart) recorre la primera llamada.

El contrato en sí es corto. Suministro fijo, sin función de mint, sin owner, así que no hay nada que puedan rugear después:

<CodeSnippet
  language="solidity"
  code={`// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract Bagel is ERC20 {
    constructor() ERC20("Bagel", "BAGEL") {
        _mint(msg.sender, 1_000_000_000 * 10 ** decimals());
    }
}`}
/>

Guarda ese contrato como `src/Bagel.sol` (`forge init` arma un `Counter.sol` que puedes borrar), luego despliégalo con Foundry:

<CodeSnippet
  language="bash"
  code={`forge init bagel && cd bagel
forge install OpenZeppelin/openzeppelin-contracts
# paste the contract above into src/Bagel.sol, then import your deployer key once
cast wallet import deployer --interactive
forge create src/Bagel.sol:Bagel \\
  --rpc-url https://robinhood-mainnet.g.alchemy.com/v2/$ALCHEMY_API_KEY \\
  --account deployer \\
  --broadcast`}
/>

Ese último comando pone el contrato en vivo en mainnet. `cast wallet import` guarda la key en un keystore encriptado y `--account` la desbloquea con una contraseña al momento del deploy, lo que mantiene la key en crudo fuera de tu historial de shell y de la lista de procesos. Robinhood también publica su propio [tutorial de despliegue con Foundry](https://docs.robinhood.com/chain/deploy-smart-contracts) si quieres la versión del equipo de la chain.

## ¿Qué pasa después del deploy?

Un contrato desplegado es un token que nadie puede comprar. El lanzamiento se vuelve real cuando sembras un pool de liquidez en uno de los DEXs ya activos en la chain y empiezas a distribuir el suministro. Aquí también es donde los compradores te van a evaluar. Los traders de memecoins experimentados revisan si el suministro es fijo, si la liquidez está bloqueada, y cuánto tiene la wallet del deployer antes de tocar un token.

## ¿Puede un agente lanzar la moneda por ti?

Cada paso de arriba es scripteable, lo que lo hace un trabajo natural para un agente de código. El [CLI de Alchemy](https://www.alchemy.com/agents) fue construido exactamente para esto. Cada comando acepta `--json --no-interactive` para que un agente pueda parsear la salida, y las [agent wallets](https://www.alchemy.com/blog/agent-wallets-alchemy-cli) le dan una sesión con alcance limitado para firmar en vez de una private key en crudo. Esto funciona con cualquier agente capaz de ejecutar comandos de shell, Claude Code, Cursor, un agente basado en OpenAI, o tu propio script. Los usuarios de Claude Code tienen un atajo: el [plugin de Alchemy](https://www.alchemy.com/blog/alchemy-claude-plugin-now-live) instala las skills del CLI y el servidor MCP en un solo comando.

Una nota honesta sobre la división del trabajo. El CLI no tiene comando de deploy, así que el agente ejecuta el despliegue a través de Foundry contra tu endpoint de Alchemy y usa el CLI para todo lo demás: revisar balances, obtener receipts, leer el contrato de vuelta, y mover tokens. Esas dos mitades firman de manera distinta, y esto importa: la creación del contrato pasa por tu cuenta de keystore de Foundry, mientras que los pasos del CLI firman con la sesión de la agent wallet. Configura el keystore antes de darle el prompt al agente, o llegará al paso de deploy sin ninguna key que pueda usar.

Instala el CLI con `npm i -g @alchemy/cli`, luego dale a tu agente este prompt. Te entrevista sobre los detalles del token antes de escribir una línea de Solidity:

<CodeSnippet
  language="text"
  code={`You have the Alchemy CLI and Foundry installed. Run \`alchemy --json --no-interactive agent-prompt\` first to load the CLI's command contract, then launch a memecoin for me on Robinhood Chain mainnet.

Start by asking me for:

- The token name and ticker symbol
- The total supply
- A logo image, and wait for me to upload the file before continuing

Do not invent any of these. Wait for my answers, then confirm them back to me before you write any code.

Once I have confirmed:

- Check that robinhood-mainnet is available with \`alchemy evm network list\`.
- Check my wallet with \`alchemy wallet status\`, then check its ETH balance on robinhood-mainnet with \`alchemy evm data balance\`. If it cannot cover gas, stop and tell me how much to fund.
- Write a fixed-supply ERC20 using the name, symbol, and supply I gave you, with no mint function and no owner, and deploy it with \`forge create\` against my Alchemy robinhood-mainnet endpoint, signing with my Foundry keystore account via \`--account\`. Never pass a raw private key on the command line. If no keystore account exists, stop and tell me to run \`cast wallet import\` first.
- Verify the launch: pull the receipt with \`alchemy evm receipt\`, then read the name, symbol, and total supply back with \`alchemy evm contract read\`.
- Ask me which wallet gets the first distribution, then send 1% of supply with \`alchemy evm send --token <address>\` using \`--dry-run\` first. Show me the preview and wait for my approval before the real send.

The logo never goes onchain. Keep the file path and hand it back to me for the block explorer and token list submissions once the contract is live.

Ask before every transaction that spends funds.`}
/>

Nada en el prompt es específico de algún producto de agente en particular, ya que el CLI y Foundry hacen todo el trabajo real. Para un patrón más profundo sobre conectar agentes con wallets y datos onchain, mira nuestra guía sobre [construir agentes onchain](https://www.alchemy.com/blog/how-to-build-onchain-agents).

El prompt mantiene cada acción irreversible detrás de tu aprobación. Cuando un agente tiene una wallet con fondos en mainnet, ese filtro de dry-run-y-luego-aprobar es la diferencia entre una vista previa y una transacción en vivo.

## Empieza a construir en Robinhood Chain

Los endpoints de Robinhood Chain están disponibles en nuestro tier gratuito. Crea una app en el [dashboard](https://dashboard.alchemy.com), selecciona Robinhood Chain, y tienes un endpoint de mainnet desde el primer día. Sin contratos, sin lista de espera, sin compromiso mínimo. Si vas por el camino del agente, el [CLI de Alchemy](https://www.alchemy.com/agents) te lleva de la instalación a una transacción firmada en mainnet en unos minutos.

Robinhood construyó la chain para acciones. Sus primeras dos semanas mostraron que va a correr lo que sea que la gente despliegue en ella.