Add cold import script

pkg/geth/converters/rpc/transaction_converter.go

@@ -0,0 +1,90 @@
+package rpc
+
+import (
+	"context"
+	"log"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/types"
+	"golang.org/x/sync/errgroup"
+
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	vulcCommon "github.com/vulcanize/vulcanizedb/pkg/geth/converters/common"
+)
+
+type Client interface {
+	TransactionSender(ctx context.Context, tx *types.Transaction, block common.Hash, index uint) (common.Address, error)
+	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
+}
+
+type RpcTransactionConverter struct {
+	client Client
+}
+
+func NewRpcTransactionConverter(client Client) *RpcTransactionConverter {
+	return &RpcTransactionConverter{client: client}
+}
+
+func (rtc *RpcTransactionConverter) ConvertTransactionsToCore(gethBlock *types.Block) ([]core.Transaction, error) {
+	var g errgroup.Group
+	coreTransactions := make([]core.Transaction, 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)
+			if err != nil {
+				log.Println("transaction sender: ", err)
+				return err
+			}
+			coreTransaction := transToCoreTrans(transaction, &from)
+			coreTransaction, err = appendReceiptToTransaction(rtc.client, coreTransaction)
+			if err != nil {
+				log.Println("receipt: ", err)
+				return err
+			}
+			coreTransactions[transactionIndex] = coreTransaction
+			return nil
+		})
+	}
+	if err := g.Wait(); err != nil {
+		log.Println("transactions: ", err)
+		return coreTransactions, err
+	}
+	return coreTransactions, nil
+}
+
+func appendReceiptToTransaction(client Client, transaction core.Transaction) (core.Transaction, error) {
+	gethReceipt, err := client.TransactionReceipt(context.Background(), common.HexToHash(transaction.Hash))
+	if err != nil {
+		return transaction, err
+	}
+	receipt := vulcCommon.ToCoreReceipt(gethReceipt)
+	transaction.Receipt = receipt
+	return transaction, nil
+}
+
+func transToCoreTrans(transaction *types.Transaction, from *common.Address) core.Transaction {
+	data := hexutil.Encode(transaction.Data())
+	return core.Transaction{
+		Hash:     transaction.Hash().Hex(),
+		Nonce:    transaction.Nonce(),
+		To:       strings.ToLower(addressToHex(transaction.To())),
+		From:     strings.ToLower(addressToHex(from)),
+		GasLimit: transaction.Gas(),
+		GasPrice: transaction.GasPrice().Int64(),
+		Value:    transaction.Value().String(),
+		Data:     data,
+	}
+}
+
+func addressToHex(to *common.Address) string {
+	if to == nil {
+		return ""
+	}
+	return to.Hex()
+}