def get_ether_balance(user_name, user_address): """ To Get user token Balance """ try: # Check if the address correspond to the user obj_logger = common_util.MyLogger(logs_directory, category) if not models.find_sql(logger=obj_logger, table_name='address_master', filters={ 'user_name': user_name, 'address': user_address.lower() }): raise custom_exception.UserException( exception_str.UserExceptionStr.not_user_address) return obj_common.get_ether_balance(user_address) except custom_exception.UserException: raise except Exception as e: obj_logger = common_util.MyLogger(logs_directory, category) obj_logger.error_logger('Error get_balance : ' + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.bad_request)
def sign_transaction(from_address, to_address, value, private_key): """ For Signing Transaction """ try: con = obj_common.blockchain_connection(common_util.url) # Sign TODO - Confirm Bid ID transaction = { 'to': web3.Web3().toChecksumAddress(to_address), 'value': web3.Web3().toHex(value), 'gas': gas_limit, 'gasPrice': con.eth.gasPrice, 'nonce': con.eth.getTransactionCount( web3.Web3().toChecksumAddress(from_address)), 'chainId': chainId, } signed = web3.Account.signTransaction(transaction, private_key) return signed.rawTransaction.hex() except Exception as e: obj_logger = common_util.MyLogger(logs_directory, category) obj_logger.error_logger('Error sign_transaction : ' + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.bad_request)
def _unpad(self, s): try: return s[:-ord(s[len(s) - 1:])] except Exception as e: self.obj_logger.error_logger("Error AESCipher _unpad : " + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.some_error_occurred)
def check_if_present(*args): """ For Server Side Checks """ if not all(arg for arg in args): raise custom_exception.UserException( exception_str.UserExceptionStr.specify_required_fields)
def generate_address(user_name, token): try: # Logs obj_logger = common_util.MyLogger(logs_directory, category) # Generate Crypto Secure Number crypto_secure = ''.join( [str(int(math.pow(number, 2))) for number in os.urandom(20)]) # Generate Private Key private_key = web3.Web3().sha3(text=crypto_secure).hex() # Genrate public Address address = web3.Account.privateKeyToAccount(private_key).address.lower() # Encrypt PK enc_pk = common_util.AESCipher(token, log).encrypt(private_key) # Insert in DB models.insert_sql(logger=obj_logger, table_name='address_master', data={ 'user_name': user_name, 'address': address, 'private_key': enc_pk, }) # Check if encryption algorithm pass enc_pk = models.find_sql(obj_logger, 'address_master', { 'user_name': user_name, 'address': address })[0]['private_key'] dec_pk = common_util.AESCipher(token, log).decrypt(enc_pk) if private_key != dec_pk: raise custom_exception.UserException( exception_str.UserExceptionStr.some_error_occurred) redis_conn.sadd('eth_eth_aw_set', address.encode('utf-8')) return address except custom_exception.UserException: raise except Exception as e: obj_logger.error_logger('Error get_balance : ' + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.bad_request)
def _pad(self, s): try: return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs) except Exception as e: self.obj_logger.error_logger("Error AESCipher _pad : " + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.some_error_occurred)
def decrypt(self, enc): try: enc = base64.b64decode(enc) iv = enc[:AES.block_size] cipher = AES.new(self.key, AES.MODE_CBC, iv) return self._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8') except Exception as e: self.obj_logger.error_logger("Error AESCipher decrypt : " + str(e)) raise custom_exception.UserException(exception_str.UserExceptionStr.some_error_occurred)
def encrypt(self, raw): try: raw = self._pad(raw) raw = raw.encode('utf-8') iv = Random.new().read(AES.block_size) cipher = AES.new(self.key, AES.MODE_CBC, iv) return base64.b64encode(iv + cipher.encrypt(raw)) except Exception as e: self.obj_logger.error_logger("Error AESCipher encrypt : " + str(e)) raise custom_exception.UserException(exception_str.UserExceptionStr.some_error_occurred)
def blockchain_connection(self, url): """ Connect To Blockchain Node """ try: provider = web3.Web3().HTTPProvider(url) return web3.Web3(providers=[provider]) except Exception as e: obj_logger = MyLogger(self.logs_directory, self.category) obj_logger.error_logger('Error blockchain_connection : ' + str(e)) raise custom_exception.UserException(exception_str.UserExceptionStr.bad_request)
def get_token_balance(user_name, user_address, contract_address): """ To Get user token Balance """ try: # Check if the address correspond to the user obj_logger = common_util.MyLogger(logs_directory, category) if not models.find_sql(logger=obj_logger, table_name='erc_address_master', filters={ 'user_name': user_name, 'address': user_address }): raise custom_exception.UserException( exception_str.UserExceptionStr.not_user_address) # Create Contract Object obj_contract = create_contract_object(abi_file, contract_address) # RPC method = 'eth_call' data = obj_contract.encodeABI('balanceOf', args=[user_address]) params = [{'to': contract_address, 'data': data}, "latest"] response = obj_common.rpc_request(common_util.url, method, params) result = response['result'] return int(result, 16) except custom_exception.UserException: raise except web3.exceptions.ValidationError as e: obj_logger = common_util.MyLogger(logs_directory, category) obj_logger.error_logger('Error get_balance : ' + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.input_params_wrong) except Exception as e: obj_logger = common_util.MyLogger(logs_directory, category) obj_logger.error_logger('Error get_balance : ' + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.bad_request)
def __init__(self, key, log): try: # Logs self.logs_directory, self.category = get_config(log) self.obj_logger = MyLogger(self.logs_directory, self.category) self.bs = 32 self.key = self.generate_key(key) self.key = hashlib.sha256(self.key.encode()).digest() except Exception as e: if self.obj_logger : self.obj_logger.error_logger("Error AESCipher __init__ : " + str(e)) raise custom_exception.UserException(exception_str.UserExceptionStr.some_error_occurred)
def create_contract_object(abi_file, contract_address): """ Create Contract Object """ try: with open(abi_file, 'r') as abi_definition: abi = json.load(abi_definition) return web3.Web3().eth.contract(address=contract_address, abi=abi) except Exception as e: obj_logger = common_util.MyLogger(logs_directory, category) obj_logger.error_logger('Error create_contract_object : ' + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.bad_request)
def rpc_request(self, url,method,params): """ Custom RPC Method """ try : payload['method'] = method payload['params'] = params response = requests.post(url, data=json.dumps(payload), headers=headers) return json.loads(response.text) except Exception as e: obj_logger = MyLogger(self.logs_directory , self.category) obj_logger.error_logger('rpc_request : ' + str(e)) raise custom_exception.UserException(exception_str.UserExceptionStr.bad_request)
def generate_key(self, key): """ This method is used for creating key for aes cipher :param input: token number :return: sha256 of the input """ try: token_key = hashlib.sha256(key.encode()).hexdigest() l1_token_key = token_key[:l1_start] + token_key[l1_end:] l2_token_key = hashlib.sha256(l1_token_key.encode()).hexdigest() l2_token_key = l2_token_key[l2_start:l2_end] return l2_token_key except Exception as e: self.obj_logger.error_logger("Error generate_key : " + str(e)) raise custom_exception.UserException(exception_str.UserExceptionStr.some_error_occurred)
def get_fee(): """ To Get Token Transfer Fee """ try: # Create connection con = obj_common.blockchain_connection(common_util.url) # RPC gas_price = con.eth.gasPrice fee = gas_limit * gas_price return fee except Exception as e: obj_logger = common_util.MyLogger(logs_directory, category) obj_logger.error_logger('Error get_fee : ' + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.bad_request)
def get_ether_balance(self, address): """ To get balance :param address: :return: balance in wei """ try: # RPC method = 'eth_getBalance' params = [address, 'latest'] response = self.rpc_request(url, method, params) return int(response['result'], 16) except Exception as e: obj_logger = MyLogger(self.logs_directory , self.category) obj_logger.error_logger('Error get_ether_balance : ' + str(e)) raise custom_exception.UserException(exception_str.UserExceptionStr.bad_request)
def sign_transaction(from_address, to_address, value, contract_address, private_key): """ For Signing Transaction """ try: con = obj_common.blockchain_connection(common_util.url) obj_contract = create_contract_object(abi_file, contract_address) data = obj_contract.encodeABI('transfer', args=[to_address, value]) # Sign TODO - Confirm Bid ID transaction = { 'from': from_address, 'to': contract_address, 'data': data, 'gas': gas_limit, 'gasPrice': con.eth.gasPrice, 'nonce': con.eth.getTransactionCount( web3.Web3().toChecksumAddress(from_address)), } signed = web3.Account.signTransaction(transaction, private_key) return signed.rawTransaction.hex() except Exception as e: obj_logger = common_util.MyLogger(logs_directory, category) obj_logger.error_logger('Error sign_transaction : ' + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.bad_request)
def forward_etherum(user_name, token, from_address, to_address, value): """ To Transfer Ethereum """ try: # Get User Ether Balance in Wei eth_balance_wei = obj_common.get_ether_balance(from_address) # Transaction Fee in tx_fee_wei = get_fee() # Check if the transaction fee > eth_balance if tx_fee_wei > eth_balance_wei: raise custom_exception.UserException( exception_str.UserExceptionStr.insufficient_funds_ether) # Decrypt Private Key obj_logger = common_util.MyLogger(logs_directory, category) enc_private_key = models.find_sql(logger=obj_logger, table_name='address_master', filters={ 'user_name': user_name, 'address': from_address })[0]['private_key'] if not enc_private_key: raise custom_exception.UserException( exception_str.UserExceptionStr.not_user_address) private_key = common_util.AESCipher(token, log).decrypt(enc_private_key) # Create Transaction Sign sign = sign_transaction(from_address=from_address, to_address=to_address, value=value, private_key=private_key) # Create Raw Transaction method = 'eth_sendRawTransaction' params = [sign] response = obj_common.rpc_request(common_util.url, method, params) tx_hash = response.get('result', '') if not tx_hash: raise custom_exception.UserException( exception_str.UserExceptionStr.some_error_occurred) return tx_hash except custom_exception.UserException: raise except web3.exceptions.ValidationError as e: obj_logger = common_util.MyLogger(logs_directory, category) obj_logger.error_logger('Error transfer_token : ' + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.input_params_wrong) except Exception as e: obj_logger = common_util.MyLogger(logs_directory, category) obj_logger.error_logger('Error transfer_token : ' + str(e)) raise custom_exception.UserException( exception_str.UserExceptionStr.bad_request) # ERC 20 - ends