Added encoding of extrinsics

Author: Arjan Zijderveld

scalecodec/base.py

@@ -290,6 +290,7 @@ def __str__(self):
         return str(self.value) or ''
 
     def encode(self, value):
+        self.value = value
         self.data = self.process_encode(value)
         return self.data
 
@@ -298,6 +299,12 @@ def process_encode(self, value):
 
     @classmethod
     def get_decoder_class(cls, type_string, data=None, **kwargs):
+        """
+        :param type_string:
+        :param data:
+        :param kwargs:
+        :return: ScaleType
+        """
 
         type_parts = None
 

scalecodec/block.py

@@ -112,7 +112,7 @@ def process(self):
 
                 self.era = self.process_type('Era')
 
-                self.nonce = self.process_type('Compact<U64>')
+                self.nonce = self.process_type('Compact<Index>')
 
                 self.tip = self.process_type('Compact<Balance>')
 
@@ -129,7 +129,7 @@ def process(self):
 
                 self.era = self.process_type('Era')
 
-                self.nonce = self.process_type('Compact<U64>')
+                self.nonce = self.process_type('Compact<Index>')
 
                 self.tip = self.process_type('Compact<Balance>')
 
@@ -148,7 +148,7 @@ def process(self):
 
                 self.era = self.process_type('Era')
 
-                self.nonce = self.process_type('Compact<U64>')
+                self.nonce = self.process_type('Compact<Index>')
 
                 self.tip = self.process_type('Compact<Balance>')
 
@@ -195,6 +195,7 @@ def process(self):
             result['account_id'] = self.address.account_id
             result['account_index'] = self.address.account_index
             result['account_idx'] = self.address.account_idx
+            result['signature_version'] = self.signature_version.value
             result['signature'] = self.signature.value.replace('0x', '')
             result['extrinsic_hash'] = self.extrinsic_hash
         if self.call_index:
@@ -216,14 +217,14 @@ def process(self):
         return result
 
     def process_encode(self, value):
-        # Check requirements
+
         if 'call_index' in value:
             self.call_index = value['call_index']
 
         elif 'call_module' in value and 'call_function' in value:
             # Look up call module from metadata
             for call_index, (call_module, call) in self.metadata.call_index.items():
-                if call_module.name == value['call_module'] and call.name == value['call_function']:
+                if call_module.name.lower() == value['call_module'].lower() and call.name == value['call_function']:
                     self.call_index = call_index
                     self.call_module = call_module
                     self.call = call
@@ -235,14 +236,44 @@ def process_encode(self, value):
         elif not self.call_module or not self.call:
             raise ValueError('No call module and function specified')
 
+        # Determine version (Fixed to V4 for now)
+        if 'account_id' in value:
+            self.version_info = '84'
+            self.contains_transaction = True
+        else:
+            self.version_info = '04'
+            self.contains_transaction = False
+
         if self.contains_transaction:
             data = ScaleBytes('0x84')
-            raise NotImplementedError('Encoding of signed extrinsics not supported')
+
+            self.address = self.get_decoder_class('Address', metadata=self.metadata)
+            data += self.address.encode(value['account_id'])
+
+            self.signature_version = self.get_decoder_class('U8', metadata=self.metadata)
+            data += self.signature_version.encode(value['signature_version'])
+
+            self.signature = self.get_decoder_class('Signature', metadata=self.metadata)
+            data += self.signature.encode('0x{}'.format(value['signature'].replace('0x', '')))
+
+            self.era = self.get_decoder_class('Era', metadata=self.metadata)
+            data += self.era.encode(value['era'])
+
+            self.nonce = self.get_decoder_class('Compact<Index>', metadata=self.metadata)
+            data += self.nonce.encode(value['nonce'])
+
+            self.tip = self.get_decoder_class('Compact<Balance>', metadata=self.metadata)
+            data += self.tip.encode(value['tip'])
+
         else:
             data = ScaleBytes('0x04')
 
         data += ScaleBytes(bytearray.fromhex(self.call_index))
 
+        # Convert params to call_args TODO refactor
+        if not value.get('call_args') and value.get('params'):
+            value['call_args'] = {call_arg['name']: call_arg['value'] for call_arg in value.get('params')}
+
         # Encode call params
         if len(self.call.args) > 0:
             for arg in self.call.args:
@@ -254,7 +285,7 @@ def process_encode(self, value):
                     arg_obj = self.get_decoder_class(arg.type, metadata=self.metadata)
                     data += arg_obj.encode(param_value)
 
-        # Wrap payload with een length Compact<u32>
+        # Wrap payload with a length Compact<u32>
         length_obj = self.get_decoder_class('Compact<u32>')
         data = length_obj.encode(data.length) + data
 

scalecodec/type_registry/default.json

@@ -267,7 +267,19 @@
       ]
     },
     "EventIndex": "u32",
-    "Extrinsic": "ExtrinsicDecoder",
+    "Extrinsic": "ExtrinsicsDecoder",
+    "ExtrinsicPayloadValue": {
+      "type": "struct",
+      "type_mapping": [
+        ["call", "CallBytes"],
+        ["era", "Era"],
+        ["nonce", "Compact<Index>"],
+        ["tip", "Compact<Balance>"],
+        ["specVersion", "u32"],
+        ["genesisHash", "Hash"],
+        ["blockHash", "Hash"]
+      ]
+    },
     "Gas": "u64",
     "IdentityFields": {
       "type": "set",

scalecodec/types.py

@@ -225,6 +225,15 @@ def process_encode(self, value):
         return data
 
 
+class CallBytes(ScaleType):
+
+    def process(self):
+        raise NotImplementedError()
+
+    def process_encode(self, value):
+        return bytes.fromhex(value[2:])
+
+
 class U8(ScaleType):
 
     def process(self):
@@ -625,6 +634,12 @@ def process(self):
         else:
             return option_byte + self.get_next_bytes(1).hex()
 
+    def process_encode(self, value):
+        if value == '00':
+            return ScaleBytes('0x00')
+        else:
+            raise NotImplementedError('Mortal Era not implemented')
+
 
 class EraIndex(U32):
     pass

test/test_extrinsic_payload.py

@@ -2140,3 +2140,35 @@ def test_encode_utility_cancel_as_multi_payload(self):
         })
 
         self.assertEqual(str(payload), "0xb804180405000010270000010000000123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")
+
+    def test_signed_extrinsic(self):
+        extrinsic = ExtrinsicsDecoder(metadata=self.metadata_decoder)
+
+        extrinsic_value = {
+            'account_id': '5E9oDs9PjpsBbxXxRE9uMaZZhnBAV38n2ouLB28oecBDdeQo',
+            'signature_version': 1,
+            'signature': '728b4057661816aa24918219ff90d10a34f1db4e81494d23c83ef54991980f77cf901acd970cb36d3c9c9e166d27a83a3aee648d4085e2bdb9e7622c0538e381',
+            'call_function': 'transfer',
+            'call_module': 'balances',
+            'nonce': 0,
+            'era': '00',
+            'tip': 0,
+            'params': [
+                {'name': 'dest', 'type': 'Address',
+                 'value': '0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d'},
+                {'name': 'value', 'type': 'Compact<Balance>', 'value': 1000000000000}
+            ]
+        }
+
+        extrinsic_hex = extrinsic.encode(extrinsic_value)
+
+        obj = ScaleDecoder.get_decoder_class(
+            "ExtrinsicsDecoder",
+            data=extrinsic_hex,
+            metadata=self.metadata_decoder
+        )
+
+        decoded_extrinsic = obj.decode()
+
+        self.assertEqual(extrinsic_value['signature'], decoded_extrinsic['signature'])
+        self.assertEqual(extrinsic_value['params'][0]['value'], decoded_extrinsic['params'][0]['value'])