Ir para o conteúdo
Buscar

WEB3DEV

Cover image for Implantar Contrato Inteligente e Conectar ao Go-Ethereum
Panegali
Panegali

Posted on

Implantar Contrato Inteligente e Conectar ao Go-Ethereum

#ethereum #goethereum #web3

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++.

GitHub logo ethereum / go-ethereum

Official Go implementation of the Ethereum protocol

Go Ethereum

Official Golang execution layer implementation of the Ethereum protocol.

API Reference Go Report Card Travis Discord

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
Enter fullscreen mode Exit fullscreen mode

or, to build the full suite of utilities:

make all
Enter fullscreen mode Exit fullscreen mode

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
…
Ver no GitHub

Contrato inteligente do USDT

https://etherscan.io/address/0xdac17f958d2ee523a2206206994597c13d831ec7?source=post_page-----935f4290249f--------------------------------#analytics

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.

https://ethereum.org/en/developers/docs/consensus-mechanisms/pow/?source=post_page-----935f4290249f--------------------------------

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.

https://ethereum.org/en/developers/docs/consensus-mechanisms/pos/?source=post_page-----935f4290249f--------------------------------

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

https://github.com/owanhunte/ethereum-solidity-course-updated-code?source=post_page-----935f4290249f--------------------------------

git clone https://github.com/owanhunte/ethereum-solidity-course-updated-code.git
cd lottery
Enter fullscreen mode Exit fullscreen mode 
node -v
v18.19.0
npm init
Enter fullscreen mode Exit fullscreen mode

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.");
   _;
 }
}
Enter fullscreen mode Exit fullscreen mode

Instalar dependências 

npm install solc
npm install @truffle/hdwallet-provider
npm install --save mocha ganache-cli web3
npm update
Enter fullscreen mode Exit fullscreen mode 
npm install [email protected] //implantar no infura
Enter fullscreen mode Exit fullscreen mode

Precisamos alterar no package.json 

 "scripts": {
    "test": "mocha"
  },
Enter fullscreen mode Exit fullscreen mode

Executar os testes 

npm run test
Enter fullscreen mode Exit fullscreen mode

Implantar contrato

Configure o arquivo .env

ACCOUNT_MNEMONIC="neutral ... "
GOERLI_ENDPOINT="https://sepolia.infura.io/v3/code"
Enter fullscreen mode Exit fullscreen mode

Execute o deploy.js 

node deploy.js
Enter fullscreen mode Exit fullscreen mode

Resultado

Attempting to deploy from account 0x6e06Dc176Ee86DCb3C428a42Ed9AAeD9c0Eb1935
Contract deployed to 0xc7e367A2EaE77148459b048ba3a3f6288EB82832
Enter fullscreen mode Exit fullscreen mode

https://sepolia.etherscan.io/address/0x6e06Dc176Ee86DCb3C428a42Ed9AAeD9c0Eb1935?source=post_page-----935f4290249f--------------------------------

https://sepolia.etherscan.io/tx/0xe87abc8cf10bde4395220b2c2eed29e378be3f425719354dc1c65ced9a7dd03d?source=post_page-----935f4290249f--------------------------------

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.

https://geth.ethereum.org/docs/developers/dapp-developer/native?source=post_page-----935f4290249f--------------------------------

go get github.com/ethereum/go-ethereum
Enter fullscreen mode Exit fullscreen mode 
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)
}
Enter fullscreen mode Exit fullscreen mode

https://goethereumbook.org/client-setup/?source=post_page-----935f4290249f--------------------------------

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")
Enter fullscreen mode Exit fullscreen mode

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.

https://github.com/trufflesuite/ganache?source=post_page-----935f4290249f--------------------------------

Você deve primeiro instalar o Node.js >= v16.0.0 e o npm >= 7.10.0.

sudo npm install -g ganache-cli
Enter fullscreen mode Exit fullscreen mode 
ganache
Enter fullscreen mode Exit fullscreen mode 


ganache-cli
Enter fullscreen mode Exit fullscreen mode

Conectar ao Ganache 

client, err := ethclient.Dial("http://localhost:8545")
if err != nil {
  log.Fatal(err)
}
Enter fullscreen mode Exit fullscreen mode 
ganache-cli -m "much repair shock carbon improve miss forget sock include bullet interest solution"
Enter fullscreen mode Exit fullscreen mode

Baixar a interface gráfica (UI) do Ganache 

https://trufflesuite.com/ganache/
Enter fullscreen mode Exit fullscreen mode 
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
Enter fullscreen mode Exit fullscreen mode 
dlopen(): error loading libfuse.so.2
sudo apt install libfuse2
Enter fullscreen mode Exit fullscreen mode

Códigos Golang 

address = "http://127.0.0.1:7545"
client, err := ethclient.Dial(address)
if err != nil {
 log.Fatal(err)
}
Enter fullscreen mode Exit fullscreen mode

Implantar no Ganache-cli 

GOERLI_ENDPOINT="http://localhost:8545"
ganache-cli -m "neutral ..."
node deploy.js
Enter fullscreen mode Exit fullscreen mode 
Attempting to deploy from account 0x6e06Dc176Ee86DCb3C428a42Ed9AAeD9c0Eb1935
[
  '0x6e06Dc176Ee86DCb3C428a42Ed9AAeD9c0Eb1935'
]
Contract deployed to 0xf6e2551d2AFaFBA200D3803aE6a72B515Fa9f825
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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")
)
Enter fullscreen mode Exit fullscreen mode 
account := common.HexToAddress(myAddress)
balance, err := client.BalanceAt(context.Background(), account, nil)
if err != nil {
  log.Fatal(err)
}

fmt.Println(balance) // 999997816911625000000
Enter fullscreen mode Exit fullscreen mode

Obter saldo na blockchain 1 

blockNumber := big.NewInt(1)
balance, err = client.BalanceAt(context.Background(), myAddress, blockNumber)
if err != nil {
 log.Fatal(err)
}
Enter fullscreen mode Exit fullscreen mode

Como estamos lidando com números grandes, teremos que importar os pacotes nativos Go math e math/big

https://goethereumbook.org/block-query/?source=post_page-----935f4290249f--------------------------------

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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())             
}
Enter fullscreen mode Exit fullscreen mode 
___________________________Transaction
0x40fb2033ec7b4c8a9c95945d7f3b83f9b73405eb43723cc7e4729d12a225b673
0
646841
4500000000
0
Enter fullscreen mode Exit fullscreen mode

Compilação e ABI do Contrato Inteligente

https://goethereumbook.org/smart-contract-compile/?source=post_page-----935f4290249f--------------------------------

Solc está disponível como um pacote snapcraft para o Ubuntu.

sudo snap install solc --edge
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Abigen

https://geth.ethereum.org/docs/tools/abigen?source=post_page-----935f4290249f--------------------------------

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
Enter fullscreen mode Exit fullscreen mode

Usar contrato inteligente em Golang

Criar ABI a partir do contrato.

solc --abi Lottery.sol
Enter fullscreen mode Exit fullscreen mode 
======= 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"}]
Enter fullscreen mode Exit fullscreen mode

Ou construa no arquivo:

solc --abi Storage.sol -o build
Enter fullscreen mode Exit fullscreen mode

O vínculo do contrato pode então ser gerado passando a ABI para Abigen da seguinte forma:

solc --abi Storage.sol -o build
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode 
======= Lottery.sol:Lottery =======
Binary:
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
Enter fullscreen mode Exit fullscreen mode

https://geth.ethereum.org/docs/developers/dapp-developer/native-bindings?source=post_page-----935f4290249f--------------------------------

Implantando contratos na Ethereum 

solc --bin Lottery.sol -o Lottery.bin
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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:

  1. Um nó Geth em execução conectado a uma rede de testes Ethereum
  2. 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 ..."
Enter fullscreen mode Exit fullscreen mode 


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())
Enter fullscreen mode Exit fullscreen mode 
fmt.Println(txAddress.Hex())
fmt.Println(tx.Hash().Hex())

0xf6e2551d2AFaFBA200D3803aE6a72B515Fa9f825
0x81ea1d8c480a316f5721edf31a3c1f39f3827b5cc75e9b6fcad928c3e261dd08
Enter fullscreen mode Exit fullscreen mode 
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
Enter fullscreen mode Exit fullscreen mode

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&lt;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
Enter fullscreen mode Exit fullscreen mode 
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)
}
Enter fullscreen mode Exit fullscreen mode

Escrevendo em um Contrato Inteligente

https://goethereumbook.org/smart-contract-write/?source=post_page-----935f4290249f--------------------------------

Transação do contrato:

Transaction: 0x25b79f942ebccfae067bb94a0e76282e7c1c2db825e5cbee18da1bb487596e06
Enter fullscreen mode Exit fullscreen mode

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)
}
Enter fullscreen mode Exit fullscreen mode 
go run *.go
2000000000
networkID : 1337
balance :  0
myBalance :  999997000000000000000
Enter fullscreen mode Exit fullscreen mode 
 Transaction: 0xa531650fe246012062408f17e4d56ace4622a4680ac799279262c60666201fe5
 Gas usage: 21064
 Block number: 6
 Block time: Tue Dec 19 2023 15:18:07 GMT
Enter fullscreen mode Exit fullscreen mode

Artigo escrito por mobin shaterian. Traduzido por Marcelo Panegali

Oldest comments (0)


Leia o próximo

viniblack profile image

Meu primeiro smart contract: Criando um token ERC-20 pt.2

ViniBlack -

lorenzobattistela profile image

Introdução a Web3.js - Crash Course Desenvolvedor Ethereum Blockchain

Lorenzo Battistela -

paulogio profile image

Teoria dos Jogos: Incentivos DeFi

Paulo Gio -

ojedai85 profile image

Como criar sua própria DAO com Aragon

Rafael Ojeda -