Browse Source
Merge pull request #73 from hermeznetwork/feature/ethclient0
Import & adapt iden/go-iden3-core/eth/clientfeature/sql-semaphore1
a_bennassar
4 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 275 additions and 53 deletions
Split View
Diff Options
-
+3 -3common/account.go
-
+2 -2common/accountcreationauths.go
-
+6 -6common/batch.go
-
+5 -5common/bid.go
-
+4 -4common/block.go
-
+5 -5common/coordinator.go
-
+2 -2common/l1tx.go
-
+3 -3common/pooll2tx.go
-
+10 -10common/smartcontractparams.go
-
+4 -4common/token.go
-
+2 -2coordinator/coordinator.go
-
+197 -6eth/client.go
-
+1 -1go.mod
-
+31 -0go.sum
@ -1,14 +1,14 @@ |
|||
package common |
|||
|
|||
import ( |
|||
eth "github.com/ethereum/go-ethereum/common" |
|||
ethCommon "github.com/ethereum/go-ethereum/common" |
|||
) |
|||
|
|||
// Coordinator represents a Hermez network coordinator who wins an auction for an specific slot
|
|||
// WARNING: this is strongly based on the previous implementation, once the new spec is done, this may change a lot.
|
|||
type Coordinator struct { |
|||
Forger eth.Address // address of the forger
|
|||
Beneficiary eth.Address // address of the beneficiary
|
|||
Withdraw eth.Address // address of the withdraw
|
|||
URL string // URL of the coordinators API
|
|||
Forger ethCommon.Address // address of the forger
|
|||
Beneficiary ethCommon.Address // address of the beneficiary
|
|||
Withdraw ethCommon.Address // address of the withdraw
|
|||
URL string // URL of the coordinators API
|
|||
} |
|||
@ -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 |
|||
} |
|||
|
|||
// 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} |
|||
} |
|||
|
|||
// 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 |
|||
} |
|||
|
|||
func NewEthClient() *EthClient { |
|||
// TODO
|
|||
return &EthClient{} |
|||
// Call performs a read only Smart Contract method call.
|
|||
func (c *Client) Call(fn func(*ethclient.Client) error) error { |
|||
return fn(c.client) |
|||
} |
|||
func (ec *EthClient) ForgeCall(callData *common.CallDataForge) ([]byte, error) { |
|||
|
|||
// 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 |
|||
} |
|||