---
title: "Lance uma memecoin na Arc Chain"
description: "Escreva e implante um ERC-20 de oferta fixa na mainnet da Arc com Foundry e Alchemy RPC, pagando gas em USDC, ou entregue todo o lançamento a um agente de código com o Alchemy CLI."
---

# Lance uma memecoin na Arc Chain

<ImageBlock
  src="https://media.alchemy.com/overviews/launch-a-memecoin-on-arc-hero-20260916.png"
  alt="Lance uma memecoin na Arc Chain"
  width={1920}
  height={900}
/>

Arc é a blockchain que a Circle desenhou para finanças em stablecoins, e seus [validadores fundadores](https://www.circle.com/pressroom/circle-announces-founding-validator-cohort-and-major-integrations-for-arc-ahead-of-september-16-mainnet-launch) incluem BlackRock, Visa e Mastercard. Nada disso faz dela um clube privado. A chain é aberta e permissionless para builders, a mainnet está no ar, e ela usa stablecoins como gas, começando com USDC. Qualquer pessoa pode fazer deploy de qualquer coisa nela, e toda fee ao longo do caminho é precificada em dólar.

Uma memecoin na Arc é um ERC-20 padrão com gas denominado em USDC. O contrato funciona exatamente como em qualquer chain EVM, então você pode fazer o deploy de um sozinho com Foundry em cerca de vinte minutos, ou entregar todo o fluxo para um coding agent. Os dois caminhos estão abaixo, incluindo um prompt copy-paste que permite que qualquer agent capaz de rodar comandos shell conduza o launch com o Alchemy CLI. A única diferença real em relação a todo launch que você já fez antes é o token de gas, então você abastece a wallet do deployer com USDC em vez de ETH.

## O que é Arc?

Arc é uma blockchain Layer-1 construída pela Circle, a emissora do USDC, e desenhada para pagamentos e finanças em stablecoins. Ela é compatível com EVM, usa USDC como token de gas nativo e alcança [finalidade determinística em menos de um segundo](https://docs.arc.io/arc/concepts/deterministic-finality). Seus validadores são um conjunto permissioned de instituições financeiras. Fazer deploy de contratos nela não exige permissão alguma. Nosso [explainer O que é Arc](https://www.alchemy.com/overviews/what-is-arc) vai mais fundo no design da chain, incluindo o que pode quebrar ao portar um contrato.

[A Arc mainnet está no ar na Alchemy](https://www.alchemy.com/blog/arc-mainnet-is-live-on-alchemy) com [RPC](https://www.alchemy.com/rpc-api) e WebSockets, a Debug API, a Bundler API e [gas sponsorship](https://www.alchemy.com/gasless-transactions) para fluxos de smart accounts. Os endpoints estão na [página da chain Arc](https://www.alchemy.com/arc).

Se você já fez deploy no Ethereum, Base ou Arbitrum antes, o tooling não vai te surpreender. Solidity, Foundry e viem funcionam sem mudança. As diferenças aparecem no que você usa para abastecer a wallet e em como a chain confirma.

## O que muda quando o gas é USDC?

A Arc não tem token de gas volátil, então três partes do checklist usual de launch se comportam de forma diferente:

- **Você abastece o deployer com USDC, não com ETH.** O USDC chega à Arc nativamente pelo [CCTP v2](https://developers.circle.com/cctp/cctp-supported-blockchains), o cross-chain transfer protocol da Circle, a partir de qualquer chain suportada. O [Bridge Kit](https://docs.arc.io/app-kit/bridge) envolve o fluxo burn-attest-mint em uma única chamada, se você preferir fazer por script.
- **As fees são denominadas em dólar e pequenas.** O base fee mira [cerca de um centavo por transação](https://docs.arc.io/arc/references/gas-and-fees), e ele se ajusta contra uma média suavizada da utilização recente em vez de bloco a bloco, então uma rajada de tráfego no dia do launch não o faz disparar como um leilão de gas do Ethereum faria. Você pode orçar o lançamento inteiro em dólares antes de começar.
- **Trades são finais em menos de um segundo.** A Arc roda um motor de consenso BFT sem reorganizações por construção. Uma compra está pendente ou é final, o que significa nenhuma heurística de contagem de confirmações para quem estiver negociando seu token, e nenhuma disputa de reorg no dia do launch.

Um comportamento vale a pena conhecer antes do launch. O blocklist de USDC roda no nível de protocolo, então qualquer transfer que toque um endereço no blocklist reverte. Isso se aplica à perna em USDC de um swap, não ao contrato do seu token, mas é uma diferença em relação a chains onde o blocklist vive apenas dentro do contrato do token.

## Como fazer o deploy do token?

Você precisa de três coisas antes de qualquer coisa tocar a chain:

- **Uma wallet com saldo.** O gas é pago em USDC, trazido por bridge via CCTP ou sacado de uma exchange que suporte a Arc
- **O contrato do token.** Para uma memecoin, um ERC-20 mínimo com supply fixo é o formato padrão. Nosso [guia sobre o padrão ERC-20 em Solidity](https://www.alchemy.com/overviews/erc20-solidity) cobre o que cada função faz.
- **Um endpoint RPC.** Crie um app gratuito no [dashboard](https://dashboard.alchemy.com/) e selecione Arc.

O contrato em si é curto. Supply fixo, sem função de mint, sem owner, então o contrato não dá ao deployer nenhum poder especial para abusar depois. Todo o supply ainda cai na wallet do deployer, e o que acontece com ele depois do launch é coberto mais abaixo:

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

Salve esse contrato como `src/Penny.sol` (`forge init` gera um `Counter.sol` que você pode apagar), depois faça o deploy dele com Foundry:

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

Esse último comando coloca o contrato no ar na mainnet, e a fee sai do seu saldo de USDC. `cast wallet import` armazena a chave em um keystore criptografado e `--account` a destrava com uma senha no momento do deploy, o que mantém a chave bruta fora do histórico do shell e da lista de processos. A Arc também publica seu próprio [passo a passo com Foundry](https://docs.arc.io/arc/tutorials/deploy-on-arc), caso você queira a versão do time da chain.

## O que acontece depois do deploy?

Um contrato com deploy feito é um token que ninguém pode comprar. O launch se torna real quando você alimenta um pool de liquidez e começa a distribuir o supply. Uniswap e Aerodrome já estão [ativas na Arc](https://www.circle.com/pressroom/circle-launches-arc-mainnet-an-economic-operating-system-for-the-internet), e na Arc o par natural é o seu token contra USDC, o mesmo asset que todo mundo na chain já segura para gas.

É aqui também que os compradores vão te julgar. Traders de memecoin experientes verificam se o supply é fixo, se a liquidez está travada, e quanto a wallet do deployer detém antes de tocar em um token. A Arc muda uma parte desse ritual. A finalidade é determinística, então qualquer coisa que você leia de volta um segundo depois de um trade já está liquidada, e não há janela de pendência onde um rug possa se esconder.

## Um agent pode lançar a moeda por você?

Cada passo acima é scriptável, o que torna isso um trabalho natural para um coding agent. O [Alchemy CLI](https://www.alchemy.com/agents) foi feito exatamente para isso. Todo comando aceita `--json --no-interactive` para que um agent possa fazer parse do output, e as [agent wallets](https://www.alchemy.com/blog/agent-wallets-alchemy-cli) dão a ele uma sessão com escopo definido para assinar, em vez de uma chave privada bruta. Isso funciona com qualquer agent capaz de rodar comandos shell, Claude Code, Cursor, um agent baseado em OpenAI, ou seu próprio script. Usuários do Claude Code têm um atalho: o [plugin da Alchemy](https://www.alchemy.com/blog/alchemy-claude-plugin-now-live) instala as skills do CLI e o servidor MCP em um único comando.

Uma observação honesta sobre a divisão de trabalho. O CLI não tem um comando de deploy, então o agent executa o deployment via Foundry contra o seu endpoint da Alchemy e usa o CLI para tudo que lê estado: checar saldos, buscar receipts, e ler o contrato de volta. Assinar é a parte que precisa estar certa. Todo o supply é mintado na conta do keystore do Foundry que faz o deploy do contrato, então essa mesma conta também assina a primeira distribuição, e a sessão da agent wallet cobre qualquer ação do CLI que gaste fundos. Configure o keystore antes de passar o prompt adiante, ou o agent vai chegar na etapa de deploy sem nenhuma chave que possa usar.

Instale o CLI com `npm i -g @alchemy/cli`, depois dê esse prompt ao seu agent. Ele te entrevista sobre os detalhes do token antes de escrever uma linha 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 Arc 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 arc-mainnet is available with \`alchemy evm network list\`.
- Everything that moves funds signs with my Foundry keystore account. Get the deployer address with \`cast wallet address --account deployer\`. If no keystore account exists, stop and tell me to run \`cast wallet import\` first.
- Check the deployer's balance on arc-mainnet with \`alchemy evm data balance <deployer-address>\`. Gas on Arc is paid in USDC, not ETH. If the balance cannot cover gas, stop and tell me how much USDC to bridge in.
- Write a fixed-supply ERC-20 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 arc-mainnet endpoint, signing with \`--account deployer\`. Never pass a raw private key on the command line.
- Verify the launch: pull the receipt with \`alchemy evm receipt\`, then read the name, symbol, and total supply back with \`alchemy evm contract read\`.
- The full supply mints to the deployer, so the first distribution comes from the keystore too. Ask me which wallet gets it and how much. The token has 18 decimals, so convert the amount I give you to base units with \`cast to-wei\` before building the command. Then show me the exact \`cast send <token> "transfer(address,uint256)" <recipient> <amount-in-base-units> --rpc-url <my Alchemy arc-mainnet endpoint> --account deployer\` command, and wait for my approval before running it.

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 no prompt é específico para nenhum produto de agent em particular, já que o CLI e o Foundry fazem todo o trabalho de fato. Para um padrão mais aprofundado sobre como conectar agents a wallets e dados onchain, veja nosso guia sobre [como construir onchain agents](https://www.alchemy.com/blog/how-to-build-onchain-agents).

O prompt mantém toda ação irreversível atrás da sua aprovação. Quando um agent controla uma wallet abastecida com USDC real na mainnet, esse gate de aprovação é a diferença entre um preview e uma transação real.

## Comece a construir na Arc

Os endpoints da Arc estão disponíveis no nosso tier gratuito. Crie um app no [dashboard](https://dashboard.alchemy.com), selecione Arc, e você já tem um endpoint de mainnet no primeiro dia. Sem contratos, sem waitlist, sem compromisso mínimo. Se você for pelo caminho do agent, o [Alchemy CLI](https://www.alchemy.com/agents) te leva da instalação a uma transação assinada na mainnet em poucos minutos.

A Circle desenhou a Arc para finanças em stablecoins e recrutou bancos e redes de cartão para validá-la. O deploy ser permissionless significa que a chain vai rodar o que quer que as pessoas tragam para ela, e a primeira onda sempre inclui memecoins.