From 49559e6d5e7c365f1aa081e94cb46f3483833647 Mon Sep 17 00:00:00 2001
From: "Daniel A. Nagy" <nagy.da@gmail.com>
Date: Mon, 11 May 2015 15:46:18 +0200
Subject: [PATCH] Interactive signature creation refactored into separate
 doSign function.

---
 xeth/xeth.go | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/xeth/xeth.go b/xeth/xeth.go
index 06cd9dc1b..76ca4b9b4 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -815,22 +815,30 @@ func (self *XEth) ConfirmTransaction(tx string) bool {
 	return self.frontend.ConfirmTransaction(tx)
 }
 
+func (self *XEth) doSign(from common.Address, hash []byte, didUnlock bool) ([]byte, error) {
+	sig, err := self.backend.AccountManager().Sign(accounts.Account{Address: from.Bytes()}, hash)
+	if err == accounts.ErrLocked {
+		if didUnlock {
+			return nil, fmt.Errorf("signer account still locked after successful unlock")
+		}
+		if !self.frontend.UnlockAccount(from.Bytes()) {
+			return nil, fmt.Errorf("could not unlock signer account")
+		}
+		// retry signing, the account should now be unlocked.
+		return self.doSign(from, hash, true)
+	} else if err != nil {
+		return nil, err
+	}
+	return sig, nil
+}
+
 func (self *XEth) Sign(fromStr, hashStr string, didUnlock bool) (string, error) {
 	var (
 		from = common.HexToAddress(fromStr)
 		hash = common.HexToHash(hashStr)
 	)
-	sig, err := self.backend.AccountManager().Sign(accounts.Account{Address: from.Bytes()}, hash.Bytes())
-	if err == accounts.ErrLocked {
-		if didUnlock {
-			return "", fmt.Errorf("signer account still locked after successful unlock")
-		}
-		if !self.frontend.UnlockAccount(from.Bytes()) {
-			return "", fmt.Errorf("could not unlock signer account")
-		}
-		// retry signing, the account should now be unlocked.
-		return self.Sign(fromStr, hashStr, true)
-	} else if err != nil {
+	sig, err := self.doSign(from, hash.Bytes(), didUnlock)
+	if err != nil {
 		return "", err
 	}
 	return common.ToHex(sig), nil
@@ -928,17 +936,9 @@ func (self *XEth) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceS
 }
 
 func (self *XEth) sign(tx *types.Transaction, from common.Address, didUnlock bool) error {
-	sig, err := self.backend.AccountManager().Sign(accounts.Account{Address: from.Bytes()}, tx.Hash().Bytes())
-	if err == accounts.ErrLocked {
-		if didUnlock {
-			return fmt.Errorf("sender account still locked after successful unlock")
-		}
-		if !self.frontend.UnlockAccount(from.Bytes()) {
-			return fmt.Errorf("could not unlock sender account")
-		}
-		// retry signing, the account should now be unlocked.
-		return self.sign(tx, from, true)
-	} else if err != nil {
+	hash := tx.Hash().Bytes()
+	sig, err := self.doSign(from, hash, didUnlock)
+	if err != nil {
 		return err
 	}
 	tx.SetSignatureValues(sig)