Go

1package ethereum
2 
3import (
4    "context"
5    "math/big"
6    "github.com/ethereum/go-ethereum/ethclient"
7    "github.com/ethereum/go-ethereum/common"
8    "github.com/ethereum/go-ethereum/core/types"
9)
10 
11type EthereumClient struct {
12    client *ethclient.Client
13}
14 
15func NewEthereumClient(url string) (*EthereumClient, error) {
16    client, err := ethclient.Dial(url)
17    if err != nil {
18        return nil, err
19    }
20    return &EthereumClient{client: client}, nil
21}
22 
23func (ec *EthereumClient) GetBalance(address string) (*big.Float, error) {
24    account := common.HexToAddress(address)
25    balance, err := ec.client.BalanceAt(context.Background(), account, nil)
26    if err != nil {
27        return nil, err
28    }
29 
30    fbalance := new(big.Float)
31    fbalance.SetString(balance.String())
32    ethValue := new(big.Float).Quo(fbalance, big.NewFloat(1e18))
33 
34    return ethValue, nil
35}
36 
37func (ec *EthereumClient) SendTransaction(from, to common.Address, value *big.Int) (*types.Transaction, error) {
38    nonce, err := ec.client.PendingNonceAt(context.Background(), from)
39    if err != nil {
40        return nil, err
41    }
42 
43    gasPrice, err := ec.client.SuggestGasPrice(context.Background())
44    if err != nil {
45        return nil, err
46    }
47 
48    tx := types.NewTransaction(nonce, to, value, 21000, gasPrice, nil)
49    return tx, nil
50}

1package contracts
2 
3import (
4    "github.com/ethereum/go-ethereum/accounts/abi/bind"
5    "github.com/ethereum/go-ethereum/common"
6)
7 
8type SmartContractClient struct {
9    contract *bind.BoundContract
10    address  common.Address
11}
12 
13func NewContract(address common.Address, client *ethclient.Client) (*SmartContractClient, error) {
14    parsed, err := abi.JSON(strings.NewReader(ContractABI))
15    if err != nil {
16        return nil, err
17    }
18 
19    contract := bind.NewBoundContract(address, parsed, client, client, client)
20    return &SmartContractClient{
21        contract: contract,
22        address:  address,
23    }, nil
24}
25 
26func (sc *SmartContractClient) CallMethod(method string, args ...interface{}) error {
27    opts := &bind.CallOpts{
28        Pending: false,
29        Context: context.Background(),
30    }
31 
32    return sc.contract.Call(opts, method, args...)
33}

1func (ec *EthereumClient) MonitorBlocks() (<-chan *types.Header, error) {
2    headers := make(chan *types.Header)
3    sub, err := ec.client.SubscribeNewHead(context.Background(), headers)
4    if err != nil {
5        return nil, err
6    }
7 
8    go func() {
9        for {
10            select {
11            case err := <-sub.Err():
12                log.Fatal(err)
13            case header := <-headers:
14                block, err := ec.client.BlockByHash(context.Background(), header.Hash())
15                if err != nil {
16                    log.Fatal(err)
17                }
18                fmt.Println("New block:", block.Number().Uint64())
19            }
20        }
21    }()
22 
23    return headers, nil
24}

1package utils
2 
3import (
4    "math/big"
5    "github.com/ethereum/go-ethereum/common"
6    "github.com/ethereum/go-ethereum/common/hexutil"
7)
8 
9// WeiToEther converts wei to ether
10func WeiToEther(wei *big.Int) *big.Float {
11    return new(big.Float).Quo(
12        new(big.Float).SetInt(wei),
13        new(big.Float).SetInt(big.NewInt(1e18)),
14    )
15}
16 
17// EtherToWei converts ether to wei
18func EtherToWei(ether *big.Float) *big.Int {
19    truncInt, _ := new(big.Float).Mul(ether, big.NewFloat(1e18)).Int(nil)
20    return truncInt
21}
22 
23// IsValidAddress checks if the address is valid
24func IsValidAddress(address string) bool {
25    return common.IsHexAddress(address)
26}