Launch a memecoin on Arc Chain

Arc is the blockchain Circle designed for stablecoin finance, and its founding validators include BlackRock, Visa, and Mastercard. None of that makes it a private club. The chain is open and permissionless for builders, mainnet is live, and it uses stablecoins as gas, starting with USDC. Anyone can deploy anything on it, and every fee along the way is priced in dollars.

A memecoin on Arc is a standard ERC-20 with USDC-denominated gas. The contract works exactly like it does on any EVM chain, so you can deploy one yourself with Foundry in about twenty minutes, or hand the whole flow to a coding agent. Both paths are below, including a copy-paste prompt that lets any agent that can run shell commands drive the launch with the Alchemy CLI. The one real difference from every launch you have done before is the gas token, so you fund the deployer wallet with USDC instead of ETH.

What is Arc?

Arc is a Layer-1 blockchain built by Circle, the issuer of USDC, and designed for stablecoin payments and finance. It is EVM-compatible, uses USDC as its native gas token, and reaches deterministic finality in under a second. Its validators are a permissioned set of financial institutions. Deploying contracts on it requires no permission at all. Our What is Arc explainer goes deeper on the chain's design, including what can break when you port a contract.

Arc mainnet is live on Alchemy with RPC and WebSockets, the Debug API, the Bundler API, and gas sponsorship for smart-account flows. Endpoints live on the Arc chain page.

If you have deployed to Ethereum, Base, or Arbitrum before, the tooling will not surprise you. Solidity, Foundry, and viem work unchanged. The differences show up in what you fund the wallet with and how the chain confirms.

What changes when gas is USDC?

Arc has no volatile gas token, so three parts of the usual launch checklist behave differently:

• You fund the deployer with USDC, not ETH. USDC reaches Arc natively through CCTP v2, Circle's cross-chain transfer protocol, from any supported chain. Bridge Kit wraps the burn-attest-mint flow in a single call if you would rather script it.
• Fees are dollar-denominated and small. The base fee targets around a cent per transaction, and it adjusts against smoothed recent utilization rather than block by block, so a burst of launch-day traffic does not spike it the way an Ethereum gas auction would. You can budget the entire launch in dollars before you start.
• Trades are final in under a second. Arc runs a BFT consensus engine with no reorganizations by construction. A buy is either pending or final, which means no confirmation-count heuristics for anyone trading your token, and no reorg disputes on launch day.

One behavior is worth knowing before launch. The USDC blocklist runs at the protocol level, so any transfer that touches a blocklisted address reverts. That applies to the USDC leg of a swap, not to your token contract, but it is a difference from chains where the blocklist only lives inside the token contract.

How do you deploy the token?

You need three things before anything touches the chain:

• A funded wallet. Gas is paid in USDC, bridged in over CCTP or withdrawn from an exchange that supports Arc
• The token contract. For a memecoin, a minimal fixed-supply ERC-20 is the standard shape. Our guide to the ERC-20 standard in Solidity covers what every function does.
• An RPC endpoint. Create a free app in the dashboard and select Arc.

The contract itself is short. Fixed supply, no mint function, no owner, so the contract gives its deployer no special powers to abuse later. The whole supply still lands in the deployer wallet, and what happens to it after launch is covered below:

Save that contract as src/Penny.sol (forge init scaffolds a Counter.sol you can delete), then deploy it with Foundry:

That last command puts the contract live on mainnet, and the fee comes out of your USDC balance. cast wallet import stores the key in an encrypted keystore and --account unlocks it with a password at deploy time, which keeps the raw key out of your shell history and the process list. Arc also publishes its own Foundry walkthrough if you want the chain team's version.

What happens after the deploy?

A deployed contract is a token nobody can buy. The launch becomes real when you seed a liquidity pool and start distributing supply. Uniswap and Aerodrome are both live on Arc, and on Arc the natural pair is your token against USDC, the same asset everyone on the chain already holds for gas.

This is also where buyers will judge you. Experienced memecoin traders check whether the supply is fixed, whether liquidity is locked, and how much the deployer wallet holds before they touch a token. Arc changes one part of that ritual. Finality is deterministic, so anything you read back a second after a trade is settled, and there is no pending window for a rug to hide in.

Can an agent launch the coin for you?

Every step above is scriptable, which makes it a natural job for a coding agent. The Alchemy CLI was built for exactly this. Every command takes --json --no-interactive so an agent can parse the output, and agent wallets give it a scoped session to sign with instead of a raw private key. This works with any agent that can run shell commands, Claude Code, Cursor, an OpenAI-based agent, or your own script. Claude Code users get a shortcut: the Alchemy plugin installs the CLI's skills and MCP server in one command.

One honest note on the division of labor. The CLI has no deploy command, so the agent runs the deployment through Foundry against your Alchemy endpoint and uses the CLI for everything that reads state, checking balances, pulling receipts, and reading the contract back. Signing is the part to get right. The full supply mints to the Foundry keystore account that deploys the contract, so that same account signs the first distribution too, and the agent wallet session covers any CLI action that spends. Set up the keystore before you hand the prompt over, or the agent will reach the deploy step with no key it can use.

Install the CLI with npm i -g @alchemy/cli, then give your agent this prompt. It interviews you for the token details before it writes a line of Solidity:

Nothing in the prompt is specific to any one agent product, since the CLI and Foundry do all the actual work. For a deeper pattern on wiring agents to wallets and onchain data, see our guide to building onchain agents.

The prompt keeps every irreversible action behind your approval. When an agent holds a wallet funded with real USDC on mainnet, that approval gate is the difference between a preview and a live transaction.

Start building on Arc

Arc endpoints are live on our free tier. Create an app in the dashboard, select Arc, and you have a mainnet endpoint on day one. No contracts, no waitlist, no minimum commitment. If you are taking the agent path, the Alchemy CLI gets you from install to a signed mainnet transaction in a few minutes.

Circle designed Arc for stablecoin finance and recruited banks and card networks to validate it. Deployment being permissionless means the chain will run whatever people bring to it, and the first wave always includes memecoins.