Import & adapt iden/go-iden3-core/eth/client

eth/client.go

@@ -1,15 +1,206 @@
 package eth
 
-import "github.com/hermeznetwork/hermez-node/common"
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
 
-type EthClient struct {
+	"github.com/ethereum/go-ethereum/accounts"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	ethKeystore "github.com/ethereum/go-ethereum/accounts/keystore"
+	ethCommon "github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/hermeznetwork/hermez-node/common"
+	"github.com/hermeznetwork/hermez-node/log"
+)
+
+var (
+	ErrAccountNil = fmt.Errorf("Authorized calls can't be made when the account is nil")
+	// ErrReceiptStatusFailed when receiving a failed transaction
+	ErrReceiptStatusFailed = fmt.Errorf("receipt status is failed")
+	// ErrReceiptNotRecieved when unable to retrieve a transaction
+	ErrReceiptNotReceived = fmt.Errorf("receipt not available")
+)
+
+const (
+	errStrDeploy      = "deployment of %s failed: %w"
+	errStrWaitReceipt = "wait receipt of %s deploy failed: %w"
+)
+
+// Client is an ethereum client to call Smart Contract methods.
+type Client struct {
+	client         *ethclient.Client
+	account        *accounts.Account
+	ks             *ethKeystore.KeyStore
+	ReceiptTimeout time.Duration
 }
 
-func NewEthClient() *EthClient {
-	// TODO
-	return &EthClient{}
+// NewClient creates a Client instance.  The account is not mandatory (it can
+// be nil).  If the account is nil, CallAuth will fail with ErrAccountNil.
+func NewClient(client *ethclient.Client, account *accounts.Account, ks *ethKeystore.KeyStore) *Client {
+	return &Client{client: client, account: account, ks: ks, ReceiptTimeout: 60 * time.Second}
 }
-func (ec *EthClient) ForgeCall(callData *common.CallDataForge) ([]byte, error) {
+
+// BalanceAt retieves information about the default account
+func (c *Client) BalanceAt(addr ethCommon.Address) (*big.Int, error) {
+	return c.client.BalanceAt(context.TODO(), addr, nil)
+}
+
+// Account returns the underlying ethereum account
+func (c *Client) Account() *accounts.Account {
+	return c.account
+}
+
+// CallAuth performs a Smart Contract method call that requires authorization.
+// This call requires a valid account with Ether that can be spend during the
+// call.
+func (c *Client) CallAuth(gasLimit uint64,
+	fn func(*ethclient.Client, *bind.TransactOpts) (*types.Transaction, error)) (*types.Transaction, error) {
+	if c.account == nil {
+		return nil, ErrAccountNil
+	}
+
+	gasPrice, err := c.client.SuggestGasPrice(context.Background())
+	if err != nil {
+		return nil, err
+	}
+	inc := new(big.Int).Set(gasPrice)
+	inc.Div(inc, new(big.Int).SetUint64(100))
+	gasPrice.Add(gasPrice, inc)
+	log.Debug("Transaction metadata", "gasPrice", gasPrice)
+
+	auth, err := bind.NewKeyStoreTransactor(c.ks, *c.account)
+	if err != nil {
+		return nil, err
+	}
+	auth.Value = big.NewInt(0) // in wei
+	if gasLimit == 0 {
+		auth.GasLimit = uint64(300000) // in units
+	} else {
+		auth.GasLimit = gasLimit // in units
+	}
+	auth.GasPrice = gasPrice
+
+	tx, err := fn(c.client, auth)
+	if tx != nil {
+		log.Debug("Transaction", "tx", tx.Hash().Hex(), "nonce", tx.Nonce())
+	}
+	return tx, err
+}
+
+type ContractData struct {
+	Address ethCommon.Address
+	Tx      *types.Transaction
+	Receipt *types.Receipt
+}
+
+// Deploy a smart contract.  `name` is used to log deployment information.  fn
+// is a wrapper to the deploy function generated by abigen.  In case of error,
+// the returned `ContractData` may have some parameters filled depending on the
+// kind of error that ocurred.
+// successfull.
+func (c *Client) Deploy(name string,
+	fn func(c *ethclient.Client, auth *bind.TransactOpts) (ethCommon.Address, *types.Transaction, interface{}, error)) (ContractData, error) {
+	var contractData ContractData
+	log.Info("Deploying", "contract", name)
+	tx, err := c.CallAuth(
+		1000000,
+		func(client *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
+			addr, tx, _, err := fn(client, auth)
+			if err != nil {
+				return nil, err
+			}
+			contractData.Address = addr
+			return tx, nil
+		},
+	)
+	if err != nil {
+		return contractData, fmt.Errorf(errStrDeploy, name, err)
+	}
+	log.Info("Waiting receipt", "tx", tx.Hash().Hex(), "contract", name)
+	contractData.Tx = tx
+	receipt, err := c.WaitReceipt(tx)
+	if err != nil {
+		return contractData, fmt.Errorf(errStrWaitReceipt, name, err)
+	}
+	contractData.Receipt = receipt
+	return contractData, nil
+}
+
+// Call performs a read only Smart Contract method call.
+func (c *Client) Call(fn func(*ethclient.Client) error) error {
+	return fn(c.client)
+}
+
+// WaitReceipt will block until a transaction is confirmed.  Internally it
+// polls the state every 200 milliseconds.
+func (c *Client) WaitReceipt(tx *types.Transaction) (*types.Receipt, error) {
+	return c.waitReceipt(tx, context.TODO(), c.ReceiptTimeout)
+}
+
+// GetReceipt will check if a transaction is confirmed and return
+// immediately, waiting at most 1 second and returning error if the transaction
+// is still pending.
+func (c *Client) GetReceipt(tx *types.Transaction) (*types.Receipt, error) {
+	ctx, cancel := context.WithTimeout(context.TODO(), 1*time.Second)
+	defer cancel()
+	return c.waitReceipt(tx, ctx, 0)
+}
+
+func (c *Client) waitReceipt(tx *types.Transaction, ctx context.Context, timeout time.Duration) (*types.Receipt, error) {
+	var err error
+	var receipt *types.Receipt
+
+	txid := tx.Hash()
+	log.Debug("Waiting for receipt", "tx", txid.Hex())
+
+	start := time.Now()
+	for {
+		receipt, err = c.client.TransactionReceipt(ctx, txid)
+		if receipt != nil || time.Since(start) >= timeout {
+			break
+		}
+		time.Sleep(200 * time.Millisecond)
+	}
+
+	if receipt != nil && receipt.Status == types.ReceiptStatusFailed {
+		log.Error("Failed transaction", "tx", txid.Hex())
+		return receipt, ErrReceiptStatusFailed
+	}
+
+	if receipt == nil {
+		log.Debug("Pendingtransaction / Wait receipt timeout", "tx", txid.Hex(), "lasterr", err)
+		return receipt, ErrReceiptNotReceived
+	}
+	log.Debug("Successfull transaction", "tx", txid.Hex())
+
+	return receipt, err
+}
+
+// CurrentBlock returns the current block number in the blockchain
+func (c *Client) CurrentBlock() (*big.Int, error) {
+	ctx, cancel := context.WithTimeout(context.TODO(), 1*time.Second)
+	defer cancel()
+	header, err := c.client.HeaderByNumber(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	return header.Number, nil
+}
+
+// HeaderByNumber internally calls ethclient.Client HeaderByNumber
+func (c *Client) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
+	return c.client.HeaderByNumber(ctx, number)
+}
+
+// BlockByNumber internally calls ethclient.Client BlockByNumber
+func (c *Client) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
+	return c.client.BlockByNumber(ctx, number)
+}
+
+func (c *Client) ForgeCall(callData *common.CallDataForge) ([]byte, error) {
 	// TODO this depends on the smart contracts, once are ready this will be updated
 	return nil, nil
 }