github.com/karalabe/go-ethereum@v0.8.5/crypto/keyring.go (about)

     1  package crypto
     2  
     3  import (
     4  	"fmt"
     5  	"io/ioutil"
     6  	"strings"
     7  
     8  	"github.com/ethereum/go-ethereum/ethutil"
     9  )
    10  
    11  type KeyRing struct {
    12  	keys []*KeyPair
    13  }
    14  
    15  func NewKeyRing() *KeyRing {
    16  	return &KeyRing{}
    17  }
    18  
    19  func (k *KeyRing) AddKeyPair(keyPair *KeyPair) {
    20  	k.keys = append(k.keys, keyPair)
    21  }
    22  
    23  func (k *KeyRing) GetKeyPair(i int) *KeyPair {
    24  	if len(k.keys) > i {
    25  		return k.keys[i]
    26  	}
    27  
    28  	return nil
    29  }
    30  
    31  func (k *KeyRing) Empty() bool {
    32  	return k.Len() == 0
    33  }
    34  
    35  func (k *KeyRing) Len() int {
    36  	return len(k.keys)
    37  }
    38  
    39  func (k *KeyRing) Each(f func(*KeyPair)) {
    40  	for _, keyPair := range k.keys {
    41  		f(keyPair)
    42  	}
    43  }
    44  
    45  func NewGeneratedKeyRing(len int) *KeyRing {
    46  	keyRing := NewKeyRing()
    47  	for i := 0; i < len; i++ {
    48  		keyRing.AddKeyPair(GenerateNewKeyPair())
    49  	}
    50  	return keyRing
    51  }
    52  
    53  func NewKeyRingFromFile(secfile string) (*KeyRing, error) {
    54  	var content []byte
    55  	var err error
    56  	content, err = ioutil.ReadFile(secfile)
    57  	if err != nil {
    58  		return nil, err
    59  	}
    60  	keyRing, err := NewKeyRingFromString(string(content))
    61  	if err != nil {
    62  		return nil, err
    63  	}
    64  	return keyRing, nil
    65  }
    66  
    67  func NewKeyRingFromString(content string) (*KeyRing, error) {
    68  	secretStrings := strings.Split(content, "\n")
    69  	var secrets [][]byte
    70  	for _, secretString := range secretStrings {
    71  		secret := secretString
    72  		words := strings.Split(secretString, " ")
    73  		if len(words) == 24 {
    74  			secret = MnemonicDecode(words)
    75  		} else if len(words) != 1 {
    76  			return nil, fmt.Errorf("Unrecognised key format")
    77  		}
    78  
    79  		if len(secret) != 0 {
    80  			secrets = append(secrets, ethutil.Hex2Bytes(secret))
    81  		}
    82  	}
    83  
    84  	return NewKeyRingFromSecrets(secrets)
    85  }
    86  
    87  func NewKeyRingFromSecrets(secs [][]byte) (*KeyRing, error) {
    88  	keyRing := NewKeyRing()
    89  	for _, sec := range secs {
    90  		keyPair, err := NewKeyPairFromSec(sec)
    91  		if err != nil {
    92  			return nil, err
    93  		}
    94  		keyRing.AddKeyPair(keyPair)
    95  	}
    96  	return keyRing, nil
    97  }
    98  
    99  func NewKeyRingFromBytes(data []byte) (*KeyRing, error) {
   100  	var secrets [][]byte
   101  	it := ethutil.NewValueFromBytes(data).NewIterator()
   102  	for it.Next() {
   103  		secret := it.Value().Bytes()
   104  		secrets = append(secrets, secret)
   105  	}
   106  	keyRing, err := NewKeyRingFromSecrets(secrets)
   107  	if err != nil {
   108  		return nil, err
   109  	}
   110  	return keyRing, nil
   111  }
   112  
   113  func (k *KeyRing) RlpEncode() []byte {
   114  	return k.RlpValue().Encode()
   115  }
   116  
   117  func (k *KeyRing) RlpValue() *ethutil.Value {
   118  	v := ethutil.EmptyValue()
   119  	k.Each(func(keyPair *KeyPair) {
   120  		v.Append(keyPair.RlpValue())
   121  	})
   122  	return v
   123  }