Neste artigo, vou implantar um contrato inteligente no ambiente local da blockchain usando Go e Go-Ethereum.
Go-ethereum
Go, uma linguagem de programação desenvolvida pelo Google, é uma das linguagens usadas para construir a rede Ethereum, e o Go Ethereum é a interface usada para escrever, editar e manipular o código Go para a blockchain. Além do Go, a blockchain e o protocolo Ethereum também são amplamente baseados em Python e C++.
ethereum
/
go-ethereum
Official Go implementation of the Ethereum protocol
Go Ethereum
Official Golang execution layer implementation of the Ethereum protocol.
Automated builds are available for stable releases and the unstable master branch. Binary archives are published at https://geth.ethereum.org/downloads/.
Building the source
For prerequisites and detailed build instructions please read the Installation Instructions.
Building geth
requires both a Go (version 1.19 or later) and a C compiler. You can install
them using your favourite package manager. Once the dependencies are installed, run
make geth
or, to build the full suite of utilities:
make all
Executables
The go-ethereum project comes with several wrappers/executables found in the cmd
directory.
Command | Description |
---|---|
geth |
Our main Ethereum CLI client. It is the entry point into the Ethereum network (main-, test- or private net), capable of running as a full node (default), archive node (retaining all historical state) or a light node (retrieving data live). It can be used by other processes as |
Contrato inteligente do USDT
Prova de trabalho (Proof-of-work ou PoW)
A rede Ethereum foi iniciada com o uso de um mecanismo de consenso que envolvia a Prova de Trabalho (PoW). Isso permitia que os nós da rede Ethereum concordassem com o estado de todas as informações registradas na blockchain Ethereum e evitava certos tipos de ataques econômicos. No entanto, a Ethereum desativou a prova de trabalho em 2022 e passou a utilizar a prova de participação (proof-of-stake ou PoS).
A prova de trabalho agora foi descontinuada. A Ethereum não usa mais a prova de trabalho como parte de seu mecanismo de consenso. Em vez disso, utiliza a prova de participação. Saiba mais sobre a prova de participação e o staking.
Prova de participação (PoS)
A prova de participação (PoS) é a base do mecanismo de consenso da Ethereum. A Ethereum ativou seu mecanismo de prova de participação em 2022 porque é mais seguro, menos intensivo em energia e melhor para implementar novas soluções de escalabilidade em comparação com a arquitetura anterior de prova de trabalho.
A prova de participação é uma maneira de provar que os validadores depositaram algo de valor na rede que pode ser destruído se agirem de maneira desonesta. Na prova de participação da Ethereum, os validadores fazem stake de capital na forma de ETH em um contrato inteligente na Ethereum. O validador é então responsável por verificar se os novos blocos propagados pela rede são válidos e ocasionalmente criar e propagar novos blocos. Se tentarem fraudar a rede (por exemplo, propondo vários blocos quando deveriam enviar apenas um ou enviando atestações conflitantes), parte ou todo o ETH que ele fez stake pode ser destruído.
Obter o projeto
git clone https://github.com/owanhunte/ethereum-solidity-course-updated-code.git
cd lottery
node -v
v18.19.0
npm init
Arquivo lottery.sol
pragma solidity >=0.5.0 <0.9.0;
contract Lottery {
address public manager;
address payable[] public players;
constructor() {
manager = msg.sender;
}
function enter() public payable {
require(msg.value >= .01 ether, "A minimum payment of .01 ether must be sent to enter the lottery");
players.push(payable(msg.sender));
}
function random() private view returns (uint256) {
return uint256(keccak256(abi.encodePacked(block.prevrandao, block.number, players)));
}
function pickWinner() public onlyOwner {
uint256 index = random() % players.length;
address contractAddress = address(this);
players[index].transfer(contractAddress.balance);
players = new address payable[](0);
}
function getPlayers() public view returns (address payable[] memory) {
return players;
}
modifier onlyOwner() {
require(msg.sender == manager, "Only owner can call this function.");
_;
}
}
Instalar dependências
npm install solc
npm install @truffle/hdwallet-provider
npm install --save mocha ganache-cli web3
npm update
npm install [email protected] //implantar no infura
Precisamos alterar no package.json
"scripts": {
"test": "mocha"
},
Executar os testes
npm run test
Implantar contrato
Configure o arquivo .env
ACCOUNT_MNEMONIC="neutral ... "
GOERLI_ENDPOINT="https://sepolia.infura.io/v3/code"
Execute o deploy.js
node deploy.js
Resultado
Attempting to deploy from account 0x6e06Dc176Ee86DCb3C428a42Ed9AAeD9c0Eb1935
Contract deployed to 0xc7e367A2EaE77148459b048ba3a3f6288EB82832
Txhash:
0xe87abc8cf10bde4395220b2c2eed29e378be3f425719354dc1c65ced9a7dd03d
Go-Ethereum
Popularmente conhecido como Geth, é o cliente oficial Ethereum para construir aplicativos descentralizados usando a linguagem de programação Go. Geth é uma das alternativas preferidas para executar, configurar nós e interagir com blockchains Ethereum devido à sua facilidade de uso.
go get github.com/ethereum/go-ethereum
package main
import (
"context"
"fmt"
"log"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/ethclient"
)
var (
contractAddress = common.HexToAddress("0xc7e367A2EaE77148459b048ba3a3f6288EB82832")
myAddress = common.HexToAddress("0x6e06Dc176Ee86DCb3C428a42Ed9AAeD9c0Eb1935")
)
func main() {
client, err := ethclient.Dial("https://sepolia.infura.io/v3/code")
if err != nil {
log.Fatal(err)
}
networkID, err := client.NetworkID(context.Background())
if err != nil {
log.Fatal(err)
}
fmt.Println(networkID)
balance, err := client.BalanceAt(context.Background(), contractAddress, nil)
if err != nil {
log.Fatal(err)
}
fmt.Println(balance)
myBalance, err := client.BalanceAt(context.Background(), myAddress, nil)
if err != nil {
log.Fatal(err)
}
fmt.Println(myBalance)
}
Você pode se conectar à gateway do Infura se não tiver um cliente existente. O Infura gerencia vários nós Ethereum [geth e parity] que são seguros, confiáveis, escaláveis e reduzem a barreira de entrada para novatos ao se conectarem à rede Ethereum.
client, err := ethclient.Dial("https://mainnet.infura.io")
Usando Ganache
Ganache é um simulador Ethereum que torna o desenvolvimento de aplicativos Ethereum mais rápido, fácil e seguro. Ele inclui todas as funções e recursos RPC populares (como eventos) e pode ser executado de maneira determinística para facilitar o desenvolvimento.
Você deve primeiro instalar o Node.js >= v16.0.0 e o npm >= 7.10.0.
sudo npm install -g ganache-cli
ganache
ganache-cli
Conectar ao Ganache
client, err := ethclient.Dial("http://localhost:8545")
if err != nil {
log.Fatal(err)
}
ganache-cli -m "much repair shock carbon improve miss forget sock include bullet interest solution"
Baixar a interface gráfica (UI) do Ganache
https://trufflesuite.com/ganache/
wget https://github.com/trufflesuite/ganache-ui/releases/download/v2.7.1/ganache-2.7.1-linux-x86_64.AppImage
chmod u+x <AppImage File>
./exampleName.AppImage
cd ~; ./ganache-2.7.1-linux-x86_64.AppImage
dlopen(): error loading libfuse.so.2
sudo apt install libfuse2
Códigos Golang
address = "http://127.0.0.1:7545"
client, err := ethclient.Dial(address)
if err != nil {
log.Fatal(err)
}
Implantar no Ganache-cli
GOERLI_ENDPOINT="http://localhost:8545"
ganache-cli -m "neutral ..."
node deploy.js
Attempting to deploy from account 0x6e06Dc176Ee86DCb3C428a42Ed9AAeD9c0Eb1935
[
'0x6e06Dc176Ee86DCb3C428a42Ed9AAeD9c0Eb1935'
]
Contract deployed to 0xf6e2551d2AFaFBA200D3803aE6a72B515Fa9f825
No Terminal do Ganache
Transaction: 0x40fb2033ec7b4c8a9c95945d7f3b83f9b73405eb43723cc7e4729d12a225b673
Contract created: 0xf6e2551d2afafba200d3803ae6a72b515fa9f825
Gas usage: 646841
Block number: 1
Block time: Mon Dec 18 2023 16:58:05 GMT
Saldo das Contas
Ler o saldo de uma conta é simples; chame o método BalanceAt
do cliente passando o endereço da conta e um número de bloco opcional. Configurar nil
como número de bloco retornará o saldo mais recente.
var (
contractAddress = common.HexToAddress("0xf6e2551d2afafba200d3803ae6a72b515fa9f825")
myAddress = common.HexToAddress("0x6e06Dc176Ee86DCb3C428a42Ed9AAeD9c0Eb1935")
)
account := common.HexToAddress(myAddress)
balance, err := client.BalanceAt(context.Background(), account, nil)
if err != nil {
log.Fatal(err)
}
fmt.Println(balance) // 999997816911625000000
Obter saldo na blockchain 1
blockNumber := big.NewInt(1)
balance, err = client.BalanceAt(context.Background(), myAddress, blockNumber)
if err != nil {
log.Fatal(err)
}
Como estamos lidando com números grandes, teremos que importar os pacotes nativos Go math e math/big
Saldo Pendente
Às vezes, você desejará saber qual é o saldo pendente da conta, por exemplo, após enviar ou aguardar a confirmação de uma transação. O cliente fornece um método semelhante a BalanceAt
chamado PendingBalanceAt
, que aceita o endereço da conta como parâmetro.
pendingBalance, err := client.PendingBalanceAt(context.Background(), myAddress)
fmt.Println(pendingBalance) // 25729324269165216042
Cabeçalho do Bloco
Você pode chamar o método HeaderByNumber
do cliente para retornar informações do cabeçalho sobre um bloco. Ele retornará o cabeçalho do bloco mais recente se você passar nil.
header, err := client.HeaderByNumber(context.Background(), nil)
if err != nil {
log.Fatal(err)
}
fmt.Println(header.Number.String()) // 1
Bloco Completo
Chame o método BlockByNumber
do cliente para obter o bloco completo. Você pode ler todo o conteúdo e metadados do bloco, como número do bloco, carimbo de data/hora do bloco, hash do bloco, dificuldade do bloco, bem como a lista de transações e muito mais.
Bloco de contagem
count, err := client.TransactionCount(context.Background(), block.Hash())
if err != nil {
log.Fatal(err)
}
fmt.Println(count)
Dados da Transação
for _, tx := range block.Transactions() {
fmt.Println(tx.Hash().Hex())
fmt.Println(tx.Value().String())
fmt.Println(tx.Gas())
fmt.Println(tx.GasPrice().Uint64())
fmt.Println(tx.Nonce())
}
___________________________Transaction
0x40fb2033ec7b4c8a9c95945d7f3b83f9b73405eb43723cc7e4729d12a225b673
0
646841
4500000000
0
Compilação e ABI do Contrato Inteligente
Solc está disponível como um pacote snapcraft para o Ubuntu.
sudo snap install solc --edge
Também precisamos instalar uma ferramenta chamada Abigen
para gerar a ABI de um contrato inteligente Solidity.
go get -u github.com/ethereum/go-ethereum
cd $GOPATH/src/github.com/ethereum/go-ethereum/
make
make devtools
Abigen
Abigen é um gerador de bindings para interagir facilmente com a Ethereum usando Go. Abigen cria pacotes Go fáceis de usar e seguros por tipo a partir de definições de contratos inteligentes Ethereum conhecidas como ABIs. Isso abstrai muita da complexidade do manuseio de implantação e interação de contratos inteligentes em aplicativos nativos em Go, como a codificação e decodificação de contratos inteligentes em bytecode EVM. Abigen vem junto com o Geth. Uma instalação completa do Geth inclui o binário Abigen. Abigen também pode ser construído independentemente navegando até go-ethereum/cmd/abigen e executando go build, ou equivalente:
$ cd $GOPATH/src/github.com/ethereum/go-ethereum
$ go build ./cmd/abigen
Usar contrato inteligente em Golang
Criar ABI a partir do contrato.
solc --abi Lottery.sol
======= Lottery.sol:Lottery =======
Contrato JSON ABI
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"enter","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getPlayers","outputs":[{"internalType":"address payable[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pickWinner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"players","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
Ou construa no arquivo:
solc --abi Storage.sol -o build
O vínculo do contrato pode então ser gerado passando a ABI para Abigen da seguinte forma:
solc --abi Storage.sol -o build
Para implantar um contrato inteligente a partir do Go, também precisamos compilar o contrato inteligente solidity para bytecode EVM. O bytecode EVM é o que será enviado no campo de dados da transação. O arquivo bin é necessário para gerar os métodos de implantação no arquivo do contrato Go.
solc --bin Lottery.sol
======= Lottery.sol:Lottery =======
Binary:
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
Implantando contratos na Ethereum
solc --bin Lottery.sol -o Lottery.bin
Em seguida, o Abigen pode ser executado novamente, desta vez passando o Storage.bin:
abigen --abi ./build/Lottery.abi --pkg main --type Lottery --out Lottery.go --bin ./Lottery.bin/Lottery.bin
A nova função DeployLottery() pode ser usada para implantar o contrato em uma rede de testes Ethereum a partir de uma aplicação em Go. Para fazer isso, é necessário incorporar as ligações (bindings) em uma aplicação Go que também lida com gerenciamento de contas, autorização e backend Ethereum para implantar o contrato. Especificamente, isso requer:
- Um nó Geth em execução conectado a uma rede de testes Ethereum
- Uma conta no keystore pré-financiada com ETH suficiente para cobrir os custos de gás para implantação e interação com o contrato
Usar a chave privada no Ganache-cli
ganache-cli -m "neutral ..."
address := "http://localhost:8545" // ganache cli
client, err := ethclient.Dial(address)
if err != nil {
log.Fatal(err)
}
privateKey, err := crypto.HexToECDSA("872e066455dcfb1e38e1c6109f3522f2d2344e3b58fbfbe0b47803c971784760")
if err != nil {
log.Fatal(err)
}
nonce, err := client.PendingNonceAt(context.Background(), crypto.PubkeyToAddress(privateKey.PublicKey))
if err != nil {
log.Fatal(err)
}
gasPrice, err := client.SuggestGasPrice(context.Background())
if err != nil {
log.Fatal(err)
}
fmt.Println("gasPrice: ", gasPrice)
chainID, err := client.ChainID(context.Background())
fmt.Println("networkID :", chainID)
auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
if err != nil {
fmt.Println(err)
}
auth.Nonce = big.NewInt(int64(nonce))
auth.Value = big.NewInt(0) // em wei
auth.GasLimit = uint64(300000) // em unidades
auth.GasPrice = gasPrice
txAddress, tx, instance, err := contracts.DeployLottery(auth, client)
if err != nil {
fmt.Println("DeployLottery")
log.Fatal(err.Error())
}
fmt.Println(instance, address, tx, instance)
fmt.Println(txAddress.Hex()) // 0x147B8eb97fD247D06C4006D269c90C1908Fb5D54
fmt.Println(tx.Hash().Hex())
fmt.Println(txAddress.Hex())
fmt.Println(tx.Hash().Hex())
0xf6e2551d2AFaFBA200D3803aE6a72B515Fa9f825
0x81ea1d8c480a316f5721edf31a3c1f39f3827b5cc75e9b6fcad928c3e261dd08
Transaction: 0x81ea1d8c480a316f5721edf31a3c1f39f3827b5cc75e9b6fcad928c3e261dd08
Contract created: 0xf6e2551d2afafba200d3803ae6a72b515fa9f825
Gas usage: 300000
Block number: 1
Block time: Tue Dec 19 2023 14:10:57
Runtime error: code size to deposit exceeds maximum code size
Carregando um Contrato Inteligente
Depois de compilar a ABI do seu contrato inteligente para um pacote Go usando a ferramenta Abigen, o próximo passo é chamar o método "New", que está no formato New<NomeDoContrato>,
então, em nosso exemplo, se você se lembrar, será NewStore. Este método inicializador recebe o endereço do contrato inteligente e retorna uma instância de contrato com a qual você pode começar a interagir.
Transaction: 0x25b79f942ebccfae067bb94a0e76282e7c1c2db825e5cbee18da1bb487596e06
address := "http://localhost:8545" // ganache cli
client, err := ethclient.Dial(address)
if err != nil {
log.Fatal(err)
}
contractAddress := common.HexToAddress("0x25b79f942ebccfae067bb94a0e76282e7c1c2db825e5cbee18da1bb487596e06")
instance, err := contracts.NewLottery(contractAddress, client)
if err != nil {
log.Fatal(err)
}
Escrevendo em um Contrato Inteligente
Transação do contrato:
Transaction: 0x25b79f942ebccfae067bb94a0e76282e7c1c2db825e5cbee18da1bb487596e06
Use chaves privadas no ganache:
address := "http://localhost:8545" // ganache cli
client, err := ethclient.Dial(address)
if err != nil {
log.Fatal(err)
}
privateKey, err := crypto.HexToECDSA("872e066455dcfb1e38e1c6109f3522f2d2344e3b58fbfbe0b47803c971784760")
if err != nil {
log.Fatal(err)
}
publicKey := privateKey.Public()
publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
if !ok {
log.Fatal("error casting public key to ECDSA")
}
fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
if err != nil {
log.Fatal(err)
}
gasPrice, err := client.SuggestGasPrice(context.Background())
if err != nil {
log.Fatal(err)
}
fmt.Println(gasPrice)
chainID, err := client.ChainID(context.Background())
if err != nil {
log.Fatal(err)
}
fmt.Println("networkID :", chainID)
auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
if err != nil {
log.Fatal(err)
}
auth.Nonce = big.NewInt(int64(nonce))
auth.Value = big.NewInt(0) // em wei
auth.GasLimit = uint64(3000000) // em unidades
auth.GasPrice = gasPrice
contractAddress := common.HexToAddress("0x25b79f942ebccfae067bb94a0e76282e7c1c2db825e5cbee18da1bb487596e06")
balance, err := client.BalanceAt(context.Background(), contractAddress, nil)
if err != nil {
log.Fatal(err)
}
fmt.Println("balance : ", balance)
myAddress := common.HexToAddress("0x6e06Dc176Ee86DCb3C428a42Ed9AAeD9c0Eb1935")
myBalance, err := client.BalanceAt(context.Background(), myAddress, nil)
if err != nil {
log.Fatal(err)
}
fmt.Println("myBalance : ", myBalance)
instance, err := contracts.NewLottery(contractAddress, client)
if err != nil {
fmt.Println("NewLottery")
log.Fatal(err)
}
tx, err := instance.Enter(auth)
if err != nil {
fmt.Println("Enter")
log.Fatal(err)
}
go run *.go
2000000000
networkID : 1337
balance : 0
myBalance : 999997000000000000000
Transaction: 0xa531650fe246012062408f17e4d56ace4622a4680ac799279262c60666201fe5
Gas usage: 21064
Block number: 6
Block time: Tue Dec 19 2023 15:18:07 GMT
Artigo escrito por mobin shaterian. Traduzido por Marcelo Panegali
Oldest comments (0)