def post(self, request): serializer_input = addresses.NewAddressesPostParametersSerializer(data=request.DATA) if serializer_input.is_valid(): currency = serializer_input.data["currency"] wallet = serializer_input.data["wallet"] btc_rpc_call = BTCRPCCall(wallet=wallet, currency=currency) #check is on testnet or not. is_test_net = constantutil.check_service_is_test_net(btc_rpc_call) logger.info("quantity is " + str(serializer_input.data["quantity"]) + ".") new_addresses = [] for x in xrange(0, int(serializer_input.data[attributeConst.QUANTITY])): new_address = btc_rpc_call.do_get_new_address() btc_rpc_call.do_set_account(new_address, new_address) new_addresses.append(new_address) new_addresses_response = addresses.NewAddresses(addresses=new_addresses, test=is_test_net) addresses_serializer = addresses.NewAddressesSerializer(data=new_addresses_response.__dict__) if addresses_serializer.is_valid(): return Response(addresses_serializer.data, status=status.HTTP_201_CREATED) else: return Response(addresses_serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE) return Response(serializer_input.errors, status=status.HTTP_400_BAD_REQUEST)
def __init__(self): self.yml_config = ConfigFileReader() self.fee = self.yml_config.get_reserved_fee_for_transferring( currency='btc') self.confirms = self.yml_config.get_min_transfer_confirmations( currency='btc') self.btc_rpc_call = BTCRPCCall(wallet='receive', currency='btc') self.coin_to_be_send_dict = self.__init_dict_of_accounts()
def post(self, request): log.info(request.DATA) post_serializers = check_multi_receives.PostParametersSerializer(data=request.DATA) btc_rpc_call = BTCRPCCall() is_test_net = constantutil.check_service_is_test_net(btc_rpc_call) response_list = [] if post_serializers.is_valid(): log.info(post_serializers.data["transactions"]) transactions = post_serializers.data["transactions"] for transaction in transactions: log.info(transaction) address_validation = btc_rpc_call.do_validate_address(address=transaction["address"]) if address_validation["isvalid"] is False: return Response( transaction["address"] + " is not a valid address", status=status.HTTP_400_BAD_REQUEST ) received_with_risk = self.__receive_amount_for_risk( wallet_address=transaction["address"], expected_amount=transaction["amount"], btc_service=btc_rpc_call, ) tx_ids = self.__get_txIds(transaction["address"], btc_service=btc_rpc_call) log.info(tx_ids) log.info(Decimal(received_with_risk["result"])) response = check_multi_receives.ReceiveInformationResponse( currency=transaction["currency"], address=transaction["address"], received=Decimal(received_with_risk["result"]), risk=received_with_risk["risk"], txs=tx_ids, ) response_list.append(response.__dict__) receives_response = check_multi_receives.ReceivesInformationResponse( receives=response_list, test=is_test_net ) response_dict = receives_response.__dict__ response_serializer = check_multi_receives.ReceivesInformationResponseSerializer(data=response_dict) if response_serializer.is_valid(): return Response(response_serializer.data, status=status.HTTP_201_CREATED) else: return Response(response_serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE) return Response(post_serializers.errors, status=status.HTTP_400_BAD_REQUEST)
def __init__(self): self.yml_config = ConfigFileReader() self.fee = self.yml_config.get_reserved_fee_for_transferring(currency='btc') self.confirms = self.yml_config.get_min_transfer_confirmations(currency='btc') self.btc_rpc_call = BTCRPCCall(wallet='receive', currency='btc') self.coin_to_be_send_dict = self.__init_dict_of_accounts()
def post(self, request): post_serializers = wallet_balance.GetWalletBalancePostParameterSerializer(data=request.DATA) wallet_balance_response_list = [] if post_serializers.is_valid(): currency = post_serializers.data["currency"] wallet_list = yml_config.get_wallet_list(currency) log.info(wallet_list) for wallet in wallet_list: log.info(wallet) btc_rpc_call = BTCRPCCall(wallet=wallet, currency=currency) is_test_net = constantutil.check_service_is_test_net(btc_rpc_call) log.info(is_test_net) balance = btc_rpc_call.get_wallet_balance() log.info(format(balance, '0.8f')) wallet_balance_response = wallet_balance.WalletBalanceResponse(wallet=wallet, balance=Decimal(balance), test=is_test_net) log.info(wallet_balance_response.__dict__) wallet_balance_response_list.append(wallet_balance_response.__dict__) wallets_balance_response = wallet_balance.WalletsBalanceResponse(wallets=wallet_balance_response_list) wallets_balance_response_serializer = \ wallet_balance.WalletsBalanceResponseSerializer(data=wallets_balance_response.__dict__) if wallets_balance_response_serializer.is_valid(): return Response(wallets_balance_response_serializer.data, status=status.HTTP_201_CREATED) else: return Response(wallets_balance_response_serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE) return Response(post_serializers.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = send.SendFromPostParametersSerializer(data=request.DATA) #from_account_balance = btc_rpc_call.get_balance(account=serializer) if serializer.is_valid(): currency = serializer.data["currency"] btc_rpc_call = BTCRPCCall(wallet=serializer.data["wallet"], currency=currency) #check is testnet or not is_test_net = constantutil.check_service_is_test_net(btc_rpc_call) from_account = serializer.data["fromAddress"] to_address = serializer.data["toAddress"] fee_limit = serializer.data["feeLimit"] send_amount = serializer.data["amount"] balance = btc_rpc_call.get_balance(account=from_account) from_account_is_valid = (btc_rpc_call.do_validate_address(address=from_account))["isvalid"] to_address_is_valid = (btc_rpc_call.do_validate_address(address=to_address))["isvalid"] if not from_account_is_valid: response_serializer = self.__send_to(send_status="NOK", message="invalid send from address %s" % from_account, test=is_test_net) return Response(data=response_serializer.data, status=status.HTTP_406_NOT_ACCEPTABLE) if not to_address_is_valid: response_serializer = self.__send_to(send_status="NOK", message="invalid send to address %s" % to_address, test=is_test_net) return Response(data=response_serializer.data, status=status.HTTP_406_NOT_ACCEPTABLE) if (send_amount + fee_limit) > balance: response_serializer = self.__send_to(send_status="NOK", message="There is no enough fund from %s" % from_account, test=is_test_net) return Response(data=response_serializer.data, status=status.HTTP_406_NOT_ACCEPTABLE) try: send_response_tx_id = btc_rpc_call.send_from(from_account=from_account, to_address=to_address, amount=float(send_amount)) transaction = btc_rpc_call.do_get_transaction(send_response_tx_id) log.info(abs(transaction["fee"])) send_response = SendFromResponse(tx_id=send_response_tx_id, status="OK", fee=abs(transaction["fee"]), test=is_test_net) send_response_serializer = SendFromResponseSerializer(send_response) except JSONRPCException as ex: log.info("Error: %s" % ex.error['message']) send_response = SendFromResponse(status="NOK", message=ex.error['message'], test=is_test_net) send_response_serializer = SendFromResponseSerializer(send_response) return Response(data=send_response_serializer.data, status=status.HTTP_200_OK)
def __get_txIds(self, account="", btc_service=BTCRPCCall()): if not isinstance(btc_service, BTCRPCCall): raise TypeError("Expected object BTCRPCCall, got %s" % (type(btc_service),)) transactions = btc_service.list_transactions(account=account, count=88) transactions_with_tx_id = [] for transaction in transactions: if 'txid' in transaction and transaction['category'] == 'receive': transaction_with_tx_id = check_multi_receives.TxIdTransaction(txid=transaction['txid'], received=transaction['amount'], confirmations=transaction['confirmations'], date=datetime.fromtimestamp(transaction['time'])) transactions_with_tx_id.append(transaction_with_tx_id.__dict__) # txIds = map(lambda transaction: transaction['txid'], transactions_with_tx_id) return transactions_with_tx_id
def __receive_amount_for_risk(self, wallet_address="", tx_ids=[], btc_service=BTCRPCCall()): if not isinstance(btc_service, BTCRPCCall): raise TypeError("Expected object BTCRPCCall, got %s" % (type(btc_service),)) result = Decimal( btc_service.amount_received_by_address(address=wallet_address, confirms=RISK_HIGH_CONFIRMATIONS)) low_risk_counter = 0 medium_risk_counter = 0 high_risk_counter = 0 for tx_id in tx_ids: log.info("tx_id confirmation is %d.", tx_id["confirmations"]) if tx_id["confirmations"] == RISK_HIGH_CONFIRMATIONS: high_risk_counter += 1 if tx_id["confirmations"] >= RISK_MEDIUM_CONFIRMATIONS and tx_id["confirmations"] < RISK_LOW_CONFIRMATIONS: medium_risk_counter += 1 if tx_id["confirmations"] >= RISK_LOW_CONFIRMATIONS: low_risk_counter += 1 log.info("low_risk_counter: %d, medium_risk_counter: %d, high_risk_counter: %d", low_risk_counter, medium_risk_counter, high_risk_counter) if high_risk_counter >= 1: log.info("received with 0 confirmed") log.info(result) log.info("high") return {"result": result, "risk": 'high'} if medium_risk_counter >= 1: log.info("received with 1 confirmed") log.info(result) log.info("medium") return {"result": result, "risk": 'medium'} if low_risk_counter >= 1: log.info("received with 6 confirmed") log.info(result) log.info("low") return {"result": result, "risk": 'low'}
def post(self, request): log.info(request.data) post_serializers = check_multi_receives.PostParametersSerializer(data=request.data) response_list = [] if post_serializers.is_valid(): log.info(post_serializers.data["transactions"]) transactions = post_serializers.data["transactions"] try: btc_rpc_call = BTCRPCCall() is_test_net = constantutil.check_service_is_test_net(btc_rpc_call) for transaction in transactions: log.info(transaction) transaction_address = transaction["address"] address_validation = btc_rpc_call.do_validate_address(address=transaction_address) if address_validation["isvalid"] is False: return Response(transaction_address + " is not a valid address", status=status.HTTP_400_BAD_REQUEST) if address_validation["ismine"] is False: log.info(transaction_address + " is not an address of the wallet") return Response(transaction_address + " is not an address of the wallet", status=status.HTTP_400_BAD_REQUEST) tx_ids = self.__get_txIds(transaction["address"], btc_service=btc_rpc_call) log.debug(tx_ids) received_with_risk = self.__receive_amount_for_risk(wallet_address=transaction_address, tx_ids=tx_ids, btc_service=btc_rpc_call) received = Decimal(received_with_risk["result"]) if received_with_risk else 0.0 risk = received_with_risk["risk"] if received_with_risk else "low" log.info("received: %f, risk: %s", received, risk) response = check_multi_receives.ReceiveInformationResponse(currency=transaction["currency"], address=transaction_address, received=received, risk=risk, txs=tx_ids) print(address_validation) response_list.append(response.__dict__) receives_response = check_multi_receives.ReceivesInformationResponse(receives=response_list, test=is_test_net) except JSONRPCException as ex: log.error("Error: %s" % ex.error['message']) error_message = "Bitcoin RPC error, check if username and password for node is correct. Message from " \ "python-bitcoinrpc: " + ex.message receives_response = check_multi_receives.ReceivesInformationResponse(receives=response_list, test=True, error=1, error_message=error_message ) except socket_error as serr: if serr.errno != errno.ECONNREFUSED: receives_response = check_multi_receives.ReceivesInformationResponse(receives=[], test=True, error=1, error_message="A general socket error was raised." ) else: receives_response = check_multi_receives.ReceivesInformationResponse(receives=[], test=True, error=1, error_message="Connection refused error, " "check if the wallet node is down." ) response_dict = receives_response.__dict__ response_serializer = check_multi_receives.ReceivesInformationResponseSerializer(data=response_dict) if response_serializer.is_valid(): return Response(response_serializer.data, status=status.HTTP_201_CREATED) else: return Response(response_serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE) return Response(post_serializers.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): global response_serializer post_serializer = transfers_using_sendtoaddress.PostParametersSerializer( data=request.data) yml_config = ConfigFileReader() if post_serializer.is_valid(): transfer_list = post_serializer.data["transfers"] response_list = [] try: btc_rpc_call = BTCRPCCall() is_test_net = constantutil.check_service_is_test_net( btc_rpc_call) for transfer in transfer_list: log.info(transfer) currency = transfer["currency"] txFee = transfer["txFee"] send_amount = transfer["amount"] log.info(send_amount) to_address = yml_config.get_safe_address_to_be_transferred( currency=currency) log.info("%s, %s, %s" % (currency, to_address, send_amount)) to_address_is_valid = (btc_rpc_call.do_validate_address( address=to_address))["isvalid"] log.info("%s" % (to_address_is_valid)) if to_address_is_valid: try: if lock.locked() is False: lock.acquire() btc_rpc_call.set_tx_fee(txFee) send_response_tx_id = btc_rpc_call.send_to_address( address=to_address, amount=send_amount) lock.release() transaction = btc_rpc_call.do_get_transaction( send_response_tx_id) response = \ transfers_using_sendtoaddress.TransferInformationResponse(currency=currency, to_address=to_address, amount=Decimal(str(send_amount)), fee=abs(transaction["fee"]), message="Transfer is done", status="ok", txid=send_response_tx_id) except JSONRPCException as ex: if lock.locked() is True: lock.release() log.error("Error: %s" % ex.error['message']) response = transfers_using_sendtoaddress.TransferInformationResponse( currency=currency, to_address=to_address, amount=Decimal(str(send_amount)), message=ex.error['message'], status="fail", txid="") except (LockTimeoutException, LockException): log.error("Error: %s" % "LockTimeoutException or LockException") response = transfers_using_sendtoaddress.TransferInformationResponse( currency=currency, to_address=to_address, amount=Decimal(str(send_amount)), message="LockTimeoutException or LockException", status="fail", txid="") except (ConnectionError, ServerDown): log.error( "Error: ConnectionError or ServerDown exception" ) response = transfers_using_sendtoaddress.TransferInformationResponse( currency=currency, to_address=to_address, amount=Decimal(str(send_amount)), message= "Error: ConnectionError or ServerDown exception", status="fail", txid="") response_list.append(response.__dict__) else: log.info("do nothing") response = transfers_using_sendtoaddress.TransferInformationResponse( currency=currency, to_address=to_address, amount=Decimal(str(send_amount)), message="to_address is not valid", status="fail", txid="") response_list.append(response.__dict__) log.info(response_list) transfers_response = transfers_using_sendtoaddress.TransfersInformationResponse( transfers=response_list, test=is_test_net) except JSONRPCException as ex: if lock.locked() is True: lock.release() log.error("Error: %s" % ex.error['message']) transfers_response = transfers_using_sendtoaddress.TransfersInformationResponse( transfers=[], test=True, error=1, error_message= "Bitcoin RPC error, check if username and password " "for node is correct. Message from python-bitcoinrpc: " + ex.message) except socket_error as serr: if lock.locked() is True: lock.release() if serr.errno != errno.ECONNREFUSED: transfers_response = transfers_using_sendtoaddress.TransfersInformationResponse( transfers=[], test=True, error=1, error_message="A general socket error was raised.") else: transfers_response = transfers_using_sendtoaddress.TransfersInformationResponse( transfers=[], test=True, error=1, error_message= "Connection refused error, check if the wallet" " node is down.") response_dict = transfers_response.__dict__ response_serializer = transfers_using_sendtoaddress.TransfersInformationResponseSerializer( data=response_dict) if response_serializer.is_valid(): return Response(response_serializer.data, status=status.HTTP_200_OK) else: return Response(response_serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE) return Response(post_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class BTCCurrencyTransfer(AbstractDigitalCurrencyTransfer): def __init__(self): self.yml_config = ConfigFileReader() self.fee = self.yml_config.get_reserved_fee_for_transferring( currency='btc') self.confirms = self.yml_config.get_min_transfer_confirmations( currency='btc') self.btc_rpc_call = BTCRPCCall(wallet='receive', currency='btc') self.coin_to_be_send_dict = self.__init_dict_of_accounts() def __get_total_amount_in_wallet(self): if self.coin_to_be_send_dict.values(): return reduce(lambda (coin_value), y: coin_value + y, self.coin_to_be_send_dict.values()) else: return 0 def __init_dict_of_accounts(self): lists_received_by_account = self.btc_rpc_call.list_accounts( self.confirms) dict_coin_to_be_send = {} for received_account, amount in lists_received_by_account.iteritems(): amount_balance = self.btc_rpc_call.get_balance( received_account, self.confirms) if amount_balance > 0: dict_coin_to_be_send[received_account] = amount_balance if amount_balance < 0: logger_file.error("Minus value is in the account %s ", received_account) raise SystemExit("Minus value is in an account!!") return dict_coin_to_be_send def __create_an_address_with_account_assigned(self): new_address = self.btc_rpc_call.do_get_new_address() self.btc_rpc_call.do_set_account(new_address, new_address) return new_address def main(self): min_transfer = self.yml_config.get_min_transfer_amount(currency='btc') total_amount = self.__get_total_amount_in_wallet() balance_amount = (self.btc_rpc_call.do_getinfo())['balance'] amount_thresh = abs(balance_amount - total_amount) if amount_thresh > 0.0001: logger_file.error( "%d confirmed amount %s != the total receiving balance %s, need more confirms", int(self.confirms), total_amount, balance_amount) logger_file.info("Total amount of coins to be transfer: %f" % total_amount) if total_amount >= min_transfer: logger_file.info("Init transferring...") logger_file.info( "Creating a temporary address for moving coins...") btc_account = self.__create_an_address_with_account_assigned() logger_file.info("Starting to move coins to %s", btc_account) for received_account, amount in self.coin_to_be_send_dict.iteritems( ): """ logger_file.info("%s, %s, %f", received_account, self.btc_rpc_call.get_addresses_by_account(received_account), amount) """ if self.btc_rpc_call.move(received_account, btc_account, float(amount)): pass else: logger_file.error("Fail to move coins to from %s to %s!", received_account, btc_account) send_to_address = self.yml_config.get_safe_address_to_be_transferred( currency='btc') amount_to_transfer = float(total_amount) - float(self.fee) logger_file.info( "Starting transferring %f coins to address: %s from account: %s", amount_to_transfer, send_to_address, btc_account) self.btc_rpc_call.send_from(btc_account, send_to_address, amount_to_transfer) logger_file.info("Transfer is done") else: logger_file.info("It is not ready to do the coin transferring!") def main_test(self): total_amount = self.__get_total_amount_in_wallet() logger_file.info(total_amount) balance_amount = (self.btc_rpc_call.do_getinfo())['balance'] logger_file.info(balance_amount) logger_file.info(len(self.coin_to_be_send_dict)) for received_account, amount in self.coin_to_be_send_dict.iteritems(): logger_file.info("account: %s, amount: %f", received_account, amount)
class BTCCurrencyTransfer(AbstractDigitalCurrencyTransfer): def __init__(self): self.yml_config = ConfigFileReader() self.fee = self.yml_config.get_reserved_fee_for_transferring(currency='btc') self.confirms = self.yml_config.get_min_transfer_confirmations(currency='btc') self.btc_rpc_call = BTCRPCCall(wallet='receive', currency='btc') self.coin_to_be_send_dict = self.__init_dict_of_accounts() def __get_total_amount_in_wallet(self): if self.coin_to_be_send_dict.values(): return reduce(lambda (coin_value), y: coin_value + y, self.coin_to_be_send_dict.values()) else: return 0 def __init_dict_of_accounts(self): lists_received_by_account = self.btc_rpc_call.list_accounts(self.confirms) dict_coin_to_be_send = {} for received_account, amount in lists_received_by_account.iteritems(): amount_balance = self.btc_rpc_call.get_balance(received_account, self.confirms) if amount_balance > 0: dict_coin_to_be_send[received_account] = amount_balance if amount_balance < 0: logger_file.error("Minus value is in the account %s ", received_account) raise SystemExit("Minus value is in an account!!") return dict_coin_to_be_send def __create_an_address_with_account_assigned(self): new_address = self.btc_rpc_call.do_get_new_address() self.btc_rpc_call.do_set_account(new_address, new_address) return new_address def main(self): min_transfer = self.yml_config.get_min_transfer_amount(currency='btc') total_amount = self.__get_total_amount_in_wallet() balance_amount = (self.btc_rpc_call.do_getinfo())['balance'] amount_thresh = abs(balance_amount - total_amount) if amount_thresh > 0.0001: logger_file.error("%d confirmed amount %s != the total receiving balance %s, need more confirms", int(self.confirms), total_amount, balance_amount) logger_file.info("Total amount of coins to be transfer: %f" % total_amount) if total_amount >= min_transfer: logger_file.info("Init transferring...") logger_file.info("Creating a temporary address for moving coins...") btc_account = self.__create_an_address_with_account_assigned() logger_file.info("Starting to move coins to %s", btc_account) for received_account, amount in self.coin_to_be_send_dict.iteritems(): """ logger_file.info("%s, %s, %f", received_account, self.btc_rpc_call.get_addresses_by_account(received_account), amount) """ if self.btc_rpc_call.move(received_account, btc_account, float(amount)): pass else: logger_file.error("Fail to move coins to from %s to %s!", received_account, btc_account) send_to_address = self.yml_config.get_safe_address_to_be_transferred(currency='btc') amount_to_transfer = float(total_amount) - float(self.fee) logger_file.info("Starting transferring %f coins to address: %s from account: %s", amount_to_transfer, send_to_address, btc_account) self.btc_rpc_call.send_from(btc_account, send_to_address, amount_to_transfer) logger_file.info("Transfer is done") else: logger_file.info("It is not ready to do the coin transferring!") def main_test(self): total_amount = self.__get_total_amount_in_wallet() logger_file.info(total_amount) balance_amount = (self.btc_rpc_call.do_getinfo())['balance'] logger_file.info(balance_amount) logger_file.info(len(self.coin_to_be_send_dict)) for received_account, amount in self.coin_to_be_send_dict.iteritems(): logger_file.info("account: %s, amount: %f", received_account, amount)
def post(self, request): post_serializer = transfers.PostParametersSerializer(data=request.DATA) # from_account_balance = btc_rpc_call.get_balance(account=serializer) yml_config = ConfigFileReader() if post_serializer.is_valid(): btc_rpc_call = BTCRPCCall() is_test_net = constantutil.check_service_is_test_net(btc_rpc_call) transfer_list = post_serializer.data["transfers"] log.info(is_test_net) response_list = [] for transfer in transfer_list: log.info(transfer) currency = transfer["currency"] from_address = transfer["from_address"] send_amount = transfer["amount"] log.info(send_amount) to_address = yml_config.get_safe_address_to_be_transferred(currency=currency) log.info("%s, %s, %s, %s" % (currency, from_address, to_address, send_amount)) #log.info("%s %s" % currency, from_address) from_address_is_valid = (btc_rpc_call.do_validate_address(address=from_address))["isvalid"] to_address_is_valid = (btc_rpc_call.do_validate_address(address=to_address))["isvalid"] log.info("%s, %s" % (from_address_is_valid, to_address_is_valid)) if from_address_is_valid and to_address_is_valid: try: send_response_tx_id = btc_rpc_call.send_from(from_account=from_address, to_address=to_address, amount=send_amount) response = transfers.TransferInformationResponse(currency=currency, from_address=from_address, to_address=to_address, amount=Decimal(str(send_amount)), status="ok", txid=send_response_tx_id) response_list.append(response.__dict__) except JSONRPCException as ex: log.info("Error: %s" % ex.error['message']) response = transfers.TransferInformationResponse(currency=currency, from_address=from_address, to_address=to_address, amount=Decimal(str(send_amount)), status="fail", txid="") response_list.append(response.__dict__) else: log.info("do nothing") response = transfers.TransferInformationResponse(currency=currency, from_address=from_address, to_address=to_address, amount=Decimal(str(send_amount)), status="fail", txid="") response_list.append(response.__dict__) log.info(response_list) transfers_response = transfers.TransfersInformationResponse(transfers=response_list, test=is_test_net) response_dict = transfers_response.__dict__ response_serializer = transfers.TransfersInformationResponseSerializer(data=response_dict) if response_serializer.is_valid(): return Response(response_serializer.data, status=status.HTTP_200_OK) else: return Response(response_serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE) return Response(post_serializers.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer_post = send_many_vo.SendManyPostParametersSerializer( data=request.data) if serializer_post.is_valid(): log.info(serializer_post.data) currency = serializer_post.data["currency"] wallet = serializer_post.data["wallet"] txFee = serializer_post.data["txFee"] btc_rpc_call = BTCRPCCall(wallet=wallet, currency=currency) from_account = serializer_post.data['fromAddress'] log.info(from_account) amounts = serializer_post.data['toSend'] amounts_dict = dict() for amount in amounts: if amount['toAddress'] in amounts_dict: #As the values in amounts_dict[amount['toAddress']] and amount['amount'] is a string, They need to be converted current_amount = float(amounts_dict[amount['toAddress']]) extra_amount = float(amount['amount']) new_amount = current_amount + extra_amount amounts_dict[amount['toAddress']] = '%.9f' % new_amount else: amounts_dict[amount['toAddress']] = amount['amount'] response = None try: is_test_net = constantutil.check_service_is_test_net( btc_rpc_call) if lock.locked() is False: lock.acquire() btc_rpc_call.set_tx_fee(txFee) isSuccess, result = btc_rpc_call.send_many( from_account=from_account, amounts=amounts_dict) lock.release() if (isSuccess): log.info(result) transaction = btc_rpc_call.do_get_transaction(result) if transaction is None: response = send_many_vo.SendManyResponse( status=status.HTTP_500_INTERNAL_SERVER_ERROR, fee=0, message="BTC server - " + wallet + "is done.", test=is_test_net, error=1) else: response = send_many_vo.SendManyResponse( tx_id=result, status=status.HTTP_200_OK, fee=abs(transaction["fee"]), message="Send many is done.", test=is_test_net) elif result is not None and isinstance( result, JSONRPCException): if lock.locked() is True: lock.release() log.info("Error: %s" % result.error['message']) response = send_many_vo.SendManyResponse( status=status.HTTP_500_INTERNAL_SERVER_ERROR, fee=0, message=result.error['message'], test=is_test_net, error=1) elif result is not None and isinstance( result, socket.error): log.info(result.errno == errno.ECONNREFUSED) log.info(result.message) response = send_many_vo.SendManyResponse( status=status.HTTP_500_INTERNAL_SERVER_ERROR, fee=0, message=result.message, test=is_test_net, error=1) except (LockTimeoutException, LockException): is_test_net = constantutil.check_service_is_test_net( btc_rpc_call) log.error("Error: %s" % "LockTimeoutException or LockException") response = send_many_vo.SendManyResponse( status=status.HTTP_500_INTERNAL_SERVER_ERROR, fee=0, message="LockTimeoutException or LockException", test=is_test_net, error=1) except (ConnectionError, ServerDown): log.error("Error: ConnectionError or ServerDown exception") response = send_many_vo.SendManyResponse( status=status.HTTP_500_INTERNAL_SERVER_ERROR, fee=0, message="Error: ConnectionError or ServerDown exception", test=True, error=1) except JSONRPCException as ex: if lock.locked() is True: lock.release() log.error("Error: %s" % ex.error['message']) error_message = "Bitcoin RPC error, check if username and password for node is correct. Message from " \ "python-bitcoinrpc: " + ex.message response = send_many_vo.SendManyResponse( status=status.HTTP_500_INTERNAL_SERVER_ERROR, fee=0, message=error_message, test=True, error=1, error_message=error_message) except socket_error as serr: if lock.locked() is True: lock.release() if serr.errno != errno.ECONNREFUSED: error_message = "A general socket error was raised." response = send_many_vo.SendManyResponse( status=status.HTTP_500_INTERNAL_SERVER_ERROR, fee=0, message=error_message, test=True, error=1, error_message=error_message) else: error_message = "Connection refused error, check if the wallet node is down." response = send_many_vo.SendManyResponse( status=status.HTTP_500_INTERNAL_SERVER_ERROR, fee=0, message=error_message, test=True, error=1, error_message=error_message) if (response is not None): send_many_response_serializer = send_many_vo.SendManyResponseSerializer( data=response.__dict__) else: is_test_net = constantutil.check_service_is_test_net( btc_rpc_call) response = send_many_vo.SendManyResponse( status=status.HTTP_500_INTERNAL_SERVER_ERROR, fee=0, message="Error: response is None", test=is_test_net, error=1) send_many_response_serializer = send_many_vo.SendManyResponseSerializer( data=response.__dict__) if send_many_response_serializer.is_valid(): return Response(send_many_response_serializer.data, status=status.HTTP_200_OK) else: return Response(send_many_response_serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE) return Response(serializer_post.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): post_serializers = wallet_balance.GetWalletBalancePostParameterSerializer( data=request.data) wallet_balance_response_list = [] if post_serializers.is_valid(): currency = post_serializers.data["currency"] wallet_list = yml_config.get_wallet_list(currency) log.info(wallet_list) for wallet in wallet_list: try: log.info(wallet) btc_rpc_call = BTCRPCCall(wallet=wallet, currency=currency) is_test_net = constantutil.check_service_is_test_net( btc_rpc_call) log.info(is_test_net) balance = btc_rpc_call.get_wallet_balance() log.info(format(balance, '0.8f')) wallet_balance_response = wallet_balance.WalletBalanceResponse( wallet=wallet, balance=Decimal(balance), test=is_test_net) log.info(wallet_balance_response.__dict__) wallet_balance_response_list.append( wallet_balance_response.__dict__) except socket_error as serr: if serr.errno != errno.ECONNREFUSED: wallet_balance_response = wallet_balance.WalletBalanceResponse( wallet=wallet, balance=Decimal(0), test=True, error=1, error_message="A general socket error was raised.") wallet_balance_response_list.append( wallet_balance_response.__dict__) else: wallet_balance_response = wallet_balance.WalletBalanceResponse( wallet=wallet, balance=Decimal(0), test=True, error=1, error_message= "Connection refused error, check if the wallet node is down." ) wallet_balance_response_list.append( wallet_balance_response.__dict__) except JSONRPCException as ex: wallet_balance_response = wallet_balance.WalletBalanceResponse( wallet=wallet, balance=Decimal(0), test=True, error=1, error_message= "Bitcoin RPC error, check if username and password for node is correct. Message from python-bitcoinrpc: " + ex.message) wallet_balance_response_list.append( wallet_balance_response.__dict__) wallets_balance_response = wallet_balance.WalletsBalanceResponse( wallets=wallet_balance_response_list) wallets_balance_response_serializer = \ wallet_balance.WalletsBalanceResponseSerializer(data=wallets_balance_response.__dict__) if wallets_balance_response_serializer.is_valid(): return Response(wallets_balance_response_serializer.data, status=status.HTTP_201_CREATED) else: return Response(wallets_balance_response_serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE) return Response(post_serializers.errors, status=status.HTTP_400_BAD_REQUEST)