deep-stack/ipld-eth-server
4
0
Fork 0
forked from cerc-io/ipld-eth-server
Code Pull Requests Activity

updates for light sync transactions

Browse Source
This commit is contained in:
Rob Mulholand
2019-03-28 14:31:17 -05:00
parent 79e011aad2
commit 54d46638a8
39 changed files with 769 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/geth/blockchain.go
+93 -67
View File
@@ -18,10 +18,11 @@ package geth
import (
"errors"
"fmt"
"github.com/ethereum/go-ethereum"
"math/big"
"strconv"
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/core/types"
@@ -37,20 +38,22 @@ var ErrEmptyHeader = errors.New("empty header returned over RPC")
const MAX_BATCH_SIZE = 100
type BlockChain struct {
blockConverter vulcCommon.BlockConverter
ethClient core.EthClient
headerConverter vulcCommon.HeaderConverter
node core.Node
rpcClient core.RpcClient
blockConverter vulcCommon.BlockConverter
ethClient core.EthClient
headerConverter vulcCommon.HeaderConverter
node core.Node
rpcClient core.RpcClient
transactionConverter vulcCommon.TransactionConverter
}
func NewBlockChain(ethClient core.EthClient, rpcClient core.RpcClient, node core.Node, converter vulcCommon.TransactionConverter) *BlockChain {
return &BlockChain{
blockConverter: vulcCommon.NewBlockConverter(converter),
ethClient: ethClient,
headerConverter: vulcCommon.HeaderConverter{},
node: node,
rpcClient: rpcClient,
blockConverter: vulcCommon.NewBlockConverter(converter),
ethClient: ethClient,
headerConverter: vulcCommon.HeaderConverter{},
node: node,
rpcClient: rpcClient,
transactionConverter: converter,
}
}
@@ -62,6 +65,14 @@ func (blockChain *BlockChain) GetBlockByNumber(blockNumber int64) (block core.Bl
return blockChain.blockConverter.ToCoreBlock(gethBlock)
}
func (blockChain *BlockChain) GetEthLogsWithCustomQuery(query ethereum.FilterQuery) ([]types.Log, error) {
gethLogs, err := blockChain.ethClient.FilterLogs(context.Background(), query)
if err != nil {
return []types.Log{}, err
}
return gethLogs, nil
}
func (blockChain *BlockChain) GetHeaderByNumber(blockNumber int64) (header core.Header, err error) {
if blockChain.node.NetworkID == core.KOVAN_NETWORK_ID {
return blockChain.getPOAHeader(blockNumber)
@@ -76,49 +87,55 @@ func (blockChain *BlockChain) GetHeaderByNumbers(blockNumbers []int64) (header [
return blockChain.getPOWHeaders(blockNumbers)
}
func (blockChain *BlockChain) getPOWHeader(blockNumber int64) (header core.Header, err error) {
gethHeader, err := blockChain.ethClient.HeaderByNumber(context.Background(), big.NewInt(blockNumber))
if err != nil {
return header, err
func (blockChain *BlockChain) GetLogs(contract core.Contract, startingBlockNumber, endingBlockNumber *big.Int) ([]core.Log, error) {
if endingBlockNumber == nil {
endingBlockNumber = startingBlockNumber
}
return blockChain.headerConverter.Convert(gethHeader, gethHeader.Hash().String()), nil
contractAddress := common.HexToAddress(contract.Hash)
fc := ethereum.FilterQuery{
FromBlock: startingBlockNumber,
ToBlock: endingBlockNumber,
Addresses: []common.Address{contractAddress},
Topics: nil,
}
gethLogs, err := blockChain.GetEthLogsWithCustomQuery(fc)
if err != nil {
return []core.Log{}, err
}
logs := vulcCommon.ToCoreLogs(gethLogs)
return logs, nil
}
func (blockChain *BlockChain) getPOWHeaders(blockNumbers []int64) (headers []core.Header, err error) {
func (blockChain *BlockChain) GetTransactions(transactionHashes []common.Hash) ([]core.TransactionModel, error) {
numTransactions := len(transactionHashes)
var batch []client.BatchElem
var POWHeaders [MAX_BATCH_SIZE]types.Header
includeTransactions := false
for index, blockNumber := range blockNumbers {
if index >= MAX_BATCH_SIZE {
break
}
blockNumberArg := hexutil.EncodeBig(big.NewInt(blockNumber))
transactions := make([]core.RpcTransaction, numTransactions)
for index, transactionHash := range transactionHashes {
batchElem := client.BatchElem{
Method: "eth_getBlockByNumber",
Result: &POWHeaders[index],
Args: []interface{}{blockNumberArg, includeTransactions},
Method: "eth_getTransactionByHash",
Result: &transactions[index],
Args: []interface{}{transactionHash},
}
batch = append(batch, batchElem)
}
err = blockChain.rpcClient.BatchCall(batch)
if err != nil {
return headers, err
rpcErr := blockChain.rpcClient.BatchCall(batch)
if rpcErr != nil {
fmt.Println("rpc err")
return []core.TransactionModel{}, rpcErr
}
for _, POWHeader := range POWHeaders {
if POWHeader.Number != nil {
header := blockChain.headerConverter.Convert(&POWHeader, POWHeader.Hash().String())
headers = append(headers, header)
}
}
return blockChain.transactionConverter.ConvertRpcTransactionsToModels(transactions)
}
return headers, err
func (blockChain *BlockChain) LastBlock() (*big.Int, error) {
block, err := blockChain.ethClient.HeaderByNumber(context.Background(), nil)
return block.Number, err
}
func (blockChain *BlockChain) Node() core.Node {
return blockChain.node
}
func (blockChain *BlockChain) getPOAHeader(blockNumber int64) (header core.Header, err error) {
@@ -204,38 +221,47 @@ func (blockChain *BlockChain) getPOAHeaders(blockNumbers []int64) (headers []cor
return headers, err
}
func (blockChain *BlockChain) GetLogs(contract core.Contract, startingBlockNumber, endingBlockNumber *big.Int) ([]core.Log, error) {
if endingBlockNumber == nil {
endingBlockNumber = startingBlockNumber
}
contractAddress := common.HexToAddress(contract.Hash)
fc := ethereum.FilterQuery{
FromBlock: startingBlockNumber,
ToBlock: endingBlockNumber,
Addresses: []common.Address{contractAddress},
Topics: nil,
}
gethLogs, err := blockChain.GetEthLogsWithCustomQuery(fc)
func (blockChain *BlockChain) getPOWHeader(blockNumber int64) (header core.Header, err error) {
gethHeader, err := blockChain.ethClient.HeaderByNumber(context.Background(), big.NewInt(blockNumber))
if err != nil {
return []core.Log{}, err
return header, err
}
logs := vulcCommon.ToCoreLogs(gethLogs)
return logs, nil
return blockChain.headerConverter.Convert(gethHeader, gethHeader.Hash().String()), nil
}
func (blockChain *BlockChain) GetEthLogsWithCustomQuery(query ethereum.FilterQuery) ([]types.Log, error) {
gethLogs, err := blockChain.ethClient.FilterLogs(context.Background(), query)
func (blockChain *BlockChain) getPOWHeaders(blockNumbers []int64) (headers []core.Header, err error) {
var batch []client.BatchElem
var POWHeaders [MAX_BATCH_SIZE]types.Header
includeTransactions := false
for index, blockNumber := range blockNumbers {
if index >= MAX_BATCH_SIZE {
break
}
blockNumberArg := hexutil.EncodeBig(big.NewInt(blockNumber))
batchElem := client.BatchElem{
Method: "eth_getBlockByNumber",
Result: &POWHeaders[index],
Args: []interface{}{blockNumberArg, includeTransactions},
}
batch = append(batch, batchElem)
}
err = blockChain.rpcClient.BatchCall(batch)
if err != nil {
return []types.Log{}, err
return headers, err
}
return gethLogs, nil
}
func (blockChain *BlockChain) LastBlock() (*big.Int, error) {
block, err := blockChain.ethClient.HeaderByNumber(context.Background(), nil)
return block.Number, err
}
for _, POWHeader := range POWHeaders {
if POWHeader.Number != nil {
header := blockChain.headerConverter.Convert(&POWHeader, POWHeader.Hash().String())
headers = append(headers, header)
}
}
func (blockChain *BlockChain) Node() core.Node {
return blockChain.node
return headers, err
}
pkg/geth/blockchain_test.go
+28 -12
View File
@@ -30,20 +30,23 @@ import (
vulcCore "github.com/vulcanize/vulcanizedb/pkg/core"
"github.com/vulcanize/vulcanizedb/pkg/fakes"
"github.com/vulcanize/vulcanizedb/pkg/geth"
"github.com/vulcanize/vulcanizedb/pkg/geth/converters/cold_db"
)
var _ = Describe("Geth blockchain", func() {
var mockClient *fakes.MockEthClient
var mockRpcClient *fakes.MockRpcClient
var node vulcCore.Node
var blockChain *geth.BlockChain
var (
mockClient *fakes.MockEthClient
blockChain *geth.BlockChain
mockRpcClient *fakes.MockRpcClient
mockTransactionConverter *fakes.MockTransactionConverter
node vulcCore.Node
)
BeforeEach(func() {
mockClient = fakes.NewMockEthClient()
mockRpcClient = fakes.NewMockRpcClient()
mockTransactionConverter = fakes.NewMockTransactionConverter()
node = vulcCore.Node{}
blockChain = geth.NewBlockChain(mockClient, mockRpcClient, node, cold_db.NewColdDbTransactionConverter())
blockChain = geth.NewBlockChain(mockClient, mockRpcClient, node, mockTransactionConverter)
})
Describe("getting a block", func() {
@@ -89,8 +92,6 @@ var _ = Describe("Geth blockchain", func() {
})
It("fetches headers with multiple blocks", func() {
blockChain = geth.NewBlockChain(mockClient, mockRpcClient, node, cold_db.NewColdDbTransactionConverter())
_, err := blockChain.GetHeaderByNumbers([]int64{100, 99})
Expect(err).NotTo(HaveOccurred())
@@ -103,7 +104,7 @@ var _ = Describe("Geth blockchain", func() {
node.NetworkID = vulcCore.KOVAN_NETWORK_ID
blockNumber := hexutil.Big(*big.NewInt(100))
mockRpcClient.SetReturnPOAHeader(vulcCore.POAHeader{Number: &blockNumber})
blockChain = geth.NewBlockChain(mockClient, mockRpcClient, node, cold_db.NewColdDbTransactionConverter())
blockChain = geth.NewBlockChain(mockClient, mockRpcClient, node, fakes.NewMockTransactionConverter())
_, err := blockChain.GetHeaderByNumber(100)
@@ -114,7 +115,7 @@ var _ = Describe("Geth blockchain", func() {
It("returns err if rpcClient returns err", func() {
node.NetworkID = vulcCore.KOVAN_NETWORK_ID
mockRpcClient.SetCallContextErr(fakes.FakeError)
blockChain = geth.NewBlockChain(mockClient, mockRpcClient, node, cold_db.NewColdDbTransactionConverter())
blockChain = geth.NewBlockChain(mockClient, mockRpcClient, node, fakes.NewMockTransactionConverter())
_, err := blockChain.GetHeaderByNumber(100)
@@ -124,7 +125,7 @@ var _ = Describe("Geth blockchain", func() {
It("returns error if returned header is empty", func() {
node.NetworkID = vulcCore.KOVAN_NETWORK_ID
blockChain = geth.NewBlockChain(mockClient, mockRpcClient, node, cold_db.NewColdDbTransactionConverter())
blockChain = geth.NewBlockChain(mockClient, mockRpcClient, node, fakes.NewMockTransactionConverter())
_, err := blockChain.GetHeaderByNumber(100)
@@ -136,7 +137,6 @@ var _ = Describe("Geth blockchain", func() {
node.NetworkID = vulcCore.KOVAN_NETWORK_ID
blockNumber := hexutil.Big(*big.NewInt(100))
mockRpcClient.SetReturnPOAHeaders([]vulcCore.POAHeader{{Number: &blockNumber}})
blockChain = geth.NewBlockChain(mockClient, mockRpcClient, node, cold_db.NewColdDbTransactionConverter())
_, err := blockChain.GetHeaderByNumbers([]int64{100, 99})
@@ -216,6 +216,22 @@ var _ = Describe("Geth blockchain", func() {
})
})
Describe("getting transactions", func() {
It("fetches transaction for each hash", func() {
_, err := blockChain.GetTransactions([]common.Hash{{}, {}})
Expect(err).NotTo(HaveOccurred())
mockRpcClient.AssertBatchCalledWith("eth_getTransactionByHash", 2)
})
It("converts transaction indexes from hex to int", func() {
_, err := blockChain.GetTransactions([]common.Hash{{}, {}})
Expect(err).NotTo(HaveOccurred())
Expect(mockTransactionConverter.ConvertHeaderTransactionIndexToIntCalled).To(BeTrue())
})
})
Describe("getting the most recent block number", func() {
It("fetches latest header from ethClient", func() {
blockNumber := int64(100)
pkg/geth/cold_import/importer_test.go
+2 -1
View File
@@ -81,7 +81,8 @@ var _ = Describe("Geth cold importer", func() {
mockEthereumDatabase.AssertGetBlockHashCalledWith(blockNumber)
mockEthereumDatabase.AssertGetBlockCalledWith(fakeHash, blockNumber)
mockTransactionConverter.AssertConvertTransactionsToCoreCalledWith(fakeGethBlock)
Expect(mockTransactionConverter.ConvertBlockTransactionsToCoreCalled).To(BeTrue())
Expect(mockTransactionConverter.ConvertBlockTransactionsToCorePassedBlock).To(Equal(fakeGethBlock))
convertedBlock, err := blockConverter.ToCoreBlock(fakeGethBlock)
Expect(err).NotTo(HaveOccurred())
mockBlockRepository.AssertCreateOrUpdateBlockCalledWith(convertedBlock)
pkg/geth/converters/cold_db/transaction_converter.go
+9 -7
View File
@@ -18,7 +18,6 @@ package cold_db
import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/core/types"
"github.com/vulcanize/vulcanizedb/pkg/core"
"golang.org/x/sync/errgroup"
@@ -31,9 +30,9 @@ func NewColdDbTransactionConverter() *ColdDbTransactionConverter {
return &ColdDbTransactionConverter{}
}
func (cdtc *ColdDbTransactionConverter) ConvertTransactionsToCore(gethBlock *types.Block) ([]core.Transaction, error) {
func (cdtc *ColdDbTransactionConverter) ConvertBlockTransactionsToCore(gethBlock *types.Block) ([]core.TransactionModel, error) {
var g errgroup.Group
coreTransactions := make([]core.Transaction, len(gethBlock.Transactions()))
coreTransactions := make([]core.TransactionModel, len(gethBlock.Transactions()))
for gethTransactionIndex, gethTransaction := range gethBlock.Transactions() {
transaction := gethTransaction
@@ -55,6 +54,10 @@ func (cdtc *ColdDbTransactionConverter) ConvertTransactionsToCore(gethBlock *typ
return coreTransactions, nil
}
func (cdtc *ColdDbTransactionConverter) ConvertRpcTransactionsToModels(transactions []core.RpcTransaction) ([]core.TransactionModel, error) {
panic("converting transaction indexes to integer not supported for cold import")
}
func getSigner(tx *types.Transaction) types.Signer {
v, _, _ := tx.RawSignatureValues()
if v.Sign() != 0 && tx.Protected() {
@@ -63,9 +66,8 @@ func getSigner(tx *types.Transaction) types.Signer {
return types.HomesteadSigner{}
}
func transToCoreTrans(transaction *types.Transaction, from *common.Address) core.Transaction {
data := hexutil.Encode(transaction.Data())
return core.Transaction{
func transToCoreTrans(transaction *types.Transaction, from *common.Address) core.TransactionModel {
return core.TransactionModel{
Hash: transaction.Hash().Hex(),
Nonce: transaction.Nonce(),
To: strings.ToLower(addressToHex(transaction.To())),
@@ -73,7 +75,7 @@ func transToCoreTrans(transaction *types.Transaction, from *common.Address) core
GasLimit: transaction.Gas(),
GasPrice: transaction.GasPrice().Int64(),
Value: transaction.Value().String(),
Data: data,
Data: transaction.Data(),
}
}
pkg/geth/converters/common/block_converter.go
+1 -1
View File
@@ -32,7 +32,7 @@ func NewBlockConverter(transactionConverter TransactionConverter) BlockConverter
}
func (bc BlockConverter) ToCoreBlock(gethBlock *types.Block) (core.Block, error) {
transactions, err := bc.transactionConverter.ConvertTransactionsToCore(gethBlock)
transactions, err := bc.transactionConverter.ConvertBlockTransactionsToCore(gethBlock)
if err != nil {
return core.Block{}, err
}
pkg/geth/converters/common/block_converter_test.go
+2 -1
View File
@@ -260,7 +260,8 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
Expect(err).ToNot(HaveOccurred())
Expect(len(coreBlock.Transactions)).To(Equal(1))
coreTransaction := coreBlock.Transactions[0]
Expect(coreTransaction.Data).To(Equal("0xf7d8c8830000000000000000000000000000000000000000000000000000000000037788000000000000000000000000000000000000000000000000000000000003bd14"))
expectedData := common.FromHex("0xf7d8c8830000000000000000000000000000000000000000000000000000000000037788000000000000000000000000000000000000000000000000000000000003bd14")
Expect(coreTransaction.Data).To(Equal(expectedData))
Expect(coreTransaction.To).To(Equal(gethTransaction.To().Hex()))
Expect(coreTransaction.From).To(Equal("0x0000000000000000000000000000000000000123"))
Expect(coreTransaction.GasLimit).To(Equal(gethTransaction.Gas()))
pkg/geth/converters/common/transaction_converter.go
+2 -1
View File
@@ -22,5 +22,6 @@ import (
)
type TransactionConverter interface {
ConvertTransactionsToCore(gethBlock *types.Block) ([]core.Transaction, error)
ConvertBlockTransactionsToCore(gethBlock *types.Block) ([]core.TransactionModel, error)
ConvertRpcTransactionsToModels(transactions []core.RpcTransaction) ([]core.TransactionModel, error)
}
pkg/geth/converters/rpc/rpc_suite_test.go
+13
View File
@@ -0,0 +1,13 @@
package rpc_test
import (
"testing"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
func TestRpc(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Rpc Suite")
}
pkg/geth/converters/rpc/transaction_converter.go
+121 -13
View File
@@ -19,11 +19,13 @@ package rpc
import (
"bytes"
"context"
"fmt"
"log"
"math/big"
"strings"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/core/types"
"golang.org/x/sync/errgroup"
@@ -35,29 +37,75 @@ type RpcTransactionConverter struct {
client core.EthClient
}
// raw transaction data, required for generating RLP
type transactionData struct {
AccountNonce uint64
Price *big.Int
GasLimit uint64
Recipient *common.Address `rlp:"nil"` // nil means contract creation
Amount *big.Int
Payload []byte
V *big.Int
R *big.Int
S *big.Int
}
func NewRpcTransactionConverter(client core.EthClient) *RpcTransactionConverter {
return &RpcTransactionConverter{client: client}
}
func (rtc *RpcTransactionConverter) ConvertTransactionsToCore(gethBlock *types.Block) ([]core.Transaction, error) {
func (converter *RpcTransactionConverter) ConvertRpcTransactionsToModels(transactions []core.RpcTransaction) ([]core.TransactionModel, error) {
var results []core.TransactionModel
for _, transaction := range transactions {
txData, convertErr := getTransactionData(transaction)
if convertErr != nil {
return nil, convertErr
}
txRLP, rlpErr := getTransactionRLP(txData)
if rlpErr != nil {
return nil, rlpErr
}
txIndex, txIndexErr := hexToBigInt(transaction.TransactionIndex)
if txIndexErr != nil {
return nil, txIndexErr
}
transactionModel := core.TransactionModel{
Data: transaction.Payload,
From: transaction.From,
GasLimit: txData.GasLimit,
GasPrice: txData.Price.Int64(),
Hash: transaction.Hash,
Nonce: txData.AccountNonce,
Raw: txRLP,
// NOTE: Light Sync transactions don't include receipt; would require separate RPC call
To: transaction.Recipient,
TxIndex: txIndex.Int64(),
Value: txData.Amount.String(),
}
results = append(results, transactionModel)
}
return results, nil
}
func (converter *RpcTransactionConverter) ConvertBlockTransactionsToCore(gethBlock *types.Block) ([]core.TransactionModel, error) {
var g errgroup.Group
coreTransactions := make([]core.Transaction, len(gethBlock.Transactions()))
coreTransactions := make([]core.TransactionModel, len(gethBlock.Transactions()))
for gethTransactionIndex, gethTransaction := range gethBlock.Transactions() {
//https://golang.org/doc/faq#closures_and_goroutines
transaction := gethTransaction
transactionIndex := uint(gethTransactionIndex)
g.Go(func() error {
from, err := rtc.client.TransactionSender(context.Background(), transaction, gethBlock.Hash(), transactionIndex)
from, err := converter.client.TransactionSender(context.Background(), transaction, gethBlock.Hash(), transactionIndex)
if err != nil {
log.Println("transaction sender: ", err)
return err
}
coreTransaction, convertErr := transToCoreTrans(transaction, &from, int64(gethTransactionIndex))
coreTransaction, convertErr := convertGethTransactionToModel(transaction, &from, int64(gethTransactionIndex))
if convertErr != nil {
return convertErr
}
coreTransaction, err = rtc.appendReceiptToTransaction(coreTransaction)
coreTransaction, err = converter.appendReceiptToTransaction(coreTransaction)
if err != nil {
log.Println("receipt: ", err)
return err
@@ -73,7 +121,7 @@ func (rtc *RpcTransactionConverter) ConvertTransactionsToCore(gethBlock *types.B
return coreTransactions, nil
}
func (rtc *RpcTransactionConverter) appendReceiptToTransaction(transaction core.Transaction) (core.Transaction, error) {
func (rtc *RpcTransactionConverter) appendReceiptToTransaction(transaction core.TransactionModel) (core.TransactionModel, error) {
gethReceipt, err := rtc.client.TransactionReceipt(context.Background(), common.HexToHash(transaction.Hash))
if err != nil {
return transaction, err
@@ -83,15 +131,14 @@ func (rtc *RpcTransactionConverter) appendReceiptToTransaction(transaction core.
return transaction, nil
}
func transToCoreTrans(transaction *types.Transaction, from *common.Address, transactionIndex int64) (core.Transaction, error) {
data := hexutil.Encode(transaction.Data())
var raw bytes.Buffer
func convertGethTransactionToModel(transaction *types.Transaction, from *common.Address, transactionIndex int64) (core.TransactionModel, error) {
raw := bytes.Buffer{}
encodeErr := transaction.EncodeRLP(&raw)
if encodeErr != nil {
return core.Transaction{}, encodeErr
return core.TransactionModel{}, encodeErr
}
return core.Transaction{
Data: data,
return core.TransactionModel{
Data: transaction.Data(),
From: strings.ToLower(addressToHex(from)),
GasLimit: transaction.Gas(),
GasPrice: transaction.GasPrice().Int64(),
@@ -104,9 +151,70 @@ func transToCoreTrans(transaction *types.Transaction, from *common.Address, tran
}, nil
}
func getTransactionData(transaction core.RpcTransaction) (transactionData, error) {
nonce, nonceErr := hexToBigInt(transaction.Nonce)
if nonceErr != nil {
return transactionData{}, nonceErr
}
gasPrice, gasPriceErr := hexToBigInt(transaction.GasPrice)
if gasPriceErr != nil {
return transactionData{}, gasPriceErr
}
gasLimit, gasLimitErr := hexToBigInt(transaction.GasLimit)
if gasLimitErr != nil {
return transactionData{}, gasLimitErr
}
recipient := common.HexToAddress(transaction.Recipient)
amount, amountErr := hexToBigInt(transaction.Amount)
if amountErr != nil {
return transactionData{}, amountErr
}
v, vErr := hexToBigInt(transaction.V)
if vErr != nil {
return transactionData{}, vErr
}
r, rErr := hexToBigInt(transaction.R)
if rErr != nil {
return transactionData{}, rErr
}
s, sErr := hexToBigInt(transaction.S)
if sErr != nil {
return transactionData{}, sErr
}
return transactionData{
AccountNonce: nonce.Uint64(),
Price: gasPrice,
GasLimit: gasLimit.Uint64(),
Recipient: &recipient,
Amount: amount,
Payload: transaction.Payload,
V: v,
R: r,
S: s,
}, nil
}
func getTransactionRLP(txData transactionData) ([]byte, error) {
transactionRlp := bytes.Buffer{}
encodeErr := rlp.Encode(&transactionRlp, txData)
if encodeErr != nil {
return nil, encodeErr
}
return transactionRlp.Bytes(), nil
}
func addressToHex(to *common.Address) string {
if to == nil {
return ""
}
return to.Hex()
}
func hexToBigInt(hex string) (*big.Int, error) {
result := big.NewInt(0)
_, scanErr := fmt.Sscan(hex, result)
if scanErr != nil {
return nil, scanErr
}
return result, nil
}
pkg/geth/converters/rpc/transaction_converter_test.go
+82
View File
@@ -0,0 +1,82 @@
package rpc_test
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/vulcanize/vulcanizedb/pkg/core"
"github.com/vulcanize/vulcanizedb/pkg/fakes"
"github.com/vulcanize/vulcanizedb/pkg/geth/converters/rpc"
)
var _ = Describe("RPC transaction converter", func() {
It("converts hex fields to integers", func() {
converter := rpc.RpcTransactionConverter{}
rpcTransaction := getFakeRpcTransaction("0x1")
transactionModels, err := converter.ConvertRpcTransactionsToModels([]core.RpcTransaction{rpcTransaction})
Expect(err).NotTo(HaveOccurred())
Expect(len(transactionModels)).To(Equal(1))
Expect(transactionModels[0].GasLimit).To(Equal(uint64(1)))
Expect(transactionModels[0].GasPrice).To(Equal(int64(1)))
Expect(transactionModels[0].Nonce).To(Equal(uint64(1)))
Expect(transactionModels[0].TxIndex).To(Equal(int64(1)))
Expect(transactionModels[0].Value).To(Equal("1"))
})
It("returns error if invalid hex cannot be converted", func() {
converter := rpc.RpcTransactionConverter{}
invalidTransaction := getFakeRpcTransaction("invalid")
_, err := converter.ConvertRpcTransactionsToModels([]core.RpcTransaction{invalidTransaction})
Expect(err).To(HaveOccurred())
})
It("copies RPC transaction hash, from, and to values to model", func() {
converter := rpc.RpcTransactionConverter{}
rpcTransaction := getFakeRpcTransaction("0x1")
transactionModels, err := converter.ConvertRpcTransactionsToModels([]core.RpcTransaction{rpcTransaction})
Expect(err).NotTo(HaveOccurred())
Expect(len(transactionModels)).To(Equal(1))
Expect(transactionModels[0].Hash).To(Equal(rpcTransaction.Hash))
Expect(transactionModels[0].From).To(Equal(rpcTransaction.From))
Expect(transactionModels[0].To).To(Equal(rpcTransaction.Recipient))
})
XIt("derives transaction RLP", func() {
// actual transaction: https://kovan.etherscan.io/tx/0x73aefdf70fc5650e0dd82affbb59d107f12dfabc50a78625b434ea68b7a69ee6
// actual RLP hex: 0x2926af093b6b72e3f10089bde6da0f99b0d4e13354f6f37c8334efc9d7e99a47
})
It("does not include transaction receipt", func() {
converter := rpc.RpcTransactionConverter{}
rpcTransaction := getFakeRpcTransaction("0x1")
transactionModels, err := converter.ConvertRpcTransactionsToModels([]core.RpcTransaction{rpcTransaction})
Expect(err).NotTo(HaveOccurred())
Expect(len(transactionModels)).To(Equal(1))
Expect(transactionModels[0].Receipt).To(Equal(core.Receipt{}))
})
})
func getFakeRpcTransaction(hex string) core.RpcTransaction {
return core.RpcTransaction{
Hash: "0x2",
Amount: hex,
GasLimit: hex,
GasPrice: hex,
Nonce: hex,
From: fakes.FakeAddress.Hex(),
Recipient: fakes.FakeAddress.Hex(),
V: "0x2",
R: "0x2",
S: "0x2",
Payload: nil,
TransactionIndex: hex,
}
}