256 lines
7.0 KiB
Go
256 lines
7.0 KiB
Go
package rpcclient
|
|
|
|
import (
|
|
"context"
|
|
"crypto/ecdsa"
|
|
"io/ioutil"
|
|
"math/big"
|
|
"strings"
|
|
|
|
"github.com/Secured-Finance/p2p-oracle-node/contracts/aggregator"
|
|
"github.com/Secured-Finance/p2p-oracle-node/contracts/oracleemitter"
|
|
"github.com/ethereum/go-ethereum"
|
|
"github.com/ethereum/go-ethereum/accounts/abi"
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
"github.com/ethereum/go-ethereum/accounts/keystore"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/ethclient"
|
|
"github.com/ipfs/go-log"
|
|
)
|
|
|
|
type EthereumClient struct {
|
|
HttpClient *ethclient.Client
|
|
WsClient *ethclient.Client
|
|
Logger *log.ZapEventLogger
|
|
}
|
|
|
|
type OracleEvent struct {
|
|
RequestType string
|
|
CallbackAddress common.Address
|
|
CallbackMethodID [4]byte
|
|
RequestID *big.Int
|
|
}
|
|
|
|
type Ethereum interface {
|
|
Connect(context.Context, string) error
|
|
Balance(context.Context, string) (*big.Int, error)
|
|
SubscribeOnSmartContractEvents(context.Context, string)
|
|
GenerateAddressFromPrivateKey(string) string
|
|
SendTransaction(string, string, int64) string
|
|
createKeyStore(string) string
|
|
importKeyStore(string, string) string
|
|
}
|
|
|
|
func NewEthereumClient() *EthereumClient {
|
|
ethereumClient := &EthereumClient{
|
|
Logger: log.Logger("rendezvous"),
|
|
}
|
|
log.SetAllLoggers(log.LevelInfo)
|
|
|
|
return ethereumClient
|
|
}
|
|
|
|
func (c *EthereumClient) Connect(ctx context.Context, url string, connectionType string) error {
|
|
client, err := ethclient.Dial(url)
|
|
if err != nil {
|
|
c.Logger.Fatal(err)
|
|
}
|
|
if connectionType == "websocket" {
|
|
c.WsClient = client
|
|
} else {
|
|
c.HttpClient = client
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Balance returns the balance of the given ethereum address.
|
|
func (c *EthereumClient) Balance(ctx context.Context, address string) (*big.Int, error) {
|
|
ethereumAddress := common.HexToAddress(address)
|
|
value, err := c.HttpClient.BalanceAt(ctx, ethereumAddress, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func (c *EthereumClient) SendTransaction(private_key, to string, amount int64) string {
|
|
privateKey, err := crypto.HexToECDSA(private_key)
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to parse private key", err)
|
|
}
|
|
|
|
publicKey := privateKey.Public()
|
|
publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
|
|
if !ok {
|
|
c.Logger.Fatal("Cannot assert type: publicKey is not of type *ecdsa.PublicKey", err)
|
|
}
|
|
|
|
fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
|
|
nonce, err := c.HttpClient.PendingNonceAt(context.Background(), fromAddress)
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to generate wallet nonce value", err)
|
|
}
|
|
|
|
value := big.NewInt(amount)
|
|
gasLimit := uint64(21000) // in units
|
|
gasPrice, err := c.HttpClient.SuggestGasPrice(context.Background())
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to suggest new gas price", err)
|
|
}
|
|
|
|
toAddress := common.HexToAddress(to)
|
|
var data []byte
|
|
tx := types.NewTransaction(nonce, toAddress, value, gasLimit, gasPrice, data)
|
|
|
|
chainID, err := c.HttpClient.NetworkID(context.Background())
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to get network ID", err)
|
|
}
|
|
|
|
signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to sign transaction", err)
|
|
}
|
|
|
|
err = c.HttpClient.SendTransaction(context.Background(), signedTx)
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to send signed transaction", err)
|
|
}
|
|
|
|
TxHash := signedTx.Hash().Hex()
|
|
|
|
c.Logger.Info("Transaction sent: %s", TxHash)
|
|
|
|
return TxHash
|
|
}
|
|
|
|
func (c *EthereumClient) GenerateAddressFromPrivateKey(private_key string) string {
|
|
privateKey, err := crypto.HexToECDSA(private_key)
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to generate private key", err)
|
|
}
|
|
|
|
publicKey := privateKey.Public()
|
|
publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
|
|
if !ok {
|
|
c.Logger.Fatal("cannot assert type: publicKey is not of type *ecdsa.PublicKey")
|
|
}
|
|
|
|
publicKeyBytes := crypto.FromECDSAPub(publicKeyECDSA)
|
|
c.Logger.Info(hexutil.Encode(publicKeyBytes)[4:])
|
|
|
|
address := crypto.PubkeyToAddress(*publicKeyECDSA).Hex()
|
|
|
|
return address
|
|
}
|
|
|
|
func (c *EthereumClient) SubscribeOnOracleEvents(ctx context.Context, address string) {
|
|
contractAddress := common.HexToAddress(address)
|
|
|
|
query := ethereum.FilterQuery{
|
|
Addresses: []common.Address{contractAddress},
|
|
}
|
|
|
|
contractAbi, err := abi.JSON(strings.NewReader(string(oracleemitter.SmartcontractsABI)))
|
|
if err != nil {
|
|
c.Logger.Fatal(err)
|
|
}
|
|
|
|
logs := make(chan types.Log)
|
|
sub, err := c.WsClient.SubscribeFilterLogs(context.Background(), query, logs)
|
|
if err != nil {
|
|
c.Logger.Fatal(err)
|
|
}
|
|
|
|
for {
|
|
select {
|
|
case err := <-sub.Err():
|
|
c.Logger.Fatal(err)
|
|
case vLog := <-logs:
|
|
var event OracleEvent
|
|
err := contractAbi.Unpack(&event, "NewOracleRequest", vLog.Data)
|
|
|
|
if err != nil {
|
|
c.Logger.Fatal(err)
|
|
}
|
|
c.Logger.Info(event) // pointer to event log
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *EthereumClient) createKeyStore(password string) string {
|
|
ks := keystore.NewKeyStore("./wallets", keystore.StandardScryptN, keystore.StandardScryptP)
|
|
account, err := ks.NewAccount(password)
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to create new keystore", err)
|
|
}
|
|
|
|
return account.Address.Hex()
|
|
}
|
|
|
|
func (c *EthereumClient) importKeyStore(filePath string, password string) string {
|
|
ks := keystore.NewKeyStore("./wallets", keystore.StandardScryptN, keystore.StandardScryptP)
|
|
jsonBytes, err := ioutil.ReadFile(filePath)
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to read keystore file", err)
|
|
}
|
|
|
|
account, err := ks.Import(jsonBytes, password, password)
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to import keystore", err)
|
|
}
|
|
|
|
return account.Address.Hex()
|
|
}
|
|
|
|
func (c *EthereumClient) SendConsensusValues(private_key string, smartContractAddress string, reqID *big.Int, data string, callbackAddress common.Address, callbackMethodID [4]byte) string {
|
|
privateKey, err := crypto.HexToECDSA(private_key)
|
|
if err != nil {
|
|
c.Logger.Fatal("Failed to generate private key", err)
|
|
}
|
|
|
|
publicKey := privateKey.Public()
|
|
publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
|
|
if !ok {
|
|
c.Logger.Fatal("cannot assert type: publicKey is not of type *ecdsa.PublicKey")
|
|
}
|
|
|
|
publicKeyBytes := crypto.FromECDSAPub(publicKeyECDSA)
|
|
c.Logger.Info(hexutil.Encode(publicKeyBytes)[4:])
|
|
|
|
fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
|
|
nonce, err := c.HttpClient.PendingNonceAt(context.Background(), fromAddress)
|
|
if err != nil {
|
|
c.Logger.Fatal(err)
|
|
}
|
|
|
|
gasPrice, err := c.HttpClient.SuggestGasPrice(context.Background())
|
|
if err != nil {
|
|
c.Logger.Fatal(err)
|
|
}
|
|
|
|
auth := bind.NewKeyedTransactor(privateKey)
|
|
auth.Nonce = big.NewInt(int64(nonce))
|
|
auth.Value = big.NewInt(0) // in wei
|
|
auth.GasLimit = uint64(300000) // in units
|
|
auth.GasPrice = gasPrice
|
|
|
|
address := common.HexToAddress(smartContractAddress)
|
|
contract, err := aggregator.NewSmartcontracts(address, c.HttpClient)
|
|
if err != nil {
|
|
c.Logger.Fatal(err)
|
|
}
|
|
|
|
tx, err := contract.CollectData(auth, reqID, data, callbackAddress, callbackMethodID)
|
|
if err != nil {
|
|
c.Logger.Fatal(err)
|
|
}
|
|
|
|
txHash := tx.Hash().Hex()
|
|
|
|
return txHash
|
|
}
|