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
