erc20-api/api.go at master · sokel/erc20-api · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package api

import (
	"crypto/ecdsa"
	"math/big"

	"context"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/ethclient"
)

type Tokener interface {
	Approve(key *ecdsa.PrivateKey, to string, amount *big.Int) (*types.Transaction, error)
	Transfer(key *ecdsa.PrivateKey, to string, amount *big.Int) (*types.Transaction, error)
	TransferFrom(key *ecdsa.PrivateKey, from string, to string, amount *big.Int) (*types.Transaction, error)
	BalanceOf(address string) (*big.Int, error)
	AllowanceOf(from string, to string) (*big.Int, error)
	TotalSupply() (*big.Int, error)
}

type Token struct {
	client   *ethclient.Client
	gasPrice *big.Int

	tokenContract *StandardToken
}

func NewToken(ethEndpoint string, gasPrice *big.Int, contractAddress string) (*Token, error) {
	client, err := ethclient.Dial(ethEndpoint)
	if err != nil {
		return nil, err
	}

	tokenContract, err := NewStandardToken(common.HexToAddress(contractAddress), client)
	if err != nil {
		return nil, err
	}

	bch := &Token{
		client:        client,
		gasPrice:      gasPrice,
		tokenContract: tokenContract,
	}
	return bch, nil
}

func (t *Token) BalanceOf(ctx context.Context, address string) (*big.Int, error) {
	balance, err := t.tokenContract.BalanceOf(getCallOpts(ctx), common.HexToAddress(address))
	if err != nil {
		return nil, err
	}
	return balance, nil
}

func (t *Token) AllowanceOf(ctx context.Context, from string, to string) (*big.Int, error) {
	allowance, err := t.tokenContract.Allowance(getCallOpts(ctx), common.HexToAddress(from), common.HexToAddress(to))
	if err != nil {
		return nil, err
	}
	return allowance, nil
}

func (t *Token) Approve(ctx context.Context, key *ecdsa.PrivateKey, to string, amount *big.Int) (*types.Transaction, error) {
	opts := getTxOpts(key, 48000)
	tx, err := t.tokenContract.Approve(opts, common.HexToAddress(to), amount)
	if err != nil {
		return nil, err
	}
	return tx, err
}

func (t *Token) Transfer(ctx context.Context, key *ecdsa.PrivateKey, to string, amount *big.Int) (*types.Transaction, error) {
	opts := getTxOpts(key, 40000)
	tx, err := t.tokenContract.Transfer(opts, common.HexToAddress(to), amount)
	if err != nil {
		return nil, err
	}
	return tx, err
}

func (t *Token) TransferFrom(ctx context.Context, key *ecdsa.PrivateKey, from string, to string, amount *big.Int) (*types.Transaction, error) {
	opts := getTxOpts(key, 50000)
	tx, err := t.tokenContract.TransferFrom(opts, common.HexToAddress(from), common.HexToAddress(to), amount)
	if err != nil {
		return nil, err
	}
	return tx, err
}

func (t *Token) TotalSupply(ctx context.Context) (*big.Int, error) {
	totalSupply, err := t.tokenContract.TotalSupply(getCallOpts(ctx))
	if err != nil {
		return nil, err
	}
	return totalSupply, nil
}

func getTxOpts(key *ecdsa.PrivateKey, gasLimit uint64) *bind.TransactOpts {
	opts := bind.NewKeyedTransactor(key)
	opts.GasLimit = gasLimit
	return opts
}

func getCallOpts(ctx context.Context) *bind.CallOpts {
	return &bind.CallOpts{
		Context: ctx,
		Pending: false,
	}
}