Feature/rlp for epoch v0.10 (#16)

* Compatibility with epoch 0.10.0
- Replace MsgPack with RLP

Author: noandrea

.flake8

@@ -0,0 +1,2 @@
+[flake8]
+max-line-length = 160

.gitignore

@@ -3,3 +3,7 @@ venv
 **/*.pyc
 .pytest_cache
 /epoch/
+.vscode
+aepp_sdk.egg-info
+dist
+build

AUTHORS

@@ -0,0 +1,2 @@
+Tom Wallroth <[email protected]>
+Andrea Giacobino <[email protected]>

LICENSE LICENSE.txt

@@ -0,0 +1,46 @@
+# build output folder
+DIST_FOLDER = dist
+BUILD_FOLDER = build
+
+.PHONY: list
+list:
+	@echo clean build lint test publish-test publish
+
+default: build
+
+build: build-dist
+
+build-dist:
+	@echo build 
+	python setup.py sdist
+	python setup.py bdist_wheel
+	@echo done
+
+test: test-all
+
+test-all:
+	@echo run pytest
+	pytest
+	@echo done
+
+lint: lint-all
+
+lint-all:
+	@echo lint aeternity
+	flake8 aeternity
+	@echo done
+
+clean:
+	@echo remove '$(DIST_FOLDER)','$(BUILD_FOLDER)' folders
+	@rm -rf $(DIST_FOLDER) $(BUILD_FOLDER)
+	@echo done  
+
+publish:
+	@echo publish on pypi.org
+	twine upload dist/*
+	@echo done
+
+publish-test:
+	@echo publish on test.pypi.org
+	twine upload --repository-url https://test.pypi.org/legacy/ dist/*
+	@echo done

Makefile

@@ -4,4 +4,4 @@
 from .config import Config
 from .contract import Contract
 
-__version__ = '0.1.0'
+__version__ = '0.1.2'

aeternity/__init__.py

@@ -104,6 +104,7 @@ def update_status(self):
             if self.status == NameStatus.UNKNOWN:
                 self.status = NameStatus.AVAILABLE
 
+
     def is_available(self):
         self.update_status()
         return self.status == NameStatus.AVAILABLE

aeternity/aens.py

@@ -15,21 +15,30 @@ class ConfigException(Exception):
 ae_default_websocket_host = 'localhost'
 ae_default_websocket_port = 3114
 
+
 class Config:
     default_configs = None
 
-    def __init__(self, external_host=None, internal_host=None, websocket_host=None,
-                 docker_semantics=False):
+    def __init__(self,
+                 external_host=None,
+                 internal_host=None,
+                 websocket_host=None,
+                 docker_semantics=False,
+                 secure_connection=False):
         try:
             if external_host is None:
                 host = os.environ.get('AE_EXTERNAL_HOST', ae_default_external_host)
                 port = os.environ.get('AE_EXTERNAL_PORT', ae_default_external_port)
                 external_host = f'{host}:{port}'
+                if "{}".format(port) == '443':
+                    secure_connection = True
             self.external_host_port = external_host
             if internal_host is None:
                 host = os.environ.get('AE_INTERNAL_HOST', ae_default_internal_host)
                 port = os.environ.get('AE_INTERNAL_PORT', ae_default_internal_port)
                 internal_host = f'{host}:{port}'
+                if "{}".format(port) == '443':
+                    secure_connection = True
             self.internal_host_port = internal_host
             if websocket_host is None:
                 host = os.environ.get('AE_WEBSOCKET_HOST', ae_default_websocket_host)
@@ -48,9 +57,14 @@ def __init__(self, external_host=None, internal_host=None, websocket_host=None,
 
         internal_host_suffix = 'internal/' if docker_semantics else ''
 
+        # set the schema for http connection
+        url_schema = 'http'
+        if secure_connection:
+            url_schema = 'https'
+
         self.websocket_url = f'ws://{self.websocket_host_port}/websocket'
-        self.http_api_url = f'http://{self.external_host_port}/v2'
-        self.internal_api_url = f'http://{self.internal_host_port}/{internal_host_suffix}v2'
+        self.http_api_url = f'{url_schema}://{self.external_host_port}/v2'
+        self.internal_api_url = f'{url_schema}://{self.internal_host_port}/{internal_host_suffix}v2'
 
         self.name_url = f'{self.http_api_url}/name'
         self.pubkey = None

aeternity/config.py

@@ -60,7 +60,7 @@ class EpochRequestError(Exception):
 # Transaction types:
 #
 CoinbaseTx = namedtuple('CoinbaseTx', [
-    'block_height', 'account', 'data_schema', 'type', 'vsn'
+    'block_height', 'account', 'data_schema', 'type', 'vsn', 'reward'
 ])
 AENSClaimTx = namedtuple('AENSClaimTx', [
     'account', 'fee', 'name', 'name_salt', 'nonce', 'type', 'vsn'
@@ -112,8 +112,10 @@ class EpochRequestError(Exception):
 
 
 transaction_type_mapping = {
+    'coinbase_tx': CoinbaseTx,
     'aec_coinbase_tx': CoinbaseTx,
     'aec_spend_tx': SpendTx,
+    'spend_tx': SpendTx,
     'aens_claim_tx': AENSClaimTx,
     'aens_preclaim_tx': AENSPreclaimTx,
     'aens_transfer_tx': AENSTransferTx,
@@ -132,7 +134,6 @@ def transaction_from_dict(data):
     try:
         tx = transaction_type_mapping[tx_type](**data['tx'])
     except KeyError:
-        print(data['tx'])
         raise ValueError(f'Cannot deserialize transaction of type {tx_type}')
 
     data = data.copy()  # don't mutate the input
@@ -269,7 +270,7 @@ def send(self, message):
         self._connection.send(message)
 
     def spend(self, keypair, recipient_pubkey, amount):
-        transaction = self.create_spend_transaction(recipient_pubkey, amount)
+        transaction = self.create_spend_transaction(recipient_pubkey, amount, sender=keypair)
         signed_transaction, signature = keypair.sign_transaction(transaction)
         resp = self.send_signed_transaction(signed_transaction)
         return resp, transaction.tx_hash
@@ -332,7 +333,8 @@ def _get_burn_key(cls):
         keypair.signing_key
 
     def get_pubkey(self):
-        return self.internal_http_get('account/pub-key')['pub_key']
+        pub_key = self.internal_http_get('account/pub-key')
+        return pub_key['pub_key']
 
     def get_height(self):
         return int(self.external_http_get('top')['height'])
@@ -495,15 +497,18 @@ def get_transactions_in_block_range(self, from_height, to_height, tx_types=None,
         data = self.internal_http_get('/block/txs/list/height', params=params)
         return [transaction_from_dict(tx) for tx in data['transactions']]
 
-    def create_spend_transaction(self, recipient, amount, fee=1):
-        from aeternity import AEName
-        assert AEName.validate_pointer(recipient)
-        sender = self.get_pubkey()
+    def create_spend_transaction(self, recipient, amount, fee=1, sender=None):
+        if sender is None:
+            from aeternity import AEName
+            assert AEName.validate_pointer(recipient)
+            origin = self.get_pubkey()
+        else:
+            origin = sender.get_address() 
         response = self.external_http_post(
             'tx/spend',
             json=dict(
                 amount=amount,
-                sender=sender,
+                sender=origin,
                 fee=fee,
                 recipient_pubkey=recipient,
             )

aeternity/epoch.py

@@ -1,22 +1,45 @@
 import os
-from collections import namedtuple
 
 from hashlib import sha256
 
 import base58
-import msgpack
+import rlp
 from Crypto.Cipher import AES
 from Crypto.Hash import SHA256
-from ecdsa import SECP256k1, SigningKey, VerifyingKey
+from ecdsa import SECP256k1, SigningKey
 import ecdsa
 
+# RLP version number
+# https://github.com/aeternity/protocol/blob/epoch-v0.10.1/serializations.md#binary-serialization
+VSN = 1
+
+# The list of tags can be found here:
+# https://github.com/aeternity/protocol/blob/epoch-v0.10.1/serializations.md#table-of-object-tags
+TAG_SIGNED_TX = 11
+TAG_SPEND_TX = 12
+
 
 class SignableTransaction:
+
     def __init__(self, tx_json_data):
-        self.tx_json_data = tx_json_data
         self.tx_hash = tx_json_data['tx_hash']
-        self.tx_msg_packed = base58.b58decode_check(tx_json_data['tx'][3:])
-        self.tx_unpacked = msgpack.unpackb(self.tx_msg_packed)
+        self.tx = tx_json_data['tx']
+        self.tx_unsigned = base58.b58decode_check(tx_json_data['tx'][3:])
+        self.tx_decoded = rlp.decode(self.tx_unsigned)
+
+        # decode a transaction
+        def btoi(byts):
+            return int.from_bytes(byts, byteorder='big')
+
+        self.tag = btoi(self.tx_decoded[0])
+        self.vsn = btoi(self.tx_decoded[1])
+        self.fields = {}
+        if self.tag == TAG_SPEND_TX:
+            self.fields['sender'] = base58.b58encode_check(self.tx_decoded[2])
+            self.fields['recipient'] = base58.b58encode_check(self.tx_decoded[3])
+            self.fields['amount'] = btoi(self.tx_decoded[4])
+            self.fields['fee'] = btoi(self.tx_decoded[5])
+            self.fields['nonce'] = btoi(self.tx_decoded[6])
 
 
 class KeyPair:
@@ -25,29 +48,36 @@ def __init__(self, signing_key, verifying_key):
         self.verifying_key = verifying_key
 
     def get_address(self):
+        """get the keypair public_key base58 encoded and prefixed (ak$...)"""
         pub_key = self.verifying_key.to_string()
         return 'ak$' + base58.b58encode_check(b'\x04' + pub_key)
 
-    def encode_transaction_message(self, unpacked_tx, signatures):
-        if not isinstance(signatures, list):
-            signatures = [signatures]
-        message = [
-            b"sig_tx",  # SIG_TX_TYPE
-            1,          # VSN
-            unpacked_tx,
-            signatures
-        ]
-        str = base58.b58encode_check(msgpack.packb(message, use_bin_type=True))
-        return "tx$" + str
-
-    def sign_transaction_message(self, msgpacked_tx):
-        return self.signing_key.sign(msgpacked_tx, sigencode=ecdsa.util.sigencode_der)
+    def get_private_key(self):
+        """get the private key hex encoded"""
+        return self.signing_key.to_string().hex()
+
+    def sign_transaction_message(self, message):
+        """sign a message with using the private key"""
+        signature = self.signing_key.sign(message, sigencode=ecdsa.util.sigencode_der)
+        return signature
+
+    def sign_verify(self, message, signature):
+        """verifify message signature, raise an error if the message cannot be verified"""
+        assert self.verifying_key.verify(signature, message, sigdecode=ecdsa.util.sigdecode_der)
+
+    def encode_transaction_message(self, unsigned_tx, signatures):
+        """prepare a signed transaction message"""
+        tag = bytes([TAG_SIGNED_TX])
+        vsn = bytes([VSN])
+        payload = rlp.encode([tag, vsn, signatures, unsigned_tx])
+        return f"tx${base58.b58encode_check(payload)}"
 
     def sign_transaction(self, transaction):
-        signature = self.sign_transaction_message(msgpacked_tx=transaction.tx_msg_packed)
-        encoded_msg = self.encode_transaction_message(transaction.tx_unpacked, [signature])
+        signature = self.sign_transaction_message(message=transaction.tx_unsigned)
+        tx_encoded = self.encode_transaction_message(transaction.tx_unsigned, [signature])
+        self.sign_verify(transaction.tx_unsigned, signature)
         b58_signature = 'sg$' + base58.b58encode_check(signature)
-        return encoded_msg, b58_signature
+        return tx_encoded, b58_signature
 
     def save_to_folder(self, folder, password):
         enc_key = self._encrypt_key(self.signing_key.to_string(), password)
@@ -70,8 +100,17 @@ def generate(cls):
 
     @classmethod
     def from_public_private_key_strings(cls, public, private):
-        signing_key = SigningKey.from_string(private, curve=SECP256k1, hashfunc=sha256)
-        return KeyPair(signing_key, signing_key.get_verifying_key())
+        """create a keypair from a aet address and private key string
+
+        :param public: the aet address, used to verify the private key
+        :param private: the hex encoded private key
+        :return: a keypair object or raise error if the public key doesnt match
+        """
+        pk = bytes.fromhex(private)
+        signing_key = SigningKey.from_string(pk, curve=SECP256k1, hashfunc=sha256)
+        kp = KeyPair(signing_key, signing_key.get_verifying_key())
+        assert kp.get_address() == public
+        return kp
 
     @classmethod
     def sha256(cls, data):

aeternity/signing.py

@@ -1,4 +1,15 @@
 import logging
+from aeternity import Config
 
-logging.getLogger("requests").setLevel(logging.WARNING)
-logging.getLogger("urllib3").setLevel(logging.WARNING)
+logging.getLogger("requests").setLevel(logging.DEBUG)
+logging.getLogger("urllib3").setLevel(logging.DEBUG)
+
+KEY_PATH = '/Users/andrea/Documents/workspaces/blockchain/aeternity/epoch/deployment/ansible/files/tester'
+KEY_PASSWORD = 'secret'
+
+
+Config.set_defaults(Config(
+    external_host='sdk-testnet.aepps.com:443',
+    internal_host='sdk-testnet.aepps.com:443/internal',
+    secure_connection=True
+))