Add signing message with eth_key lib

Author: VadimGrznk

sdk/celo_account/account.py

@@ -587,6 +587,7 @@ def _sign_hash(self, message_hash, private_key):
             r=r,
             s=s,
             v=v,
+            vrs=[v, r, s],
             signature=HexBytes(eth_signature_bytes),
         )
 

sdk/celo_account/datastructures.py

@@ -30,6 +30,7 @@ class SignedMessage(NamedTuple):
     r: int
     s: int
     v: int
+    vrs: list
     signature: HexBytes
 
     def __getitem__(self, index):

sdk/contracts/AccountsWrapper.py

@@ -197,7 +197,7 @@ def authorize_attestation_signer(self, signer: str, proof_of_signing_key_possess
             Transaction hash
         """
         func_call = self._contract.functions.authorizeAttestationSigner(
-            signer, proof_of_signing_key_possession.v, proof_of_signing_key_possession.r, proof_of_signing_key_possession.s)
+            signer, proof_of_signing_key_possession.v, self.web3.toBytes(proof_of_signing_key_possession.r), self.web3.toBytes(proof_of_signing_key_possession.s))
         return self.__wallet.send_transaction(func_call)
 
     def authorize_vote_signer(self, signer: str, proof_of_signing_key_possession: SignedMessage) -> str:
@@ -213,7 +213,7 @@ def authorize_vote_signer(self, signer: str, proof_of_signing_key_possession: Si
             Transaction hash
         """
         func_call = self._contract.functions.authorizeVoteSigner(
-            signer, proof_of_signing_key_possession.v, proof_of_signing_key_possession.r, proof_of_signing_key_possession.s)
+            signer, proof_of_signing_key_possession.v, self.web3.toBytes(proof_of_signing_key_possession.r), self.web3.toBytes(proof_of_signing_key_possession.s))
         return self.__wallet.send_transaction(func_call)
 
     def authorize_validator_signer(self, signer: str, proof_of_signing_key_possession: SignedMessage) -> str:
@@ -237,11 +237,11 @@ def authorize_validator_signer(self, signer: str, proof_of_signing_key_possessio
             pub_key = PublicKey.recover_from_msg_hash(
                 prefixed_message_hash, proof_of_signing_key_possession).to_hex()
             func_call = self._contract.functions.authorizeValidatorSignerWithPublicKey(
-                signer, proof_of_signing_key_possession.v, proof_of_signing_key_possession.r, proof_of_signing_key_possession.s, pub_key)
+                signer, proof_of_signing_key_possession.v, self.web3.toBytes(proof_of_signing_key_possession.r), self.web3.toBytes(proof_of_signing_key_possession.s), pub_key)
             return self.__wallet.send_transaction(func_call)
         else:
             func_call = self._contract.functions.authorizeValidatorSigner(
-                signer, proof_of_signing_key_possession.v, proof_of_signing_key_possession.r, proof_of_signing_key_possession.s)
+                signer, proof_of_signing_key_possession.v, self.web3.toBytes(proof_of_signing_key_possession.r), self.web3.toBytes(proof_of_signing_key_possession.s))
             return self.__wallet.send_transaction(func_call)
 
     def authorize_validator_signer_and_bls(self, signer: str, proof_of_signing_key_possession: SignedMessage, bls_public_key: str, bls_pop: str) -> str:
@@ -267,8 +267,8 @@ def authorize_validator_signer_and_bls(self, signer: str, proof_of_signing_key_p
         pub_key = PublicKey.recover_from_msg_hash(
             prefixed_message_hash, proof_of_signing_key_possession).to_hex()
 
-        func_call = self._contract.functions.authorizeValidatorSignerWithKeys(signer, proof_of_signing_key_possession.v, proof_of_signing_key_possession.r,
-                                                                              proof_of_signing_key_possession.s, pub_key, hash_utils.is_leading_with_0x(bls_public_key), hash_utils.is_leading_with_0x(bls_pop))
+        func_call = self._contract.functions.authorizeValidatorSignerWithKeys(signer, proof_of_signing_key_possession.v, self.web3.toBytes(proof_of_signing_key_possession.r),
+                     self.web3.toBytes(proof_of_signing_key_possession.s), pub_key, hash_utils.is_leading_with_0x(bls_public_key), hash_utils.is_leading_with_0x(bls_pop))
         return self.__wallet.send_transaction(func_call)
 
     def generate_proof_of_key_possession(self, account: str, signer: str) -> SignedMessage:
@@ -352,7 +352,7 @@ def set_account(self, name: str, data_encryption_key: str, wallet_address: str,
         """
         if proof_of_possession:
             func_call = self._contract.functions.setAccount(
-                name, data_encryption_key, wallet_address, proof_of_possession.v, proof_of_possession.r, proof_of_possession.s)
+                name, data_encryption_key, wallet_address, proof_of_possession.v, self.web3.toBytes(proof_of_possession.r), self.web3.toBytes(proof_of_possession.s))
         else:
             func_call = self._contract.functions.setAccount(
                 name, data_encryption_key, wallet_address, '0x0', '0x0', '0x0')
@@ -370,7 +370,7 @@ def set_name(self, name: str) -> str:
         """
         func_call = self._contract.functions.setName(name)
         return self.__wallet.send_transaction(func_call)
-    
+
     def set_metadata_url(self, url: str) -> str:
         """
         Sets the metadataURL for the account
@@ -397,7 +397,9 @@ def set_wallet_address(self, wallet_address: str, proof_of_possession: SignedMes
             Transaction hash
         """
         if proof_of_possession:
-            func_call = self._contract.functions.setWalletAddress(wallet_address, proof_of_possession.v, proof_of_possession.r, proof_of_possession.s)
+            func_call = self._contract.functions.setWalletAddress(
+                wallet_address, proof_of_possession.v, self.web3.toBytes(proof_of_possession.r), self.web3.toBytes(proof_of_possession.s))
         else:
-            func_call = self._contract.functions.setWalletAddress(wallet_address, '0x0', '0x0', '0x0')
+            func_call = self._contract.functions.setWalletAddress(
+                wallet_address, 0, self.web3.toBytes('0x0'), self.web3.toBytes('0x0'))
         return self.__wallet.send_transaction(func_call)

sdk/contracts/GovernanceWrapper.py

@@ -336,9 +336,23 @@ def withdraw(self) -> str:
 
         return self.__wallet.send_transaction(func_call)
 
-    def propose(self, values: List[int], destinations: List[str], data: bytes, data_lengths: List[int], description_url: str, parameters: dict = None) -> int:
-        func_call = self._contract.functions.propose(
-            values, destinations, data, data_lengths, description_url)
+    def proposal_to_params(self, values: List[int], description_url: str) -> list:
+        data = []
+        for el in values:
+            addr = el['input'].lstrip('0x')
+            data.append([elem.encode("hex") for elem in addr])
+        return [
+            [el['value'] for el in values],
+            [el['to'] for el in values if 'to' in el],
+            self.web3.toBytes('0x'+bytes(data).hex()),
+            [len(el) for el in data],
+            description_url
+        ]
+
+    def propose(self, values: List[int], description_url: str, parameters: dict = None) -> int:
+        data = self.proposal_to_params(values, description_url)
+
+        func_call = self._contract.functions.propose(data[0], data[1], data[2], data[3], data[4])
 
         return self.__wallet.send_transaction(func_call, parameters)
 

sdk/contracts/MultiSigWrapper.py

@@ -33,7 +33,7 @@ def __init__(self, web3: Web3, registry: Registry, address: str, abi: list, wall
         self._contract = self.web3.eth.contract(self.address, abi=abi)
         self.__wallet = wallet
 
-    def submit_or_confirm_transaction(self, destination: str, tx_data: str, value: str = '0', parameters: dict = None) -> str:
+    def submit_or_confirm_transaction(self, destination: str, tx_data: str, value: int = 0, parameters: dict = None) -> str:
         """
         Allows an owner to submit and confirm a transaction.
         If an unexecuted transaction matching `tx_object` exists on the multisig, adds a confirmation to that tx ID.

sdk/contracts/SortedOraclesWrapper.py

@@ -110,7 +110,7 @@ def report_expiry_seconds(self) -> int:
         """
         return self._contract.functions.reportExpirySeconds().call()
 
-    def is_oldest_report_expired(self, token: str) -> List[bool, str]:
+    def is_oldest_report_expired(self, token: str) -> list:
         """
         Checks if the oldest report for a given token is expired
 

sdk/utils/utils.py

@@ -41,35 +41,12 @@ def linked_list_changes(sorted_list: list, change_list: list):
 
     return {'lessers': lessers, 'greaters': greaters, 'sorted_list': sorted_list}
 
-if __name__ == "__main__":
-    # lst = [
-    #     { 'address': 'address 1', 'value': 7 },
-    #     { 'address': 'address 2', 'value': 5 },
-    #     { 'address': 'address 3', 'value': 4 },
-    #     { 'address': 'address 4', 'value': 3 },
-    #     { 'address': 'address 5', 'value': 2 },
-    #     { 'address': 'address 6', 'value': 2 },
-    #     { 'address': 'address 7', 'value': 1 },
-    # ]
-    # changes = [{'address': 'address 3', 'value': 2}]
-    # expected = {
-    #     greaters: ['address 6'],
-    #     lessers: ['address 7'],
-    #   }
+def int_to_bytes(x: int) -> bytes:
+    return x.to_bytes((x.bit_length() + 7) // 8, 'big')
 
-    lst = [
-        { 'address': 'address 1', 'value': 7 },
-        { 'address': 'address 2', 'value': 5 },
-        { 'address': 'address 3', 'value': 4 },
-        { 'address': 'address 4', 'value': 3 },
-        { 'address': 'address 5', 'value': 2 },
-        { 'address': 'address 6', 'value': 2 },
-        { 'address': 'address 7', 'value': 1 },
-    ]
-    changes = [{'address': 'address 3', 'value': 2}, {'address': 'address 2', 'value': 0}]
-    #expected = {
-    #     greaters: ['address 6', 'address 7'],
-    #     lessers: ['address 7', NULL_ADDRESS],
-    #   }
-
-    print(linked_list_changes(lst, changes))
+def string_to_bytes32(data):
+    if len(data) > 32:
+        myBytes32 = data[:32]
+    else:
+        myBytes32 = data.ljust(32, '0')
+    return bytes(myBytes32, 'utf-8')

sdk/wallet.py

@@ -6,6 +6,8 @@
 from sdk.celo_account.datastructures import SignedTransaction
 from hexbytes import HexBytes
 from web3 import Web3
+import eth_keys
+from sdk.utils import hash_utils
 
 
 class Wallet:
@@ -27,7 +29,9 @@ def __init__(self, web3: Web3, priv_key: bytes, gas_price_contract: "GasPriceCon
         self.__accounts = {}
         acc = Account()
         self.active_account = acc.from_key(priv_key)
-        self.__accounts.update({self.active_account.address: self.active_account})
+        self.sign_with_provider = False
+        self.__accounts.update(
+            {self.active_account.address: self.active_account})
         self._gas_price_contract = gas_price_contract
         self._fee_currency = None
         self._gateway_fee_recipient = None
@@ -56,15 +60,15 @@ def gas_price(self) -> int:
     @property
     def gas(self) -> int:
         return self._gas
-    
+
     @property
     def threshold_gas_value(self) -> int:
         return self._threshold_gas_value
 
     @property
     def accounts(self) -> dict:
         return self.__accounts
-    
+
     @property
     def gas_price_contract(self) -> 'GasPriceMinimum':
         return self._gas_price_contract
@@ -98,7 +102,7 @@ def gas(self, new_gas: int):
         if type(new_gas) != int:
             raise TypeError("Incorrect new gas type data")
         self._gas = new_gas
-    
+
     @threshold_gas_value.setter
     def threshold_gas_value(self, new_threshold_gas_value: int):
         if type(new_threshold_gas_value) != int:
@@ -111,22 +115,24 @@ def accounts(self, new_acc: Account):
             raise TypeError("Incorrect new account type")
         self.__accounts.update({new_acc.address: new_acc})
         self.active_account = new_acc
-    
+
     @gas_price_contract.setter
     def gas_price_contract(self, gas_price_wrapper: 'GasPriceMinimum'):
         self._gas_price_contract = gas_price_wrapper
 
     def add_new_key(self, priv_key: bytes):
         acc = Account()
         self.active_account = acc.from_key(priv_key)
-        self.__accounts.update({self.active_account.address: self.active_account})
+        self.__accounts.update(
+            {self.active_account.address: self.active_account})
 
     def remove_account(self, account_address: str):
         del self.__accounts[account_address]
 
     def change_account(self, account_address: str):
         if account_address not in self.__accounts:
-            raise KeyError("There is no account with such an address in wallet")
+            raise KeyError(
+                "There is no account with such an address in wallet")
         self.active_account = self.__accounts[account_address]
 
     def construct_transaction(self, contract_method: web3._utils.datatypes, parameters: dict = None) -> dict:
@@ -144,17 +150,18 @@ def construct_transaction(self, contract_method: web3._utils.datatypes, paramete
                 raise ValueError(
                     "Can't construct transaction without fee currency, set fee currency please")
 
-            nonce = self.web3.eth.getTransactionCount(self.active_account.address)
+            nonce = self.web3.eth.getTransactionCount(
+                self.active_account.address)
             gas_price = self._gas_price if self._gas_price else self.get_network_gas_price()
             base_rows = {'nonce': nonce, 'gasPrice': gas_price, 'gas': self._gas,
-                            'feeCurrency': self._fee_currency, 'from': self.active_account.address}
+                         'feeCurrency': self._fee_currency, 'from': self.active_account.address}
 
             if self._gateway_fee_recipient:
                 base_rows['gatewayFeeRecipient'] = self._gateway_fee_recipient
 
             if self._gateway_fee:
                 base_rows['gatewayFee'] = self._gateway_fee
-            
+
             if parameters:
                 for k, item in parameters.items():
                     base_rows[k] = item
@@ -166,36 +173,62 @@ def construct_transaction(self, contract_method: web3._utils.datatypes, paramete
             raise Exception(
                 f"Error while construct transaction: {sys.exc_info()[1]}")
 
-    def sign_transaction(self, tx: dict) -> SignedTransaction:
+    def sign_transaction(self, tx: dict) -> 'RawSignedTransaction':
         """
-        Takes transaction dict, signs it and sends to the blockchain
+        Takes transaction dict, signs it and returns raw signed transaciton
 
         Parameters:
             tx: dict
                 transaction data in dict
         Returns:
-            signed transaction object
+            signed raw transaction
         """
         try:
             signed_tx = self.active_account.sign_transaction(tx)
-            return signed_tx
+            print(f"Signed tx localy: {signed_tx}")
+            return signed_tx.rawTransaction
+        except:
+            raise Exception(
+                f"Error while sign transaction: {sys.exc_info()[1]}")
+
+    def sign_message(self, message: 'bytes str') -> 'Signature':
+        signer_priv_key = eth_keys.keys.PrivateKey(self.active_account._private_key)
+        signature = signer_priv_key.sign_msg(message)
+        return signature
+
+    def sign_transaction_with_provider(self, tx: dict) -> 'RawSignedTransaction':
+        """
+        Takes transaction dict, signs it and returns raw signed transaciton
+
+        Parameters:
+            tx: dict
+                transaction data in dict
+        Returns:
+            signed raw transaction
+        """
+        try:
+            signed_tx = self.web3.eth.signTransaction(tx)
+            return signed_tx.raw
         except:
             raise Exception(
                 f"Error while sign transaction: {sys.exc_info()[1]}")
 
-    def construct_and_sign_transaction(self, contract_method: web3._utils.datatypes) -> SignedTransaction:
+    def construct_and_sign_transaction(self, contract_method: web3._utils.datatypes) -> 'RawSignedTransaction':
         """
         Takes contract method call object, call method to build transaction and return signed transaction
 
         Parameters:
             contract_method: web3._utils.datatypes
                 object of contract method call
         Returns:
-            signed transaction object
+            signed raw transaction
         """
         try:
             tx = self.construct_transaction(contract_method)
-            signed_tx = self.sign_transaction(tx)
+            if self.sign_with_provider:
+                signed_tx = self.sign_transaction_with_provider(tx)
+            else:
+                signed_tx = self.sign_transaction(tx)
             return signed_tx
         except:
             raise Exception(
@@ -214,14 +247,19 @@ def send_transaction(self, contract_method: web3._utils.datatypes, parameters: d
         """
         try:
             tx = self.construct_transaction(contract_method, parameters)
-            signed_tx = self.sign_transaction(tx)
-            return self.push_tx_to_blockchain(signed_tx.rawTransaction)
+            if self.sign_with_provider:
+                signed_tx = self.sign_transaction_with_provider(tx)
+            else:
+                signed_tx = self.sign_transaction(tx)
+
+            return self.push_tx_to_blockchain(signed_tx)
         except ValueError as e:
             error_message = ast.literal_eval(str(e))['message']
             if error_message == 'intrinsic gas too low':
                 gas = gas + self.gas_increase_step if gas else self._gas + self.gas_increase_step
                 if gas > self.threshold_gas_value:
-                    raise Exception(f"Transaction requires a lot of gas use({gas}), if you want to send transaction set higher gas value and increase threshold gas value")
+                    raise Exception(
+                        f"Transaction requires a lot of gas use({gas}), if you want to send transaction set higher gas value and increase threshold gas value")
                 self.send_transaction(contract_method, parameters={'gas': gas})
             else:
                 raise ValueError(error_message)