tx from

contracts/utils.go

@@ -86,8 +86,7 @@ func CreateTransactionSign(chainConfig *params.ChainConfig, pool *core.TxPool, m
 		// Add tx signed to local tx pool.
 		err = pool.AddLocal(txSigned)
 		if err != nil {
-			log.Error("Fail to add tx sign to local pool.", "error", err, "number", block.NumberU64(), "hash", block.Hash().Hex(), "from", account.Address, "nonce", nonce)
+			log.Warn("Fail to add tx sign to local pool.", "error", err, "number", block.NumberU64(), "hash", block.Hash().Hex(), "from", account.Address, "nonce", nonce)
-			return err
 		}
 
 		// Create secret tx.
@@ -116,7 +115,6 @@ func CreateTransactionSign(chainConfig *params.ChainConfig, pool *core.TxPool, m
 			err = pool.AddLocal(txSigned)
 			if err != nil {
 				log.Error("Fail to add tx secret to local pool.", "error", err, "number", block.NumberU64(), "hash", block.Hash().Hex(), "from", account.Address, "nonce", nonce)
-				return err
 			}
 
 			// Put randomize key into chainDb.
@@ -128,7 +126,6 @@ func CreateTransactionSign(chainConfig *params.ChainConfig, pool *core.TxPool, m
 			randomizeKeyValue, err := chainDb.Get(randomizeKeyName)
 			if err != nil {
 				log.Error("Fail to get randomize key from state db.", "error", err)
-				return err
 			}
 
 			tx, err := BuildTxOpeningRandomize(nonce+1, common.HexToAddress(common.RandomizeSMC), randomizeKeyValue)
@@ -145,7 +142,6 @@ func CreateTransactionSign(chainConfig *params.ChainConfig, pool *core.TxPool, m
 			err = pool.AddLocal(txSigned)
 			if err != nil {
 				log.Error("Fail to add tx opening to local pool.", "error", err, "number", block.NumberU64(), "hash", block.Hash().Hex(), "from", account.Address, "nonce", nonce)
-				return err
 			}
 
 			// Clear randomize key in state db.
@@ -221,18 +217,15 @@ func GetRandomizeFromContract(client bind.ContractBackend, addrMasternode common
 	randomize, err := randomizeContract.NewTomoRandomize(common.HexToAddress(common.RandomizeSMC), client)
 	if err != nil {
 		log.Error("Fail to get instance of randomize", "error", err)
-		return -1, err
 	}
 	opts := new(bind.CallOpts)
 	secrets, err := randomize.GetSecret(opts, addrMasternode)
 	if err != nil {
 		log.Error("Fail get secrets from randomize", "error", err)
-		return -1, err
 	}
 	opening, err := randomize.GetOpening(opts, addrMasternode)
 	if err != nil {
 		log.Error("Fail get opening from randomize", "error", err)
-		return -1, err
 	}
 
 	return DecryptRandomizeFromSecretsAndOpening(secrets, opening)
@@ -297,7 +290,6 @@ func DecryptRandomizeFromSecretsAndOpening(secrets [][32]byte, opening [32]byte)
 				intNumber, err := strconv.Atoi(decryptSecret)
 				if err != nil {
 					log.Error("Can not convert string to integer", "error", err)
-					return -1, err
 				}
 				random = int64(intNumber)
 			}
@@ -319,56 +311,56 @@ func GetRewardForCheckpoint(chain consensus.ChainReader, blockSignerAddr common.
 
 	if len(masternodes) > 0 {
 
-        var wg sync.WaitGroup
+		var wg sync.WaitGroup
-        squeue := make(chan []common.Address, 1)
+		squeue := make(chan []common.Address, 1)
-        wg.Add(900)
+		wg.Add(900)
 
 		for i := startBlockNumber; i <= endBlockNumber; i++ {
-            go func(i uint64) {
+			go func(i uint64) {
-                block := chain.GetHeaderByNumber(i)
+				block := chain.GetHeaderByNumber(i)
-                addrs, err := GetSignersFromContract(blockSignerAddr, client, block.Hash())
+				addrs, err := GetSignersFromContract(blockSignerAddr, client, block.Hash())
-                if err != nil {
+				if err != nil {
-                    log.Crit("Fail to get signers from smartcontract.", "error", err, "blockNumber", i)
+					log.Crit("Fail to get signers from smartcontract.", "error", err, "blockNumber", i)
-                    // return nil, err
+					// return nil, err
-                }
+				}
-                squeue <- addrs
+				squeue <- addrs
-            }(i)
+			}(i)
-        }
+		}
 
-        fsigner := func() {
+		fsigner := func() {
-            for addrs := range squeue {
+			for addrs := range squeue {
-                // Filter duplicate address.
+				// Filter duplicate address.
-                if len(addrs) > 0 {
+				if len(addrs) > 0 {
-                    addrSigners := make(map[common.Address]bool)
+					addrSigners := make(map[common.Address]bool)
-                    for _, masternode := range masternodes {
+					for _, masternode := range masternodes {
-                        for _, addr := range addrs {
+						for _, addr := range addrs {
-                            if addr == masternode {
+							if addr == masternode {
-                                if _, ok := addrSigners[addr]; !ok {
+								if _, ok := addrSigners[addr]; !ok {
-                                    addrSigners[addr] = true
+									addrSigners[addr] = true
-                                }
+								}
-                                break
+								break
-                            }
+							}
-                        }
+						}
-                    }
+					}
 
-                    for addr := range addrSigners {
+					for addr := range addrSigners {
-                        _, exist := signers[addr]
+						_, exist := signers[addr]
-                        if exist {
+						if exist {
-                            signers[addr].Sign++
+							signers[addr].Sign++
-                        } else {
+						} else {
-                            signers[addr] = &rewardLog{1, new(big.Int)}
+							signers[addr] = &rewardLog{1, new(big.Int)}
-                        }
+						}
-                        *totalSigner++
+						*totalSigner++
-                    }
+					}
-                }
+				}
-                wg.Done()
+				wg.Done()
-            }
+			}
-        }
+		}
 
-        go fsigner()
+		go fsigner()
 
-        wg.Wait()
+		wg.Wait()
-        fmt.Println("totalSigner", *totalSigner)
+		fmt.Println("totalSigner", *totalSigner)
 	}
 
 	log.Info("Calculate reward at checkpoint", "startBlock", startBlockNumber, "endBlock", endBlockNumber)

core/types/transaction.go

@@ -195,6 +195,19 @@ func (tx *Transaction) To() *common.Address {
 	return &to
 }
 
+func (tx *Transaction) From() *common.Address {
+	if tx.data.V != nil {
+		signer := deriveSigner(tx.data.V)
+		if f, err := Sender(signer, tx); err != nil {
+			return nil
+		} else {
+			return &f
+		}
+	} else {
+		return nil
+	}
+}
+
 // Hash hashes the RLP encoding of tx.
 // It uniquely identifies the transaction.
 func (tx *Transaction) Hash() common.Hash {
@@ -274,6 +287,13 @@ func (tx *Transaction) IsSpecialTransaction() bool {
 	return tx.To().String() == common.RandomizeSMC || tx.To().String() == common.BlockSigners
 }
 
+func (tx *Transaction) IsSigningTransaction() bool {
+	if tx.To() == nil {
+		return false
+	}
+	return tx.To().String() == common.BlockSigners
+}
+
 func (tx *Transaction) String() string {
 	var from, to string
 	if tx.data.V != nil {