Introdução ao Solidity e smart contracts web3

Smart contracts são programas que residem e são executados em uma blockchain. Você pode pensá-los como contratos digitais autoexecutáveis com regras escritas diretamente em seu código

Stablecoins (como o USDC da CircleUSDC) são uma evolução do dinheiro — elas permitem que você movimente dinheiro quase instantaneamente, a um custo próximo de zero, em todo o mundo. Se você deseja preparar sua infraestrutura de pagamentos para o futuro, precisa entender e oferecer suporte a esses pagamentos digitais.

Então, como integrar moedas digitais como o USDC à sua pilha de tecnologia? Felizmente, com um pouco de conhecimento básico e as ferramentas fornecidas pela Circle, isso não é apenas possível, mas também simples.

Neste artigo, forneceremos as informações necessárias para integrar moedas digitais. Analisaremos o que é blockchain, como a blockchain Ethereum iniciou a era dos smart contracts, como os smart contracts e o Solidity funcionam e como você pode usar stablecoins como o USDC para impulsionar sua tecnologia de pagamentos.

Vamos começar com um pouco de contexto.

Blockchain, moeda digital e Web3

• A Web1 (1991-2004) era focada em páginas da web estáticas (Yahoo!, Netscape e AOL).
• A Web2 (desde 2004) viu a evolução da web como plataforma (Facebook, Google, Uber).
• A Web3 é focada em descentralização e blockchain.

Tudo começou com o Bitcoin em 2008 — o primeiro sistema que permitiu a transferência peer-to-peer de dinheiro pela internet sem a necessidade de uma terceira parte confiável, como um banco, uma corporação ou um governo.

Isso foi possível graças ao avanço que hoje conhecemos como blockchain. Blockchains podem ser pensadas como armazenamentos de dados sem permissão, onde nenhuma pessoa ou corporação possui ou controla os dados. Mesmo com essa descentralização, a veracidade dos dados é garantida. (Para mais informações, aqui está um bom tutorial.)

O Bitcoin continua na vanguarda das blockchains públicas, mas é útil apenas para transferir bitcoin. Devido a essa limitação, alguns desenvolvedores decidiram criar uma nova blockchain com mais recursos: a Ethereum. Pense na Ethereum como um computador descentralizado que pode transferir valor entre usuários (como o Bitcoin) e também executar programas e armazenar dados.

Esses programas executados na Ethereum são chamados de smart contracts. Eles podem parecer semelhantes a códigos que você já viu em outros lugares, mas possuem algumas diferenças importantes que os tornam ideais para alimentar aplicativos descentralizados (dapps) e viabilizar o ecossistema DeFi.

O que são smart contracts?

Smart contracts são programas que residem e são executados em uma blockchain. Você pode pensá-los como contratos digitais autoexecutáveis com regras escritas diretamente em seu código. Esses contratos são programados para executar e aplicar automaticamente as ações acordadas quando condições predefinidas são atendidas. Ao fazer isso, os smart contracts eliminam a necessidade de intermediários, como advogados ou instituições terceiras, para supervisionar ou aplicar os acordos e regras.

A maneira mais fácil de entender os smart contracts é através da analogia clássica de uma máquina de venda automática. Uma máquina de venda automática é programada para fornecer certos produtos a certos preços se um usuário interagir com ela de uma determinada maneira (ou seja, inserindo dinheiro e selecionando o item desejado). Você não precisa de uma terceira parte, como um varejista, para atuar como intermediário entre os produtos na máquina e você. Em outras palavras, ao usar a máquina de venda automática, você eliminou a necessidade de um terceiro.

A plataforma blockchain na qual o smart contract reside fornece a infraestrutura necessária para a execução do contrato. No caso da Ethereum (e blockchains como Polygon e Avalanche), essa infraestrutura é conhecida como Ethereum Virtual Machine (ou EVM).

Quando um smart contract é implantado em uma blockchain, ele se torna parte do histórico da blockchain. O código e os dados armazenados no contrato também se tornam parte do estado global da blockchain.

Para garantir transparência, segurança e resistência a adulterações, os smart contracts na maioria das blockchains são imutáveis. Em outras palavras, é impossível alterar o código de um contrato depois que ele é implantado. (Observe que ainda é possível alterar os dados armazenados no contrato por meio de funções que permitem a modificação desses dados.)

Embora os smart contracts tenham sido introduzidos pela primeira vez pelo cientista da computação e criptógrafo Nick Szabo na década de 1990, eles só se tornaram populares com o lançamento da Ethereum.

Como funcionam os smart contracts?

Veja como os smart contracts funcionam:

• 1. Criação: Um desenvolvedor escreve o código de um smart contract, especificando as regras, condições e ações que o contrato deve realizar. 2. Implantação: O código do smart contract é implantado em uma rede blockchain, tornando-se uma parte permanente do histórico da blockchain. O contrato recebe um endereço exclusivo que serve como seu identificador na rede. No caso de contratos na Ethereum, um trecho de código conhecido como construtor é executado. Isso acontece apenas uma vez e nunca mais pode ser invocado. 3. Execução: Uma vez que o contrato tenha sido implantado, qualquer pessoa pode invocar funções públicas dentro dele. Se as condições especificadas forem atendidas, o código é executado e as alterações de estado, se houver, são realizadas.

É importante enfatizar que qualquer pessoa pode invocar funções públicas em um smart contract e que os smart contracts são imutáveis. Uma vez que um smart contract é implantado, ele permanece lá para sempre (pelo menos enquanto a blockchain existir) e está disponível para todos.

Aplicações de Smart Contracts

A grande maioria da Web3 é impulsionada por smart contracts, incluindo:

• 1. Stablecoins: Moedas digitais criadas para ter um valor estável (como o USDC da Circle). 2. DeFi: Corretoras descentralizadas, protocolos de empréstimo, mecanismos de staking e até loterias. 3. NFTs: Armazenam e verificam ativos não fungíveis ou NFTs. 4. Cadeia de suprimentos: Rastreiam e verificam a movimentação de mercadorias, reduzindo fraudes e aumentando a transparência. 5. Imobiliário: Automatizam transferências de propriedades, contratos de aluguel e gestão de títulos. 6. Jogos: Implementam jogos onde é possível possuir e negociar ativos de jogos. 7. DAOs: Criam organizações autônomas descentralizadas, ou DAOs, e, por sua vez, realizam votações, executam decisões e permitem a governança comunitária.

Introdução ao Solidity

A maioria das blockchains possui uma linguagem de programação personalizada usada para criar smart contracts. Na Ethereum e em blockchains baseadas em EVM, como Polygon, Avalanche e Arbitrum, essa linguagem é o Solidity.

O Solidity é uma linguagem fortemente tipada e se inspira em JavaScript, Python, C++ e Java. Se você estiver familiarizado com qualquer uma dessas linguagens, achará fácil aprender Solidity.

Aqui estão algumas características marcantes do Solidity:

• 1. Orientado a contratos: O design do Solidity gira em torno do conceito de contratos, que encapsulam o código e os dados da aplicação. Os contratos podem conter funções, variáveis de estado e eventos. O que mais se aproxima dos contratos Solidity são as classes Java. 2. Tipos de dados: O Solidity suporta uma variedade de tipos de dados, incluindo inteiros (uint256), booleanos (bool), strings (string), arrays e estruturas definidas pelo usuário (struct). Como outras linguagens fortemente tipadas, como C++, cada dado deve ser explicitamente marcado com um tipo de dado. 3. Eventos: Os contratos Solidity podem emitir eventos, que servem como um mecanismo de comunicação entre o contrato e aplicações externas. Os eventos fornecem uma maneira de notificar sistemas externos sobre ocorrências importantes dentro do contrato (como a transferência de um NFT). 4. Herança e modularidade: O Solidity suporta herança, permitindo que os desenvolvedores criem contratos modulares que herdam propriedades e métodos de contratos pai. Isso promove a reutilização e a organização do código. 5. Composabilidade: O Solidity também permite que você interaja com qualquer contrato já implantado na blockchain. Esse é, sem dúvida, seu recurso mais poderoso, permitindo que você construa sobre o que já está disponível. 6. Medidas de segurança: O Solidity fornece recursos como controle de acesso, especificadores de visibilidade e modificadores para garantir que os contratos sejam executados com segurança. 7. Ecossistema de desenvolvimento: O Solidity é apoiado por um ecossistema robusto de ferramentas de desenvolvimento. O compilador Solidity converte o código Solidity em bytecode que pode ser executado na blockchain. Ambientes de desenvolvimento integrados (IDEs) e frameworks de teste como Hardhat e Truffle facilitam a escrita, implantação e teste de smart contracts. 8. Atualizações: Os contratos na blockchain são imutáveis após a implantação. Para lidar com mudanças e melhorias, os desenvolvedores usam versionamento e padrões de contrato proxy para facilitar as atualizações de contrato, mantendo a compatibilidade com os sistemas existentes.

Vamos analisar alguns exemplos de contratos para que você possa ter uma noção de como o Solidity funciona.

Exemplo 1: Um contrato de votação simples

Exemplo 1: Um contrato de votação simples

Neste exemplo, implementaremos um sistema de votação. Este é um caso de uso comum para blockchain (embora este seja um exemplo extremamente simplificado). Aqui, permitiremos que o público vote em um candidato e, em seguida, permitiremos que verifiquem o número de votos por candidato.

// SPDX-License-Identifier: MIT
// Define the version of solidity we’re using
pragma solidity ^0.8.0;
// Core code goes into the Contract
contract VotingContract {
    // Mapping to store the vote count for each candidate
    mapping (string => uint256) public votes;

    // Function to vote for a candidate
    function voteForCandidate(string memory candidate) public {
        // Increment the vote count for the candidate
        votes[candidate] += 1;
    }

    // Function to retrieve the vote count for a candidate
    function getVotesForCandidate(string memory candidate) public view returns (uint256) {
        return votes[candidate];
    }
}

Vamos percorrer este código passo a passo:

• 1. Definimos o licenciamento deste contrato, o que é uma prática comum na Ethereum. 2. Definimos a versão do Solidity que estamos usando. Lembre-se de que não poderemos alterar isso mais tarde, pois o contrato é imutável. 3. Definimos um contrato, que é algo como uma classe Java. É aqui que residem os dados e a lógica da nossa aplicação. 4. Definimos uma variável de estado chamada votes, que é um mapeamento. Pense em mapeamentos como dicionários. Este mapeamento específico tem chaves do tipo string e valores do tipo inteiro. Efetivamente, ele armazena uma lista de candidatos e o número de votos que eles receberam. 5. A função voteForCandidate pode ser invocada após o contrato ter sido implantado. Se você chamar esta função com um candidato como parâmetro, o número de votos para o candidato aumenta em 1. 6. A função getVotesForCandidate também pode ser invocada publicamente. Esta é uma função somente leitura, pois não altera o estado. Como resultado, a função é marcada como view. Ela simplesmente retorna o número de votos recebidos pelo candidato solicitado.

Exemplo 2: Um token simples

Agora vamos ver algo um pouco mais complicado. Neste exemplo, criaremos um token fungível simples do zero. Parte da lógica que você vê aqui também pode ser encontrada no padrão ERC-20, que é o protocolo que impulsiona todos os tokens fungíveis na Ethereum e em blockchains baseadas em EVM — incluindo o USDC.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract SimpleToken {
    string public name = "Simple Token";
    string public symbol = "ST";
    uint8 public decimals = 18; // You can adjust the number of decimal places
    uint256 public totalSupply;
    mapping(address => uint256) public balances;

    // Create an initial supply of tokens
    constructor(uint256 initialSupply) {
        totalSupply = initialSupply * 10 ** uint256(decimals);
        balances[msg.sender] = totalSupply;
    }

    // Transfer tokens 
    function transfer(address recipient, uint256 amount) public {
        require(recipient != address(0), "Transfer to the zero address is not allowed");
        require(balances[msg.sender] >= amount, "Insufficient balance");

        balances[msg.sender] -= amount;
        balances[recipient] += amount;
    }

   // Check balance of tokens
     function balanceOf(address account) public view returns (uint256) {
        return balances[account];
    }
}

Exemplo de código para criar uma nova carteira

Este código, embora mais complexo que seu antecessor, ainda deve ser bastante simples de entender. Alguns pontos a observar:

• 1. Inicializamos variáveis para armazenar o nome, símbolo, casas decimais e oferta total do nosso token. Observe que, ao contrário da maioria das outras linguagens de programação, o Solidity não oferece suporte a números de ponto flutuante. A solução alternativa é criar uma unidade pequena do seu token (geralmente 10^-18). Isso é semelhante ao wei, que é 1/10^18 de um ETH. 2. Temos um mapeamento que armazena os saldos do nosso token disponíveis em todos os endereços. 3. Temos um construtor que cria uma oferta inicial de moedas e as envia para o responsável pela implantação do contrato (ou seja, você). Observe que isso é feito apenas uma vez: quando o contrato é implantado. 4. A função transferTokens permite que um usuário transfira tokens de uma carteira para outra. Observe o uso de instruções require para aplicar certas regras, como o remetente ter saldo suficiente para tornar a transferência possível. 5. Finalmente, a função balanceOf nos informa o número de tokens que pertencem a um endereço específico.

Circle e USDC

Agora você tem uma base sólida do que precisa saber para integrar moedas digitais à sua pilha de tecnologia. E quando ouvir que o USDC da Circle é uma stablecoin (ou token) implementada como um smart contract — você agora sabe o que isso significa! O USDC não é apenas uma stablecoin na Ethereum (e em outras blockchains como Algorand, Arbitrum, Flow e Solana), mas também é de código aberto, componível e acessível para qualquer pessoa desenvolver. Você pode ver o código-fonte no Repositório do GitHub.

Para saber mais sobre como integrar o USDC aos seus aplicativos, consulte a documentação e os casos de uso no site da Circle. Você também pode experimentar Solidity

*A interface de programação de aplicativos (“API”) das Programmable Wallets é oferecida pela Circle Technology Services, LLC (“CTS”). A CTS não é uma empresa de serviços financeiros regulamentada e a API não inclui aconselhamento financeiro, de investimento, fiscal, jurídico, regulatório, contábil, comercial ou de outra natureza. Para obter detalhes adicionais, clique aqui para ver os termos de serviço do Circle Developer.