lib/account.py

   1 """
   2 todolist:
   3  * passwords, private keys storage
   4  * multisig service
   5  * compatibility with old addresses for restore
   6  * gui
   7
   8         an account may use one or several MPKs.
   9         due to the type 1 derivations, we need to pass the mpk to this function
  10         None : all accounts
  11         -1 : imported
  12         0,1... : seeded sequences
  13
  14         each account has a public and private master key
  15 """
  16
  17 from bitcoin import *
  18
  19
  20 class Account(object):
  21     def __init__(self, v):
  22         self.addresses = v.get('0', [])
  23         self.change = v.get('1', [])
  24         self.name = v.get('name', 'unnamed')
  25
  26     def dump(self):
  27         return {'0':self.addresses, '1':self.change, 'name':self.name}
  28
  29     def get_name(self):
  30         return self.name
  31
  32     def get_addresses(self, for_change):
  33         return self.change[:] if for_change else self.addresses[:]
  34
  35     def create_new_address(self, for_change):
  36         addresses = self.change if for_change else self.addresses
  37         n = len(addresses)
  38         address = self.get_new_address( for_change, n)
  39         addresses.append(address)
  40         print address
  41         return address
  42
  43     def get_new_address(self, for_change, n):
  44         pass
  45
  46
  47
  48
  49 class OldAccount(Account):
  50     """  Privatekey(type,n) = Master_private_key + H(n|S|type)  """
  51
  52     def __init__(self, mpk, mpk2 = None, mpk3 = None):
  53         self.mpk = mpk
  54         self.mpk2 = mpk2
  55         self.mpk3 = mpk3
  56
  57     @classmethod
  58     def mpk_from_seed(klass, seed):
  59         curve = SECP256k1
  60         secexp = klass.stretch_key(seed)
  61         master_private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 )
  62         master_public_key = master_private_key.get_verifying_key().to_string().encode('hex')
  63         return master_public_key
  64
  65     @classmethod
  66     def stretch_key(self,seed):
  67         oldseed = seed
  68         for i in range(100000):
  69             seed = hashlib.sha256(seed + oldseed).digest()
  70         return string_to_number( seed )
  71
  72     def get_sequence(self, sequence, mpk):
  73         for_change, n = sequence
  74         return string_to_number( Hash( "%d:%d:"%(n,for_change) + mpk.decode('hex') ) )
  75
  76     def get_address(self, sequence):
  77         if not self.mpk2:
  78             pubkey = self.get_pubkey(sequence)
  79             address = public_key_to_bc_address( pubkey.decode('hex') )
  80         elif not self.mpk3:
  81             pubkey1 = self.get_pubkey(sequence)
  82             pubkey2 = self.get_pubkey(sequence, mpk = self.mpk2)
  83             address = Transaction.multisig_script([pubkey1, pubkey2], 2)["address"]
  84         else:
  85             pubkey1 = self.get_pubkey(sequence)
  86             pubkey2 = self.get_pubkey(sequence, mpk = self.mpk2)
  87             pubkey3 = self.get_pubkey(sequence, mpk = self.mpk3)
  88             address = Transaction.multisig_script([pubkey1, pubkey2, pubkey3], 2)["address"]
  89         return address
  90
  91     def get_pubkey(self, sequence, mpk=None):
  92         curve = SECP256k1
  93         if mpk is None: mpk = self.mpk
  94         z = self.get_sequence(sequence, mpk)
  95         master_public_key = ecdsa.VerifyingKey.from_string( mpk.decode('hex'), curve = SECP256k1 )
  96         pubkey_point = master_public_key.pubkey.point + z*curve.generator
  97         public_key2 = ecdsa.VerifyingKey.from_public_point( pubkey_point, curve = SECP256k1 )
  98         return '04' + public_key2.to_string().encode('hex')
  99
 100     def get_private_key_from_stretched_exponent(self, sequence, secexp):
 101         order = generator_secp256k1.order()
 102         secexp = ( secexp + self.get_sequence(sequence, self.mpk) ) % order
 103         pk = number_to_string( secexp, generator_secp256k1.order() )
 104         compressed = False
 105         return SecretToASecret( pk, compressed )
 106
 107     def get_private_key(self, sequence, seed):
 108         secexp = self.stretch_key(seed)
 109         return self.get_private_key_from_stretched_exponent(sequence, secexp)
 110
 111     def get_private_keys(self, sequence_list, seed):
 112         secexp = self.stretch_key(seed)
 113         return [ self.get_private_key_from_stretched_exponent( sequence, secexp) for sequence in sequence_list]
 114
 115     def check_seed(self, seed):
 116         curve = SECP256k1
 117         secexp = self.stretch_key(seed)
 118         master_private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 )
 119         master_public_key = master_private_key.get_verifying_key().to_string().encode('hex')
 120         if master_public_key != self.mpk:
 121             print_error('invalid password (mpk)')
 122             raise BaseException('Invalid password')
 123         return True
 124
 125     def get_input_info(self, sequence):
 126         if not self.mpk2:
 127             pk_addr = self.get_address(sequence)
 128             redeemScript = None
 129         elif not self.mpk3:
 130             pubkey1 = self.get_pubkey(sequence)
 131             pubkey2 = self.get_pubkey(sequence,mpk=self.mpk2)
 132             pk_addr = public_key_to_bc_address( pubkey1.decode('hex') ) # we need to return that address to get the right private key
 133             redeemScript = Transaction.multisig_script([pubkey1, pubkey2], 2)['redeemScript']
 134         else:
 135             pubkey1 = self.get_pubkey(sequence)
 136             pubkey2 = self.get_pubkey(sequence, mpk=self.mpk2)
 137             pubkey3 = self.get_pubkey(sequence, mpk=self.mpk3)
 138             pk_addr = public_key_to_bc_address( pubkey1.decode('hex') ) # we need to return that address to get the right private key
 139             redeemScript = Transaction.multisig_script([pubkey1, pubkey2, pubkey3], 2)['redeemScript']
 140         return pk_addr, redeemScript
 141
 142
 143
 144 class BIP32_Account(Account):
 145
 146     def __init__(self, v):
 147         Account.__init__(self, v)
 148         self.c = v['c'].decode('hex')
 149         self.K = v['K'].decode('hex')
 150         self.cK = v['cK'].decode('hex')
 151
 152     def dump(self):
 153         d = Account.dump(self)
 154         d['c'] = self.c.encode('hex')
 155         d['K'] = self.K.encode('hex')
 156         d['cK'] = self.cK.encode('hex')
 157         return d
 158
 159     def get_new_address(self, for_change, n):
 160         pubkey = self.get_pubkey(for_change, n)
 161         address = public_key_to_bc_address( pubkey )
 162         return address
 163
 164     def get_pubkey(self, for_change, n):
 165         K = self.K
 166         chain = self.c
 167         for i in [for_change, n]:
 168             K, K_compressed, chain = CKD_prime(K, chain, i)
 169         return K_compressed
 170
 171     def get_address(self, sequence):
 172         for_change, n = sequence
 173         pubkey = self.get_pubkey(for_change, n)
 174         address = public_key_to_bc_address( pubkey )
 175         return address
 176
 177     def get_private_key(self, sequence, master_k):
 178         chain = self.c
 179         k = master_k
 180         for i in sequence:
 181             k, chain = CKD(k, chain, i)
 182         return SecretToASecret(k, True)
 183
 184     def get_private_keys(self, sequence_list, seed):
 185         return [ self.get_private_key( sequence, seed) for sequence in sequence_list]
 186
 187     def check_seed(self, seed):
 188         master_secret, master_chain, master_public_key, master_public_key_compressed = bip32_init(seed)
 189         assert self.mpk == (master_public_key.encode('hex'), master_chain.encode('hex'))
 190
 191     def get_input_info(self, sequence):
 192         pk_addr = self.get_address(sequence)
 193         redeemScript = None
 194         return pk_addr, redeemScript
 195
 196
 197
 198 class BIP32_Account_2of2(BIP32_Account):
 199
 200     def __init__(self, v):
 201         BIP32_Account.__init__(self, v)
 202         self.c2 = v['c2'].decode('hex')
 203         self.K2 = v['K2'].decode('hex')
 204         self.cK2 = v['cK2'].decode('hex')
 205
 206     def dump(self):
 207         d = BIP32_Account.dump(self)
 208         d['c2'] = self.c2.encode('hex')
 209         d['K2'] = self.K2.encode('hex')
 210         d['cK2'] = self.cK2.encode('hex')
 211         return d
 212
 213     def get_pubkey2(self, for_change, n):
 214         K = self.K2
 215         chain = self.c2
 216         for i in [for_change, n]:
 217             K, K_compressed, chain = CKD_prime(K, chain, i)
 218         return K_compressed
 219
 220     def get_new_address(self, for_change, n):
 221         pubkey1 = self.get_pubkey(for_change, n)
 222         pubkey2 = self.get_pubkey2(for_change, n)
 223         address = Transaction.multisig_script([pubkey1.encode('hex'), pubkey2.encode('hex')], 2)["address"]
 224         return address
 225
 226     def get_input_info(self, sequence):
 227         chain, i = sequence
 228         pubkey1 = self.get_pubkey(chain, i)
 229         pubkey2 = self.get_pubkey2(chain, i)
 230         # fixme
 231         pk_addr = None # public_key_to_bc_address( pubkey1 ) # we need to return that address to get the right private key
 232         redeemScript = Transaction.multisig_script([pubkey1.encode('hex'), pubkey2.encode('hex')], 2)['redeemScript']
 233         return pk_addr, redeemScript
 234