Menu
Coddy logo textTech
COMEÇAR A APRENDER
flag Pt iconPortuguêsdown icon

Solidity Playground

Escreva, execute e compartilhe trechos de código — sem instalação.

Contract.sol
Clique em Executar para ver a saída aqui.
ArgsValues passed to your contract’s main(...) function. The runner ABI-encodes them based on the parameter types.
No arguments. Click "Add arg" to pass one.

Experimente Solidity no navegador

Solidity é a linguagem dos smart contracts do Ethereum. Roda na EVM — a mesma máquina virtual que protege centenas de bilhões de dólares na mainnet e que move a maioria das L2. Este playground te entrega um editor Monaco conectado a um sandbox com solc + geth EVM, então você escreve um contrato, pressiona Run e vê exatamente o que aconteceria on-chain: a saída de console.log, os eventos emitidos e o estado final das suas variáveis de storage — sem fazer deploy, sem pagar gas e sem mexer em uma wallet.

Solidity tem algumas particularidades que vale notar quando se começa. O storage é permanente por padrão — tudo que você atribui a uma variável de estado persiste; tudo que está dentro de uma função some quando a chamada retorna. Eventos são como os contratos conversam com o mundo de fora (seu frontend, seu indexador, The Graph) — custam gas, são gravados nos logs da transação e podem ser filtrados pelos parâmetros indexed. E toda função externa recebe seus argumentos via ABI encoding, não por stdin — por isso o playground expõe um painel de Args tipados que se liga direto aos parâmetros do seu main(...).

O que este playground de Solidity faz bem

  • Execução real com solc + EVM, não uma simulação por transpilador. console.log usa forge-std e os caminhos de emit / storage passam por semântica real de EVM — opcodes, gas, tudo.
  • A aba Events mostra cada emit da sua execução com os parâmetros indexed sinalizados de forma distinta, então você vê exatamente o que um frontend ou um subgraph receberia.
  • A aba Storage mostra o valor final de cada variável de estado que o contrato tocou — incluindo entradas de mapping (ex.: balances[0xabc...]). Variáveis que você não escreveu não aparecem.
  • Painel de Args tipados que alimenta valores em um main(uint256 n, string memory name, ...) parametrizado. O runner codifica via ABI a partir da assinatura da sua função, então 42 vira uint256 e "hello" vira string.

O que você pode construir no playground de Solidity

  • Contadores / contratos increment-decrement para entender como variáveis de estado persistem entre chamadas — escreva em count, execute e veja aparecendo na aba Storage.
  • Padrões de fluxo de tokens — emita Transfer(from indexed, to indexed, value) e veja os campos indexed e não-indexed renderizados de forma diferente na aba Events, do mesmo jeito que aparecem nos topics dos logs reais da EVM.
  • Casos de falha com require / revert — escreva uma guard que falhe em entrada inválida e veja a mensagem de revert surgindo no stdout, em vez de queimar gas em uma transação que falhou na mainnet.

Perguntas frequentes sobre Solidity

O que é Solidity?
Solidity é a linguagem de smart contracts mais usada no Ethereum e nas cadeias compatíveis com EVM (Polygon, Arbitrum, Optimism, Base, etc.). Compila para bytecode da EVM — um conjunto de instruções de máquina de pilha executado por cada nó da rede. Sintaticamente bebe de JavaScript e C++, mas a semântica é bem diferente: storage é caro e permanente, toda chamada é medida em gas e não existe async. O playground te dá uma EVM em sandbox para praticar a linguagem sem encostar em uma cadeia real.
Eu preciso de uma wallet ou ETH de testnet para usar isso?
Não. O playground roda seu contrato dentro de uma EVM no servidor (o mesmo motor que vem com o geth), em um contêiner isolado por requisição. Não há transação on-chain, não há gas pago em ETH real, não há assinatura de wallet. Quando você pressiona Run, o runner faz o deploy do seu contrato em uma cadeia em memória nova em folha, chama a função main(...) com os args que você forneceu e mostra o stdout, os eventos e o storage daquela chamada. Tudo é descartado depois do Run.
Como passo valores de entrada para o meu contrato?
Dê ao seu contrato uma função chamada main(...) com os parâmetros tipados que você quiser — function main(uint256 n) external ou function main(string memory name, uint256 age, bool active) external view. Depois adicione os valores no painel Args abaixo do editor. O runner inspeciona a assinatura da função e codifica via ABI suas strings nos tipos certos, do mesmo jeito que o cast call faz na linha de comando. Para um argumento address, digite 0x...; para bool, true ou false; para uint, o valor decimal.
Qual a diferença entre as abas Output, Events e Storage?
Output mostra o que você escreveu no stdout via console.log(...) do forge-std/console.sol, mais qualquer mensagem de erro de revert / require. Events mostra cada evento que o seu contrato emitiu durante a execução, na ordem, com o valor de cada parâmetro (e uma pequena etiqueta "indexed" para parâmetros indexed — esses são os que vão para os topics dos logs da EVM e podem ser filtrados por ferramentas como The Graph). Storage mostra o valor pós-execução de cada variável de estado que foi escrita, incluindo entradas individuais de mapping — variáveis que você não tocou ficam fora da lista.
Por que alguns tutoriais de Solidity não têm main()?
Em uma cadeia real, contratos Solidity não têm um único ponto de entrada — os clientes chamam qualquer função pública que quiserem, identificada pelo selector de 4 bytes. O playground usa main() como convenção para haver uma coisa óbvia para executar e um lugar para colocar os argumentos. Fora do playground, seu contrato normalmente expõe várias funções (mint, transfer, withdraw, ...) e o seu frontend ou uma ferramenta como cast / ethers / viem escolhe qual chamar.