def sendpycoin(request):
allify = {}
data = {}
if request.method == 'POST':
senderpubkey = request.POST.get('spubkey')
senderprivatekey = request.POST.get('sprikey').strip()
senderwalletid = request.POST.get('swid')
receiver = request.POST.get('pubkey').strip()
receiverhex = hashlib.sha256(base64.b64decode(receiver)).hexdigest()
amount = request.POST.get('amount').strip()
if int(amount) <= 0:
allify['response'] = "fail"
return HttpResponse(json.dumps(allify),
content_type="application/json")
balance = getbalance(senderwalletid)
if balance is None:
balance = 0
if int(amount) > int(balance):
allify['response'] = "fail"
return HttpResponse(json.dumps(allify),
content_type="application/json")
else:
first_timestamp = time.time()
data['senderpublickey'] = str(senderwalletid) #1
data['receiverhex'] = str(receiverhex) #2
data['previous_hash'] = str(
transaction.objects.all().last().blockhash) #3
data['amount'] = str(amount) #4
data['timestamp'] = str(first_timestamp) #5
perfect = miner(first_timestamp, senderwalletid, receiverhex,
amount)
data["nonce"] = str(perfect)
data = collections.OrderedDict(sorted(data.items()))
datashash = hashlib.sha256(
json.dumps(data).encode('utf-8')).hexdigest()
#senderprivatekeyde = base64.b64decode(senderprivatekey)
#rsakey = RSA.importKey(senderprivatekeyde)
#digitalSignature = rsakey.sign(datashash.encode('utf-8'),'')
#digitalSignature = json.dumps(digitalSignature)
newtrans = transaction(
sender=base64.b64encode(senderpubkey.encode('utf-8')),
senderhexdigest=senderwalletid,
receiver=receiver,
receiverhexdigest=receiverhex,
prevblockhash=transaction.objects.all().last().blockhash,
blockhash=datashash,
amount=amount,
nonce=perfect,
first_timestamp=first_timestamp,
#P2PKH=digitalSignature,
verification=True)
newtrans.save()
return render(request, 'ok.html', locals())
def addreward():
utc = arrow.utcnow()
local = utc.to('GMT')
first_timestamp = local.timestamp
nonce = miner(first_timestamp, settings.REWARD_HASH,
settings.NODE_OWNER_WALLET, 100)
blockhash = gethash(settings.REWARD_HASH, settings.NODE_OWNER_WALLET, 100,
first_timestamp, nonce)
digitalSignature = json.dumps("reward")
newtrans = transaction(
sender=settings.REWARD_HASH,
senderwallet=settings.REWARD_HASH,
receiver=settings.NODE_OWNER_WALLET,
prevblockhash=transaction.objects.all().last().blockhash,
blockhash=blockhash,
amount=100.00000000,
nonce=nonce,
first_timestamp=first_timestamp,
P2PKH=digitalSignature,
verification=True)
newtrans.save()
newtrans.refresh_from_db()
ip = ni.ifaddresses('eth0')[ni.AF_INET][0]['addr']
geturl = "http://{}/api/v1/gettransaction/{}/".format(ip, newtrans.id)
test = {
"server": False,
"sender": settings.REWARD_HASH,
"receiver": settings.NODE_OWNER_WALLET,
"prevblockhash": transaction.objects.all().last().blockhash,
"blockhash": blockhash,
"amount": 100.00000000,
"nonce": nonce,
"timestamp": first_timestamp,
"P2PKH": digitalSignature,
"verification": True,
"block": transaction.objects.all().last().id + 1,
"message": "new_transaction",
"url": geturl
}
payload = json.dumps(test)
ws = websocket.WebSocket()
wsip = "ws://{}:9000".format(ip)
ws.connect(wsip)
ws.send(payload)
def syncfirst(host):
url = "http://{}/api/v1/alltransactions/".format(host)
alltrans = requests.get(url).json()
for x in alltrans["alltestsarecomplated"]:
try:
mytransactions = transaction.objects.get(blockhash=x["blockhash"])
except transaction.DoesNotExist:
newtrans = transaction(sender=x["sender"],
senderwallet=x["senderwallet"],
receiver=x["receiver"],
prevblockhash=x["prevblockhash"],
blockhash=x["blockhash"],
amount=x["amount"],
nonce=x["nonce"],
first_timestamp=x["first_timestamp"],
P2PKH=x["P2PKH"],
verification=x["verification"])
newtrans.save()
print("everyting is up-da-te")
def onMessage(self, payload, isBinary):
data = {}
print("onmessage")
allify = {}
if isBinary:
print("Binary message received: {0} bytes".format(len(payload)))
else:
payloaded = json.loads(payload.decode('utf-8'))
print(payloaded["host"])
if str(payloaded["host"]) == str(ip):
print("bu zaten sensin")
else:
payloaded = json.loads(payload.decode('utf-8'))
if 'sender' in payloaded:
data['sender'] = str(payloaded["sender"]) #1
data['receiver'] = str(payloaded["receiver"]) #2
data['previous_hash'] = str(transaction.objects.all().last().blockhash) #3
data['amount'] = str(payloaded["amount"]) #4
data['timestamp'] = str(payloaded["timestamp"]) #5
data["nonce"] = str(payloaded["nonce"])
data = collections.OrderedDict(sorted(data.items()))
datashash = hashlib.sha256(json.dumps(data).encode('utf-8')).hexdigest()
sig = json.loads(payloaded["P2PKH"])
print("datahashhere", datashash.encode('utf-8'))
print("sigbyte is here", sig)
print("sende weas here", payloaded["sender"])
wllt = generate_wallet_from_pkey(payloaded["sender"])
try:
sigbyte = bytes.fromhex(sig)
vk = VerifyingKey.from_string(bytes.fromhex(payloaded["sender"]), curve=SECP256k1)
tt = vk.verify(sigbyte, datashash.encode('utf-8')) # True
except BadSignatureError:
print("unbelieveable")
data["response"] = "unbelieveable"
newtrans = transaction(sender=payloaded["sender"],
senderwallet=wllt,
receiver=payloaded["receiver"],
prevblockhash=transaction.objects.all().last().blockhash,
blockhash=payloaded["blockhash"],
amount=payloaded["amount"],
nonce=payloaded["nonce"],
first_timestamp=payloaded["timestamp"],
P2PKH=payloaded["P2PKH"],
verification=False
).save()
print("badsignature")
data["response"] = "bad signature"
return False
newtrans = transaction(sender=payloaded["sender"],
senderwallet=wllt,
receiver=payloaded["receiver"],
prevblockhash=transaction.objects.all().last().blockhash,
blockhash=payloaded["blockhash"],
amount=payloaded["amount"],
nonce=payloaded["nonce"],
first_timestamp=payloaded["timestamp"],
P2PKH=payloaded["P2PKH"],
verification=True
).save()
data["response"] = "Everything works correctly."
return True
else:
print("other message")
BroadcastServerFactory.broadcast(payload)
def sendosereum(request):
allify = {}
data = {}
if request.method == 'POST':
senderprivatekey = request.POST.get('sprikey')
receiverwallet = request.POST.get('receiverwallet').strip()
amount = request.POST.get('amount').strip()
sender = generate_pubkey_from_prikey(senderprivatekey)
if not receiverwallet:
allify['response'] = "fail"
allify['explain'] = "Please fill the receiver box"
return HttpResponse(json.dumps(allify),
content_type="application/json")
try:
amount = int(request.POST.get('amount').strip())
except ValueError:
allify['response'] = "fail"
allify['explain'] = "Please fill the balance box"
return HttpResponse(json.dumps(allify),
content_type="application/json")
if int(amount) <= 0:
allify['response'] = "fail"
allify['explain'] = "insufficient balance"
return HttpResponse(json.dumps(allify),
content_type="application/json")
balance = getbalance(sender)
if balance is None:
balance = 0
if int(amount) > int(balance):
allify['response'] = "fail"
allify['explain'] = "insufficient balance"
return HttpResponse(json.dumps(allify),
content_type="application/json")
else:
utc = arrow.utcnow()
local = utc.to('GMT')
first_timestamp = local.timestamp
data['sender'] = str(sender) #1
data['receiver'] = str(receiverwallet) #2
data['previous_hash'] = str(
transaction.objects.all().last().blockhash) #3
data['amount'] = str(amount) #4
data['timestamp'] = str(first_timestamp) #5
perfect = miner(first_timestamp, sender, receiverwallet, amount)
data["nonce"] = str(perfect)
data = collections.OrderedDict(sorted(data.items()))
datashash = hashlib.sha256(
json.dumps(data).encode('utf-8')).hexdigest()
try:
sk = SigningKey.from_string(bytes.fromhex(senderprivatekey),
curve=SECP256k1)
vk = sk.get_verifying_key() #public_key
print(vk.to_string().hex())
except UnicodeDecodeError:
data["response"] = "Check your wallet details"
return HttpResponse(json.dumps(data),
content_type="application/json")
print("digital sign ishere", datashash.encode('utf-8'))
digitalSignature = sk.sign(datashash.encode('utf-8'))
digitalSignature = json.dumps(digitalSignature.hex())
wllt = generate_wallet_from_pkey(sender)
newtrans = transaction(
sender=sender,
senderwallet=wllt,
receiver=receiverwallet,
prevblockhash=transaction.objects.all().last().blockhash,
blockhash=datashash,
amount=amount,
nonce=perfect,
first_timestamp=first_timestamp,
P2PKH=digitalSignature,
verification=True)
newtrans.save()
ip = ni.ifaddresses('eth0')[ni.AF_INET][0]['addr']
geturl = "http://{}/api/vi/gettransaction/{}/".format(
ip, newtrans.id)
test = {
"server": False,
"sender": sender,
"receiver": receiverwallet,
"prevblockhash": transaction.objects.all().last().blockhash,
"blockhash": datashash,
"amount": amount,
"nonce": perfect,
"timestamp": first_timestamp,
"P2PKH": digitalSignature,
"verification": True,
"block": transaction.objects.all().last().id + 1,
"message": "new_transaction",
"url": geturl
}
payload = json.dumps(test)
ws = websocket.WebSocket()
wsip = "ws://{}:9000".format(ip)
ws.connect(wsip)
ws.send(payload)
allify['response'] = "ok"
allify['datashash'] = datashash
allify['datastring'] = json.dumps(allify)
return HttpResponse(json.dumps(allify),
content_type="application/json")
