delete some comments

diff --git a/account/accounts.go b/account/accounts.go
index 4198cbf..16240a9 100644 (file)
--- a/account/accounts.go
+++ b/account/accounts.go
@@ -3,7 +3,6 @@ package account
 
 import (
        "encoding/json"
-       "fmt"
        "reflect"
        "sort"
        "strings"
@@ -417,7 +416,6 @@ func (m *Manager) FindByAlias(alias string) (*Account, error) {
 
 // FindByID returns an account's Signer record by its ID.
 func (m *Manager) FindByID(id string) (*Account, error) {
-       fmt.Println("FindByID start...")
        m.cacheMu.Lock()
        cachedAccount, ok := m.cache.Get(id)
        m.cacheMu.Unlock()
@@ -436,19 +434,16 @@ func (m *Manager) FindByID(id string) (*Account, error) {
        }
        for i, xpub := range account.XPubs {
                if reflect.TypeOf(xpub).String() == "string" {
-                       // fmt.Println("account xpubs type:", reflect.TypeOf(xpub).String())
                        if xpb, err := edchainkd.NewXPub(reflect.ValueOf(xpub).String()); err != nil {
                                panic(err)
                        } else {
                                account.XPubs[i] = *xpb
                        }
-                       fmt.Println("account xpubs type:", reflect.TypeOf(account.XPubs[i]).String())
                }
        }
 
        m.cacheMu.Lock()
        m.cache.Add(id, account)
-       fmt.Println("FindByID m.cache...", m.cache)
        m.cacheMu.Unlock()
        return account, nil
 }
@@ -691,11 +686,8 @@ func CreateCtrlProgram(account *Account, addrIdx uint64, change bool) (cp *CtrlP
 }
 
 func createP2PKH(account *Account, path [][]byte) (*CtrlProgram, error) {
-       fmt.Println("createP2PKH account.XPubs is:", account.XPubs)
        derivedXPubs := csp.DeriveXPubs(account.XPubs, path)
-       fmt.Println("createP2PKH derivedXPubs is:", derivedXPubs)
        pubHash := make([]byte, 0)
-       fmt.Println("createP2PKH len(derivedXPubs) is:", len(derivedXPubs))
        if len(derivedXPubs) == 0 {
                return nil, errors.New("no derived XPub.")
        }
@@ -704,7 +696,6 @@ func createP2PKH(account *Account, path [][]byte) (*CtrlProgram, error) {
                derivedPK := dxpub.PublicKey()
                pubHash = crypto.Ripemd160(derivedPK)
        }
-       fmt.Println("createP2PKH ...")
 
        address, err := common.NewAddressWitnessPubKeyHash(pubHash, &consensus.ActiveNetParams)
        if err != nil {

diff --git a/account/builder.go b/account/builder.go
index 18e2a09..20b12df 100644 (file)
--- a/account/builder.go
+++ b/account/builder.go
@@ -2,10 +2,7 @@ package account
 
 import (
        "context"
-       "encoding/hex"
        stdjson "encoding/json"
-       "fmt"
-       "reflect"
 
        "github.com/vapor/blockchain/signers"
        "github.com/vapor/blockchain/txbuilder"
@@ -313,7 +310,6 @@ func (a *spendUTXOAction) Build(ctx context.Context, b *txbuilder.TemplateBuilde
 
 // UtxoToInputs convert an utxo to the txinput
 func UtxoToInputs(signer *signers.Signer, u *UTXO) (*types.TxInput, *txbuilder.SigningInstruction, error) {
-       fmt.Println("UtxoToInputs...")
        txInput := types.NewSpendInput(nil, u.SourceID, u.AssetID, u.Amount, u.SourcePos, u.ControlProgram)
        sigInst := &txbuilder.SigningInstruction{}
        if signer == nil {
@@ -333,39 +329,27 @@ func UtxoToInputs(signer *signers.Signer, u *UTXO) (*types.TxInput, *txbuilder.S
        if err != nil {
                return nil, nil, err
        }
-       fmt.Println("UtxoToInputs...will sigInst.AddRawWitnessKeys")
        sigInst.AddRawWitnessKeys(signer.XPubs, path, signer.Quorum)
        derivedXPubs := csp.DeriveXPubs(signer.XPubs, path)
-       fmt.Println("UtxoToInputs...finish derivedXPubs := csp.DeriveXPubs(signer.XPubs, path)")
-       fmt.Println("UtxoToInputs derivedXPubs:", derivedXPubs)
-       fmt.Println("UtxoToInputs derivedXPubs[0] type:", reflect.TypeOf(derivedXPubs[0]))
 
-       //
        if len(derivedXPubs) == 0 {
                panic("UtxoToInputs derivedXPubs is nil.")
        }
 
        switch address.(type) {
        case *common.AddressWitnessPubKeyHash:
-               fmt.Println("UtxoToInputs  *common.AddressWitnessPubKeyHash...")
                switch dxpub := derivedXPubs[0].(type) {
                case edchainkd.XPub:
-                       fmt.Println("UtxoToInputs dxpub", hex.EncodeToString(dxpub[:]))
                        derivedPK := dxpub.PublicKey()
-                       fmt.Println("UtxoToInputs derivedPK", hex.EncodeToString(derivedPK))
                        sigInst.WitnessComponents = append(sigInst.WitnessComponents, txbuilder.DataWitness([]byte(derivedPK)))
-                       fmt.Println("UtxoToInputs *common.AddressWitnessPubKeyHash done...")
                }
 
        case *common.AddressWitnessScriptHash:
-               fmt.Println("UtxoToInputs *common.AddressWitnessScriptHash...")
-               fmt.Println("UtxoToInputs derivedXPubs", derivedXPubs)
                derivedPKs := csp.XPubKeys(derivedXPubs)
                script, err := vmutil.P2SPMultiSigProgram(derivedPKs, signer.Quorum)
                if err != nil {
                        return nil, nil, err
                }
-               fmt.Println("UtxoToInputs derivedPKs:", derivedPKs)
                sigInst.WitnessComponents = append(sigInst.WitnessComponents, txbuilder.DataWitness(script))
 
        default:

diff --git a/blockchain/pseudohsm/pseudohsm_test.go b/blockchain/pseudohsm/pseudohsm_test.go
index f1f4478..b419640 100644 (file)
--- a/blockchain/pseudohsm/pseudohsm_test.go
+++ b/blockchain/pseudohsm/pseudohsm_test.go
@@ -4,7 +4,6 @@ import (
        "fmt"
        "io/ioutil"
        "os"
-       "reflect"
        "strings"
        "testing"
 
@@ -87,7 +86,6 @@ func TestPseudoHSMChainKDKeys(t *testing.T) {
        if err != nil {
                t.Fatal(err)
        }
-       fmt.Println("TestPseudoHSMChainKDKeys xpub:", xpub)
        xpub2, _, err := hsm.XCreate("bytom", "nopassword", "en")
        if err != nil {
                t.Fatal(err)
@@ -97,14 +95,8 @@ func TestPseudoHSMChainKDKeys(t *testing.T) {
        if err != nil {
                t.Fatal(err)
        }
-       fmt.Println("TestPseudoHSMChainKDKeys xpub.XPub:", xpub.XPub)
-       fmt.Println("TestPseudoHSMChainKDKeys xpub.XPub type:", reflect.TypeOf(xpub.XPub))
-       fmt.Println("TestPseudoHSMChainKDKeys sig:", sig)
-       fmt.Println("TestPseudoHSMChainKDKeys sig type:", reflect.TypeOf(sig))
-
        switch xpubkey := xpub.XPub.(type) {
        case edchainkd.XPub:
-               fmt.Println("TestPseudoHSMChainKDKeys 1 sig:", sig)
                if !xpubkey.Verify(msg, sig) {
                        t.Error("expected verify to succeed")
                }

diff --git a/crypto/csp/util.go b/crypto/csp/util.go
index 5615e84..bf5014e 100644 (file)
--- a/crypto/csp/util.go
+++ b/crypto/csp/util.go
@@ -15,9 +15,7 @@ import (
 
 func NewXKeys(r io.Reader) (xprv vcrypto.XPrvKeyer, xpub vcrypto.XPubKeyer, err error) {
        // TODO: if ... create sm2 xprv and xpub
-       // return .....
 
-       // if ... create ed25519 xprv and xpub
        return edchainkd.NewXKeys(r)
 }
 
@@ -32,30 +30,13 @@ func XPubKeys(xpubs []vcrypto.XPubKeyer) []crypto.PublicKey {
        return res
 }
 
-// func DeriveXPubs(xpubs []vcrypto.XPubKeyer, path [][]byte) []vcrypto.XPubKeyer {
-//     res := make([]vcrypto.XPubKeyer, 0, len(xpubs))
-//     for _, xpub := range xpubs {
-//             switch xpb := xpub.(type) {
-//             case edchainkd.XPub:
-//                     d := xpb.Derive(path)
-//                     res = append(res, d)
-//                     fmt.Println("DeriveXPubs d is:", d)
-//             }
-//     }
-//     fmt.Println("DeriveXPubs len(res) is:", len(res))
-//     return res
-// }
-
 func DeriveXPubs(xpubs []vcrypto.XPubKeyer, path [][]byte) []vcrypto.XPubKeyer {
        res := make([]vcrypto.XPubKeyer, 0, len(xpubs))
        for _, xpub := range xpubs {
-               fmt.Println("DeriveXPubs type xpubs:", reflect.TypeOf(xpubs), "type xpubs[0]:", reflect.TypeOf(xpubs[0]))
-               fmt.Println("xpubs[0] is:", xpubs[0])
                switch xpb := xpub.(type) {
                case edchainkd.XPub:
                        d := xpb.Derive(path)
                        res = append(res, d)
-                       fmt.Println("DeriveXPubs d is:", d)
                default:
                        newxpub, err := edchainkd.NewXPub(reflect.ValueOf(xpub).String())
                        if err != nil {
@@ -63,10 +44,8 @@ func DeriveXPubs(xpubs []vcrypto.XPubKeyer, path [][]byte) []vcrypto.XPubKeyer {
                        } else {
                                d := newxpub.Derive(path)
                                res = append(res, d)
-                               fmt.Println("DeriveXPubs d is:", d)
                        }
                }
        }
-       fmt.Println("DeriveXPubs len(res) is:", len(res))
        return res
 }

diff --git a/crypto/ed25519/chainkd/serialize.go b/crypto/ed25519/chainkd/serialize.go
index 7a2231d..70c5bde 100644 (file)
--- a/crypto/ed25519/chainkd/serialize.go
+++ b/crypto/ed25519/chainkd/serialize.go
@@ -3,7 +3,6 @@ package chainkd
 import (
        "encoding/hex"
        "errors"
-       "fmt"
 )
 
 const (
@@ -63,15 +62,11 @@ func (xprv XPrv) String() string {
 func NewXPub(str string) (*XPub, error) {
        xpub := new(XPub)
        if len(str) != 2*64 {
-               fmt.Println("str length is:", len(str))
-               fmt.Println("str is:", str)
                return nil, errors.New("string length is invalid.")
        }
        if xpubBytes, err := hex.DecodeString(str); err != nil {
                return nil, err
        } else {
-               fmt.Println("NewXPub xpub is:", xpub)
-               fmt.Println("NewXPub xpubBytes is:", xpubBytes)
                copy(xpub[:], xpubBytes[:])
        }
        return xpub, nil

diff --git a/protocol/bc/types/map.go b/protocol/bc/types/map.go
index 8922451..1568119 100644 (file)
--- a/protocol/bc/types/map.go
+++ b/protocol/bc/types/map.go
@@ -1,8 +1,6 @@
 package types
 
 import (
-       "fmt"
-
        log "github.com/sirupsen/logrus"
 
        "github.com/vapor/consensus"
@@ -14,7 +12,6 @@ import (
 // MapTx converts a types TxData object into its entries-based
 // representation.
 func MapTx(oldTx *TxData) *bc.Tx {
-       fmt.Println("MapTx start...")
        txID, txHeader, entries := mapTx(oldTx)
        tx := &bc.Tx{
                TxHeader: txHeader,