def newKeyValue(request):
postBody = request.body
headers = {'Content-Type': 'application/json; charset=UTF-8'}
if request.method == 'OPTIONS':
return HttpResponse()
try:
reqObject = load_json(postBody)
if isinstance(reqObject, dict):
value = reqObject["value"]
if not value:
raise (Exception("body need value param"))
tx = new_keyValue_tx(value)
trans = tx.serialize().replace('"', "'", -1)
resp = utxoBroadTx(trans, tx.ID)
resp['txHash'] = tx.ID
else:
raise (Exception("body need json"))
except Exception as e:
logger.error("newKeyValue error, e=%s, body=%s" % (e, request.body))
traceback.print_exc()
err = {
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -1,
"message": "newKeyValue error "
}
}
return JsonResponse(err)
return JsonResponse(resp)
def newCoinbase(request):
postBody = request.body
#logger.info('newCoinbase, request.body=%s %s' % (request.method, request.body))
headers = {'Content-Type': 'application/json; charset=UTF-8'}
if request.method == 'OPTIONS' or request.method == 'GET':
return HttpResponse()
try:
url = UTXO_URL + '/broadcast_tx'
data = {'tx': postBody}
logger.info('newCoinbase, rawTx=%s' % data)
resp = requests.post(url, data)
logger.info('newCoinbase, resp=%s' % resp.json())
return JsonResponse(resp.json())
except Exception as e:
logger.error("newCoinbase error, e=%s, body=%s" % (e, request.body))
traceback.print_exc()
err = {
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -1,
"message": "newCoinbase error "
}
}
return JsonResponse(err)
return JsonResponse(resp)
def utxoGetBalance(address):
url = UTXO_URL + '/get_balance?address=' + address.lower()
resp = requests.get(url)
resp = json.loads(resp.content.decode("utf-8"))
if resp['code'] != 'success':
logger.error('utxoGetBalance resp error: %s' % resp)
return None
logger.info('utxoGetBalance resp=%s, url=%s' % (resp, url))
return resp['balance']
def tri(request):
postBody = request.body
headers = {'Content-Type': 'application/json; charset=UTF-8'}
if request.method == 'OPTIONS':
return HttpResponse()
supportedMethods = {
'eth_blockNumber': eth_blockNumber,
'net_version': net_version,
'eth_getBalance': eth_getBalance,
'eth_getTransactionByHash': eth_getTransactionByHash,
'eth_gasPrice': eth_gasPrice,
'eth_getTransactionCount': eth_getTransactionCount,
'eth_sendRawTransaction': eth_sendRawTransaction,
'eth_call': eth_call,
'trace_call': trace_call,
'eth_estimateGas': eth_estimateGas,
}
try:
reqObject = load_json(postBody)
if isinstance(reqObject, dict):
method = reqObject["method"]
if not method:
raise (Exception("method not find"))
if not method in supportedMethods:
raise (Exception("method not supported %s" % method))
func = supportedMethods[method]
retObject = func(reqObject)
elif isinstance(reqObject, list):
retObject = []
for reqDict in reqObject:
method = reqDict["method"]
if not method:
raise (Exception("method not find"))
if not method in supportedMethods:
raise (Exception("method not supported %s" % method))
func = supportedMethods[method]
retObjectSingle = func(reqDict)
retObject.append(retObjectSingle)
else:
raise (Exception("method not find"))
except Exception as e:
logger.error("tri receive error, e=%s, body=%s" % (e, request.body))
traceback.print_exc()
err = {
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -1,
"message": "execute " + method + " failed, please try later",
}
}
return JsonResponse(err)
return JsonResponse(retObject, safe=False)
def files(request, fileName):
index = fileName.find('.js.map')
if index != -1:
return HttpResponse()
path = os.path.join(BASE_DIR, 'wallet/static/files/' + fileName)
if not os.path.exists(path):
logger.error("files not exist %s" % path)
return HttpResponse()
file = open(path, 'rb')
response = HttpResponse(content=file)
index = fileName.rfind('.')
postfix = fileName[index + 1:]
types = {
'js': 'application/javascript',
'css': 'text/css',
'wasm': 'application/wasm',
'html': 'text/html',
}
response['Content-Type'] = types[postfix]
return response
def order(request):
try:
params = load_json(request.body)
except Exception as e:
return JsonResponse({"error": True, "msg": "body should json type"})
if not params.get('amount'):
return JsonResponse({"error": True, "msg": "Need param amount"})
if not params.get('destAddress'):
return JsonResponse({"error": True, "msg": "Need param destAddress"})
if not params.get('pair'):
return JsonResponse({"error": True, "msg": "Need param pair"})
if not (params.get('pair') in ["TRIETH", "ETHTRI"]):
return JsonResponse({"error": True, "msg": "Not support pair"})
re_dict = {"error": False, "msg": "", "data": {"input": {}, "output": {}}}
try:
sourceCoin = params['pair'][0:3]
targetCoin = params['pair'][3:]
ce = CoinExchangeList.objects.filter(
source_coin_name=sourceCoin, target_coin_name=targetCoin).first()
targetAmount = Decimal(params['amount']) * Decimal(ce.rate)
if not DBOperation.isBalanceSufficient(targetCoin, targetAmount):
re_dict["error"] = True
re_dict[
"msg"] = "insufficient balance for coin %s of amount %s" % (
targetCoin, targetAmount)
response = JsonResponse(re_dict)
return response
re_dict["data"]["id"] = random_str(100)
re_dict["data"]["amount"] = params['amount']
re_dict["data"]["pair"] = params['pair']
re_dict["data"]["payment_address"] = DBOperation.genNewAddress(
sourceCoin, False)
re_dict["data"]["validFor"] = ce.order_valid_seconds
seconds = time.time()
timestamp = stamp2UTCdatetime(seconds)
re_dict["data"]["timestamp_created"] = timestamp
re_dict["data"]["status"] = "OPEN"
re_dict["data"]["input"]['amount'] = Decimal(params['amount'])
re_dict["data"]["input"]['currency'] = sourceCoin
re_dict["data"]["output"]['amount'] = targetAmount
re_dict["data"]["output"]['currency'] = targetCoin
order = Order()
order.order_id = re_dict["data"]["id"]
order.source_coin_name = sourceCoin
order.source_amount = re_dict["data"]["input"]['amount']
order.target_coin_name = targetCoin
order.target_amount = re_dict["data"]["output"]['amount']
order.create_time_stamp = seconds
order.rate = ce.rate
order.target_coin_address = params.get('destAddress')
order.source_coin_payment_address = re_dict["data"]["payment_address"]
order.source_coin_payment_amount = 0
order.transaction_in_id = 0
order.transaction_out_id = 0
order.is_finished = False
order.save()
logger.info("%s->%s insert order in db, id=%s" %
(sourceCoin, targetCoin, order.id))
response = JsonResponse(re_dict)
except Exception as e:
logger.error(e)
return response
def status(request):
try:
params = load_json(request.body)
except Exception as e:
return JsonResponse({"error": True, "msg": "body should json type"})
if not params.get('orderid'):
return JsonResponse({"error": True, "msg": "Need param orderid"})
seconds = time.time()
timestamp = stamp2UTCdatetime(seconds)
re_dict = {
"error": False,
"msg": "",
"data": {
"id": "",
"status": "OPEN",
"input": {
"status": "",
"amount": "",
"currency": "",
"reference": ""
},
"output": {
"status": "",
"amount": "",
"currency": "",
"reference": ""
}
}
}
re_dict["data"]["id"] = params['orderid']
try:
order = Order.objects.filter(order_id=params['orderid']).first()
except Exception as e:
logger.error(e)
order = None
if not order:
re_dict["error"] = True
re_dict["msg"] = "can not find order"
response = JsonResponse(re_dict)
return response
re_dict["data"]["input"]['amount'] = str(order.source_amount)
re_dict["data"]["input"]['currency'] = order.source_coin_name
re_dict["data"]["output"]['amount'] = str(order.target_amount)
re_dict["data"]["output"]['currency'] = order.target_coin_name
if order.is_finished:
re_dict["data"]["input"]['reference'] = ReqData.getTransactionWebUrl(
order.source_coin_name, order.tx_in_hash)
re_dict["data"]["output"]['reference'] = ReqData.getTransactionWebUrl(
order.target_coin_name, order.tx_out_hash)
re_dict["data"]["status"] = "FILL"
re_dict["data"]["output"]["status"] = "FILL"
re_dict["data"]["input"]["status"] = "RCVE"
response = JsonResponse(re_dict)
return response
if order.tx_in_hash:
if order.source_amount > order.source_coin_payment_amount:
re_dict["data"]["input"][
'reference'] = ReqData.getTransactionWebUrl(
order.source_coin_name, order.tx_in_hash)
re_dict[
"msg"] = "receive amount %s, less than required amount %s" % (
order.source_coin_payment_amount, order.source_amount)
response = JsonResponse(re_dict)
return response
else:
re_dict["data"]["input"][
'reference'] = ReqData.getTransactionWebUrl(
order.source_coin_name, order.tx_in_hash)
re_dict["data"]["status"] = "RCVE"
re_dict["data"]["input"]["status"] = "RCVE"
response = JsonResponse(re_dict)
return response
else:
re_dict["error"] = True
re_dict["msg"] = {}
re_dict["data"] = ""
response = JsonResponse(re_dict)
return response