Merge pull request #48 from ltonetwork/cobalt-alloy

Cobalt alloy

Author: AndreaScorza

.gitignore

@@ -59,3 +59,5 @@ target/
 
 # dev
 test.py
+project
+/src/lto/test2.py

README.md

@@ -8,30 +8,30 @@ Python client library for interacting with LTO Network
 The chain_id is 'L' for the MainNet and 'T' TestNet
 
 ```python
-from src.lto.account_factory import AccountFactory
+from lto.accounts.account_factory import AccountFactory
 
 account = AccountFactory(chain_id).create()
 ```
 ### Create an account from seed
 
 ```python
-from src.lto.account_factory import AccountFactory
+from lto.accounts.account_factory import AccountFactory
 
 account = AccountFactory(chain_id).create_from_seed(seed)
 ```
 
 ### Create an account from public key
 
 ```python
-from src.lto.account_factory import AccountFactory
+from lto.accounts.account_factory import AccountFactory
 
 account = AccountFactory(chain_id).create_from_public_key(public_key)
 ```
 
 ### Create an account from private key
 
 ```python
-from src.lto.account_factory import AccountFactory
+from lto.accounts.account_factory import AccountFactory
 
 account = AccountFactory(chain_id).create_from_private_key(private_key)
 ```

setup.cfg

@@ -29,6 +29,10 @@ install_requires =
     ecdsa~=0.17.0
     inflection~=0.5.1
     freezegun~=1.1.0
+    mnemonic~=0.20
+    eth-utils~=2.0.0
+    pycryptodome~=3.12.0
+    pysha3~=1.0.2
 
 [options.packages.find]
 where = src

src/lto/__init__.py

@@ -1,26 +1,15 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 
-from lto.account_factory import AccountFactory
-from lto.public_node import PublicNode
+import base58
 
-from lto.transactions.anchor import Anchor
-from lto.transactions.lease import Lease
-from lto.transactions.association import Association
-from lto.transactions.cancel_lease import CancelLease
-from lto.transactions.cancel_sponsorship import CancelSponsorship
-from lto.transactions.mass_transfer import MassTransfer
-from lto.transactions.revoke_association import RevokeAssociation
-from lto.transactions.set_script import SetScript
-from lto.transactions.sponsorship import Sponsorship
-from lto.transactions.transfer import Transfer
-from lto.accounts.account_factory_ecdsa import AccountFactoryECDSA
-from lto.accounts.account_factory_ed25519 import AccountFactoryED25519
+from lto.accounts import AccountFactory
+from lto.public_node import PublicNode
+from lto.accounts import AccountFactoryECDSA, AccountFactoryED25519
 
 
 class LTO:
 
     def __init__(self, chain_id='T'):
-
         if chain_id == 'T':
             self.NODE = PublicNode('https://testnet.lto.network')
         elif chain_id == 'L':
@@ -29,15 +18,15 @@ def __init__(self, chain_id='T'):
             self.NODE = ''
 
         self.chain_id = chain_id
-
         self.account_factories = {
             'ed25519': AccountFactoryED25519(chain_id),
             'secp256r1': AccountFactoryECDSA(chain_id, curve='secp256r1'),
             'secp256k1': AccountFactoryECDSA(chain_id, curve='secp256k1')
         }
 
-    def Account(self, public_key=None, private_key=None, key_type='ed25519', seed=None, nonce=0):
-        factory = self.account_factories[key_type]
+    def Account(self, public_key=None, private_key=None, key_type='ed25519', seed=None, seed_method=None, nonce=0):
+        factory = self.account_factories[key_type].with_seed_method(seed_method)
+
         if seed:
             account = factory.create_from_seed(seed, nonce)
         elif private_key:
@@ -46,32 +35,17 @@ def Account(self, public_key=None, private_key=None, key_type='ed25519', seed=No
             account = factory.create_from_public_key(public_key)
         else:
             account = factory.create()
-        return account
 
-    def getchain_id(self):
-        return self.chain_id
+        # assert public_key is None or account.get_public_key() == self.__key_base58(public_key), "Public key mismatch"
+        # assert private_key is None or account.get_private_key() == self.__key_base58(private_key), "Private key mismatch"
 
-    def from_data(self, data):
+        return account
 
-        if data['type'] == 4:
-            return Transfer(recipient=data['recipient'], amount=data['amount']).from_data(data)
-        elif data['type'] == 8:
-            return Lease(amount=1, recipient='').from_data(data)
-        elif data['type'] == 11:
-            return MassTransfer(transfers='').from_data(data)
-        elif data['type'] == 15:
-            return Anchor(anchor='').from_data(data)
-        elif data['type'] == 16:
-            return Association(recipient='', association_type='', anchor='').from_data(data)
-        elif data['type'] == 17:
-            return RevokeAssociation(recipient='', association_type='').from_data(data)
-        elif data['type'] == 18:
-            return Sponsorship(data['recipient']).from_data(data)
-        elif data['type'] == 19:
-            return CancelSponsorship(data['recipient']).from_data(data)
-        elif data['type'] == 13:
-            return SetScript(data['script']).from_data(data)
-        elif data['type'] == 9:
-            return CancelLease(lease_id='').from_data(data)
+    @staticmethod
+    def __key_base58(key):
+        if type(key) == object:
+            return base58.b58encode(bytes(key))
+        elif type(key) == bytes:
+            return base58.b58encode(key)
         else:
-            raise Exception('Incorrect transaction Type')
+            return key

src/lto/account_factory.py

@@ -0,0 +1,4 @@
+from lto.accounts.account import Account
+from lto.accounts.account_factory import AccountFactory
+from lto.accounts.ecdsa.account_factory_ecdsa import AccountFactoryECDSA
+from lto.accounts.ed25519.account_factory_ed25519 import AccountFactoryED25519

src/lto/accounts/__init__.py

@@ -0,0 +1,56 @@
+import copy
+from abc import ABC, abstractmethod
+from lto.accounts.brainwallet import random_seed as brainwallet_random_seed
+from lto.accounts.bip39 import random_seed as bip39_random_seed
+
+
+class AccountFactory(ABC):
+    def __init__(self, chain_id, seed_method):
+        self.chain_id = chain_id
+        self.seed_method = seed_method
+
+    def with_seed_method(self, seed_method):
+        if seed_method is None or self.seed_method == seed_method:
+            return self
+
+        clone = copy.copy(self)
+        clone.seed_method = seed_method
+        return clone
+
+    @abstractmethod
+    def create_sign_keys(self, seed, nonce):
+        pass
+
+    @abstractmethod
+    def create_address(self, public_key):
+        pass
+
+    def create(self):
+        if self.seed_method == 'brainwallet':
+            seed = brainwallet_random_seed()
+        elif self.seed_method == 'bip39':
+            seed = bip39_random_seed()
+        elif self.seed_method.startswith('bip39:'):
+            # raise Exception("Method under construction")
+            seed = bip39_random_seed(self.seed_method[6:])
+        else:
+            raise Exception('Unknown seed method')
+
+        return self.create_from_seed(seed)
+
+    @abstractmethod
+    def create_from_seed(self, seed, nonce=0):
+        pass
+
+    @abstractmethod
+    def create_from_private_key(self, private_key):
+        pass
+
+    @abstractmethod
+    def create_from_public_key(self, public_key):
+        pass
+
+    @abstractmethod
+    def create_with_values(self, address, public_key, private_key, key_type, seed=''):
+        pass
+

src/lto/account.py renamed to src/lto/accounts/account.py

@@ -0,0 +1,5 @@
+from mnemonic import Mnemonic
+
+
+def random_seed(language="english"):
+    return Mnemonic(language).generate(strength=256)

src/lto/accounts/account_factory.py

@@ -0,0 +1,17 @@
+import os
+from lto import crypto
+from lto.word_list import wordList
+
+def random_seed():
+    word_count = len(wordList)
+    words = []
+    for i in range(5):
+        r = crypto.bytes2str(os.urandom(4))
+        x = (ord(r[3])) + (ord(r[2]) << 8) + (ord(r[1]) << 16) + (ord(r[0]) << 24)
+        w1 = x % word_count
+        w2 = ((int(x / word_count) >> 0) + w1) % word_count
+        w3 = ((int((int(x / word_count) >> 0) / word_count) >> 0) + w2) % word_count
+        words.append(wordList[w1])
+        words.append(wordList[w2])
+        words.append(wordList[w3])
+    return ' '.join(words)

src/lto/accounts/bip39.py

@@ -0,0 +1,2 @@
+from lto.accounts.ecdsa.account_ecdsa import AccountECDSA as Account
+from lto.accounts.ecdsa.account_factory_ecdsa import AccountFactoryECDSA as AccountFactory

src/lto/accounts/brainwallet.py

@@ -1,7 +1,7 @@
-from lto.account import Account
+from lto.accounts.account import Account
 import base58
 from lto import crypto
-import ecdsa
+
 
 class AccountECDSA(Account):
 
@@ -11,6 +11,9 @@ def init(self, address, public_key, private_key=None, key_type ='secp256k1',seed
     def get_public_key(self):
         return base58.b58encode(self.public_key.to_string(encoding="compressed"))
 
+    def get_private_key(self):
+        return base58.b58encode(self.private_key.to_string())
+
     def sign(self, message):
         if not self.private_key:
             raise Exception("Private key not set")

src/lto/accounts/ecdsa/__init__.py

@@ -1,16 +1,18 @@
-from lto.account_factory import AccountFactory
+from lto.accounts.account_factory import AccountFactory
 from ecdsa import VerifyingKey, SECP256k1, NIST256p, SigningKey
 import hashlib
-from ecdsa.util import randrange_from_seed__trytryagain
+from ecdsa.util import randrange_from_seed__trytryagain as randrange_from_seed
 import base58
 from lto import crypto
 from lto.accounts.ecdsa.account_ecdsa import AccountECDSA as Account
+from mnemonic import Mnemonic
+from lto import ethereum_mnemonic_utils as eth
 
 
 class AccountFactoryECDSA(AccountFactory):
 
     def __init__(self, chain_id, curve='secp256k1'):
-        super().__init__(chain_id)
+        super().__init__(chain_id, 'bip39')
 
         self.key_type = curve
         if curve == 'secp256k1':
@@ -21,14 +23,15 @@ def __init__(self, chain_id, curve='secp256k1'):
             raise Exception("Curve not supported")
 
     def _MakeKey(self, seed):
-        secexp = randrange_from_seed__trytryagain(seed, self.curve.order)
+        secexp = randrange_from_seed(seed, self.curve.order)
         return SigningKey.from_secret_exponent(secexp, curve=self.curve, hashfunc=hashlib.sha256)
 
     def create_sign_keys(self, seed, nonce=0):
         private_key = self._MakeKey(seed)
         public_key = private_key.verifying_key
         return private_key, public_key, self.key_type
 
+
     def create_address(self, public_key):
         unhashed_address = chr(1) + str(self.chain_id) + crypto.hash_chain(public_key.to_string(encoding="compressed"))[0:20]
         address_hash = crypto.hash_chain(crypto.str2bytes(unhashed_address))[0:4]
@@ -60,9 +63,13 @@ def create_from_private_key(self, private_key):
         return Account(address=address, public_key=public_key, private_key=private_key, key_type=self.key_type)
 
     def create_from_seed(self, seed, nonce=0):
-        private_key, public_key, key_type = self.create_sign_keys(seed, nonce)
-        address = self.create_address(public_key)
-        return Account(address, public_key, private_key, key_type, seed, nonce)
+        private_key = eth.mnemonic_to_private_key(seed, nonce=nonce)
+        public_key = eth.derive_public_key(private_key)
+        address = eth.address_from_private_key(private_key)
+        key_type = "secp256k1"
+        # private_key, public_key, key_type = self.create_sign_keys(seed, nonce)
+        # address = self.create_address(public_key)
+        return Account(address[2:], public_key, private_key, key_type, seed, nonce)
 
     def create_with_values(self, address, public_key, private_key, key_type, seed=None):
         return Account(address, public_key, private_key, key_type, seed)

src/lto/accounts/ecdsa/account_ecdsa.py

@@ -0,0 +1,3 @@
+from lto.accounts.ed25519.account_ed25519 import AccountED25519 as Account
+from lto.accounts.ed25519.account_factory_ed25519 import AccountFactoryED25519 as AccountFactory
+from nacl.signing import SigningKey, VerifyKey

src/lto/accounts/account_factory_ecdsa.py renamed to src/lto/accounts/ecdsa/account_factory_ecdsa.py

@@ -1,7 +1,6 @@
-from lto.account import Account
+from lto.accounts.account import Account
 import base58
 from lto import crypto
-from nacl.signing import SigningKey, VerifyKey
 
 
 class AccountED25519(Account):
@@ -12,6 +11,9 @@ def init(self, address, public_key, private_key=None, seed=None, nonce=0):
     def get_public_key(self):
         return base58.b58encode(bytes(self.public_key))
 
+    def get_private_key(self):
+        return base58.b58encode(bytes(self.private_key))
+
     def sign(self, message):
         if not self.private_key:
             raise Exception("Private key not set")