def node_message(self, node, data):
from node.unl import get_unl_nodes, get_as_node_type
if str(data) == "sendmefullledger":
self.send_full_chain(node)
print("Data Type: " + str(type(data)) + "\n")
if str(data) == "sendmefullnodelist":
self.send_full_node_list(node)
print("Data Type: " + str(type(data)) + "\n")
try:
from node.unl import node_is_unl
if data["fullledger"] == 1 and node_is_unl(
node.id) and Ecdsa.verify(
"fullledger" + data["byte"],
Signature.fromBase64(data["signature"]),
PublicKey.fromPem(node.id)):
print("getting chain")
self.get_full_chain(data["byte"])
except:
pass
try:
from node.unl import node_is_unl
if data["fullnodelist"] == 1 and node_is_unl(
node.id) and Ecdsa.verify(
"fullnodelist" + data["byte"],
Signature.fromBase64(data["signature"]),
PublicKey.fromPem(node.id)):
print("getting node list")
self.get_full_node_list(data["byte"])
except:
pass
try:
if data["transactionrequest"] == 1:
self.get_transaction(data, node)
except Exception as e:
print(e)
pass
try:
if data["transactionresponse"] == 1:
self.get_transaction_response(data, node)
except Exception as e:
print(e)
pass
print("node_message from " + node.id + ": " + str(data))
def createTrans(self, sequance_number, signature, fromUser, toUser, transaction_fee, data, amount, transaction_time, transaction_sender=None):
# Printing the info of tx
dprint("\nCreating the transaction")
dprint("***")
dprint(sequance_number)
dprint(signature)
dprint(fromUser)
dprint(toUser)
dprint(data)
dprint(amount)
dprint("***\n")
# End
# Some data
signature_class = Signature.fromBase64(signature)
temp_signature = signature_class.toBase64()
already_got = self.tx_already_got(temp_signature)
# End
# Validation
dprint("\nValidation")
if Ecdsa.verify((str(sequance_number)+str(fromUser)+str(toUser)+str(data)+str(amount)+str(transaction_fee)+str(transaction_time)), signature_class, PublicKey.fromPem(fromUser)) and not amount < self.minumum_transfer_amount and not transaction_fee < self.transaction_fee and not already_got and not (int(time.time()) - transaction_time) > 60:
dprint("Signature is valid")
dprint("Getsequancenumber: "+str(GetSequanceNumber(fromUser, self)+1))
if sequance_number == (GetSequanceNumber(fromUser, self)+1):
dprint("Sequance number is valid")
balance = GetBalance(fromUser, self)
if balance >= (float(amount)+float(transaction_fee)) and (balance - (float(amount)+float(transaction_fee))) > 2:
dprint("Amount is valid")
# Local saving
the_tx = Transaction(
sequance_number= sequance_number,
signature=temp_signature,
fromUser= fromUser,
toUser=toUser,
data = data,
amount = amount,
transaction_fee= transaction_fee,
time_of_transaction = transaction_time
)
self.pendingTransaction.append(the_tx)
self.change_transaction_fee()
self.save_block()
# End
self.propagating_the_tx(the_tx)
return True
dprint(" Validation end")
def get_candidate_block(self, data, node):
dprint("Getting the candidate block")
from node.unl import node_is_unl
if node_is_unl(node.id) and GetBlock(
).sequance_number == data["sequance_number"]:
dprint("is unl")
signature_list = []
for element in data["transaction"]:
signature_list.append(element["signature"])
dprint("signature_list: " + str(signature_list))
merkle_root_of_signature_list = MerkleTree(
signature_list).getRootHash(
) if len(signature_list) != 0 else "0"
dprint("signatureverify: " + str(
Ecdsa.verify("myblock" + merkle_root_of_signature_list,
Signature.fromBase64(data["signature"]),
PublicKey.fromPem(node.id))))
dprint("publickey from pem: " + str(node.id))
dprint("merkleroot: " + merkle_root_of_signature_list)
if Ecdsa.verify(
"myblock" + merkle_root_of_signature_list +
str(data["sequance_number"]),
Signature.fromBase64(data["signature"]),
PublicKey.fromPem(node.id)):
dprint("ecdsa true")
temp_tx = []
for element in data["transaction"]:
temp_tx.append(Transaction.load_json(element))
data["transaction"] = temp_tx
node.candidate_block = data
def send_my_response_on_transaction(self, temp_transaction, response, transaction_sender):
items = {
"transactionresponse": 1,
"fromUser": mynode.main_node.id,
"response": response,
"transaction_signature": temp_transaction.signature,
"signature": Ecdsa.sign(
response+str(temp_transaction.signature),
PrivateKey.fromPem(Wallet_Import(0, 1))
).toBase64()
}
mynode.main_node.send_data_to_node(transaction_sender, items)
def send_full_blockshash(self, node=None):
dprint("Sending full chain to node or nodes." + " Node: " + str(node))
file = open(TEMP_BLOCKSHASH_PATH, "rb")
SendData = file.read(1024)
while SendData:
data = {
"fullblockshash":
1,
"byte": (SendData.decode(encoding='iso-8859-1')),
"signature":
Ecdsa.sign(
"fullblockshash" + str(
(SendData.decode(encoding='iso-8859-1'))),
PrivateKey.fromPem(Wallet_Import(0, 1))).toBase64()
}
if not node is None:
self.send_data_to_node(node, data)
else:
self.send_data_to_nodes(data)
SendData = file.read(1024)
dprint(SendData)
if not SendData:
data = {
"fullblockshash":
1,
"byte":
"end",
"signature":
Ecdsa.sign("fullblockshash" + "end",
PrivateKey.fromPem(Wallet_Import(
0, 1))).toBase64()
}
if not node is None:
self.send_data_to_node(node, data)
else:
self.send_data_to_nodes(data)
def send(my_public_key, my_private_key, to_user, password, data=None, amount=None):
"""
The main function for sending the transaction.
Inputs:
* my_public_key: Sender's public key.
* my_private_key: Sender's private key.
* to_user: Receiver's address.
* data: A text that can be written into the transaction. (Can be None)
* amount: A int or float amount to be sent. (Can be None)
"""
my_public_key = "".join(
[
l.strip()
for l in my_public_key.splitlines()
if l and not l.startswith("-----")
]
)
system = GetBlock()
sequance_number = GetSequanceNumber(my_public_key, system) + 1
# Get the current fee
transaction_fee = system.transaction_fee
tx_time = int(time.time())
the_tx = system.createTrans(
sequance_number=sequance_number,
signature=Ecdsa.sign(
str(sequance_number)
+ str(my_public_key)
+ str(to_user)
+ str(data)
+ str(amount)
+ str(transaction_fee)
+ str(tx_time),
PrivateKey.fromPem(my_private_key),
).toBase64(),
fromUser=str(my_public_key),
toUser=str(to_user),
data=data,
amount=amount,
transaction_fee=transaction_fee,
transaction_sender=None,
transaction_time=tx_time,
)
SavetoMyTransaction(the_tx)
def send(my_public_key, my_private_key, to_user, data=None, amount=None):
from ledger.ledger_main import get_ledger
system = get_ledger()
sequance_number = (system.getSequanceNumber(my_public_key)) + 1
transaction_fee = 0.02
system.createTrans(
sequance_number=sequance_number,
signature=Ecdsa.sign(
str(sequance_number) + str(my_public_key) + str(to_user) +
str(data) + str(amount) + str(transaction_fee),
PrivateKey.fromPem(my_private_key)).toBase64(),
fromUser=str(my_public_key),
toUser=str(to_user),
data=str(data),
amount=amount,
transaction_fee=transaction_fee)
def send_my_response_on_transaction(self, temp_transaction, response,
transaction_sender):
from node.myownp2pn import MyOwnPeer2PeerNode
MyOwnPeer2PeerNode.main_node.send_to_node(
transaction_sender, {
"transactionresponse":
1,
"fromUser":
MyOwnPeer2PeerNode.main_node.id,
"response":
response,
"transaction_signature":
temp_transaction.signature,
"signature":
Ecdsa.sign(response + str(temp_transaction.signature),
PrivateKey.fromPem(Wallet_Import(0, 1))).toBase64()
})
def get_candidate_block_hash(self, data, node):
dprint("Getting the candidate block hash")
from node.unl import node_is_unl
if node_is_unl(node.id) and GetBlock(
).sequance_number == data["sequance_number"]:
dprint("is unl")
if Ecdsa.verify(
"myblockhash" + data["hash"] +
str(data["sequance_number"]),
Signature.fromBase64(data["signature"]),
PublicKey.fromPem(node.id)):
dprint("ecdsa true")
data["sender"] = node.id
node.candidate_block_hash = data
def get_transaction_response(self, data, node):
#burada bu mesaj gönderen adamın bizim istediğimiz node ve pub key olup olmadığına bakacağız. ayrıca eğer unl listemizdeki bir adamdan evet oyu aldıysak o oyu hayıra çeviremeyiz
from ledger.ledger_main import get_ledger
dprint("Getting the transactions response")
system = get_ledger()
from node.unl import node_is_unl
if node_is_unl(node.id):
for tx in system.validating_list:
if node.id == data["fromUser"] and Ecdsa.verify(
data["response"] + str(data["transaction_signature"]),
Signature.fromBase64(data["signature"]),
PublicKey.fromPem(data["fromUser"])):
if data["transaction_signature"] == tx.signature:
if data["response"] == "TRUE":
tx.valid.append({"data": data, "node": node.id})
system.Verificate_Pending_Trans()
elif data["response"] == "FALSE":
tx.invalid.append({"data": data, "node": node.id})
system.Verificate_Pending_Trans()
def send_my_block_hash(self, nodes):
system = GetBlock()
if system.raund_1 and not system.raund_2:
data = {
"action":
"myblockhash",
"hash":
system.hash,
"sequance_number":
system.sequance_number,
"signature":
Ecdsa.sign(
"myblockhash" + system.hash + str(system.sequance_number),
PrivateKey.fromPem(Wallet_Import(0, 1))).toBase64()
}
for each_node in nodes:
dprint("Raund 2: second ok of get candidate block hashes: " +
str(each_node.__dict__))
self.send_data_to_node(each_node, data)
def send_full_chain(self, node=None):
from config import LEDGER_PATH
dprint("Sending full chain to node or nodes." + " Node: " + str(node))
file = open(LEDGER_PATH, "rb")
SendData = file.read(1024)
while SendData:
data = {
"fullledger":
1,
"byte": (SendData.decode(encoding='iso-8859-1')),
"signature":
Ecdsa.sign(
"fullledger" + str(
(SendData.decode(encoding='iso-8859-1'))),
PrivateKey.fromPem(Wallet_Import(0, 1))).toBase64()
}
if not node == None:
self.send_to_node(node, data)
else:
self.send_to_nodes(data)
SendData = file.read(1024)
def send(my_public_key, my_private_key, to_user, data=None, amount=None):
from ledger.ledger_main import get_ledger
system = get_ledger()
sequance_number = (system.getSequanceNumber(my_public_key)) + 1
transaction_fee = 0.02
my_public_key = "".join([
l.strip() for l in my_public_key.splitlines()
if l and not l.startswith("-----")
])
system.createTrans(
sequance_number=sequance_number,
signature=Ecdsa.sign(
str(sequance_number) + str(my_public_key) + str(to_user) +
str(data) + str(amount) + str(transaction_fee),
PrivateKey.fromPem(my_private_key)).toBase64(),
fromUser=str(my_public_key),
toUser=str(to_user),
data=data,
amount=amount,
transaction_fee=transaction_fee,
my_tx=True)
def send_full_node_list(self, node=None):
file = open(CONNECTED_NODE_PATH, "rb")
SendData = file.read(1024)
while SendData:
data = {
"fullnodelist":
1,
"byte": (SendData.decode(encoding='iso-8859-1')),
"signature":
Ecdsa.sign(
"fullnodelist" + str(
(SendData.decode(encoding='iso-8859-1'))),
PrivateKey.fromPem(Wallet_Import(0, 1))).toBase64()
}
print(data)
print(type(data))
if not node is None:
self.send_data_to_node(node, data)
else:
self.send_data_to_nodes(data)
SendData = file.read(1024)
def send_my_block(self, nodes):
system = GetBlock()
new_list = []
signature_list = []
for element in system.validating_list:
new_list.append(element.dump_json())
signature_list.append(element.signature)
dprint("signature_list: " + str(signature_list))
dprint("publickey from pem: " + str(Wallet_Import(0, 1)))
Merkle_signature_list = MerkleTree(
signature_list).getRootHash() if len(signature_list) != 0 else "0"
dprint("\nmerkleroot: " + Merkle_signature_list)
data = {
"action":
"myblock",
"transaction":
new_list,
"sequance_number":
system.sequance_number,
"signature":
Ecdsa.sign(
"myblock" + Merkle_signature_list +
str(system.sequance_number),
PrivateKey.fromPem(Wallet_Import(0, 1))).toBase64()
}
for each_node in nodes:
dprint("Raund 1: second ok of get candidate block: " +
str(each_node.__dict__))
self.send_data_to_node(each_node, data)
def createTrans(self,
sequance_number,
signature,
fromUser,
toUser,
transaction_fee,
data=None,
amount=None,
transaction_sender=None,
response=False):
dprint("\nCreating transaction.")
signature_class = Signature.fromBase64(signature)
dprint("***")
dprint(sequance_number)
dprint(signature)
dprint(fromUser)
dprint(toUser)
dprint(data)
dprint(amount)
dprint("***\n")
dprint(
Ecdsa.verify((str(sequance_number) + str(fromUser) + str(toUser) +
str(data) + str(amount) + str(transaction_fee)),
signature_class, PublicKey.fromPem(fromUser)))
temp_signature = signature_class.toBase64()
already_in_pending = False
for already_tx in (self.pendingTransaction + self.validating_list):
if already_tx.signature == temp_signature:
already_in_pending = True
if Ecdsa.verify((str(sequance_number) + str(fromUser) + str(toUser) +
str(data) + str(amount) + str(transaction_fee)),
signature_class, PublicKey.fromPem(fromUser)):
if sequance_number == (self.getSequanceNumber(fromUser) +
1) or already_in_pending:
dprint("Sign verify is true.")
if (self.getBalance(fromUser) >=
(float(amount) + float(transaction_fee))
and float(amount) != float(0)) or response == False:
temp_transaction = Transaction(
sequance_number=sequance_number,
signature=signature_class.toBase64(),
fromUser=fromUser,
toUser=toUser,
data=data,
amount=amount,
transaction_fee=transaction_fee)
dprint("Balance controll is true.")
if already_in_pending == False:
self.pendingTransaction.append(temp_transaction)
self.save_ledger()
from node.myownp2pn import MyOwnPeer2PeerNode
dprint("imported myownpeer2peernode")
if transaction_sender is None:
if already_in_pending == False:
MyOwnPeer2PeerNode.main_node.send_to_nodes({
"transactionrequest":
1,
"sequance_number":
sequance_number,
"signature":
signature,
"fromUser":
fromUser,
"to_user":
toUser,
"data":
data,
"amount":
amount,
"transaction_fee":
transaction_fee,
"response":
False
})
else:
dprint(str(response))
if response:
self.send_my_response_on_transaction(
temp_transaction=temp_transaction,
response="TRUE",
transaction_sender=transaction_sender)
if already_in_pending == False:
MyOwnPeer2PeerNode.main_node.send_to_nodes(
{
"transactionrequest": 1,
"sequance_number": sequance_number,
"signature": signature,
"fromUser": fromUser,
"to_user": toUser,
"data": data,
"amount": amount,
"transaction_fee": transaction_fee,
"response": False
},
exclude=[transaction_sender])
self.Verificate_Pending_Trans()
return True
else:
if transaction_sender != None and response == True:
self.send_my_response_on_transaction(
temp_transaction=temp_transaction,
response="FALSE",
transaction_sender=transaction_sender)
else:
if transaction_sender != None and response == True:
self.send_my_response_on_transaction(
temp_transaction=temp_transaction,
response="FALSE",
transaction_sender=transaction_sender)
def message_from_node(self, node, data):
from node.unl import get_unl_nodes, get_as_node_type
if str(data) == "sendmefullblock":
self.send_full_chain(node)
print("Data Type: " + str(type(data)) + "\n")
if str(data) == "sendmefullnodelist":
self.send_full_node_list(node)
print("Data Type: " + str(type(data)) + "\n")
try:
from node.unl import node_is_unl
if data["fullblock"] == 1 and node_is_unl(
node.id) and Ecdsa.verify(
"fullblock" + data["byte"],
Signature.fromBase64(data["signature"]),
PublicKey.fromPem(node.id)):
print("getting chain")
self.get_full_chain(data, node)
except Exception as e:
print(e)
try:
from node.unl import node_is_unl
if data["fullaccounts"] == 1 and node_is_unl(
node.id) and Ecdsa.verify(
"fullaccounts" + data["byte"],
Signature.fromBase64(data["signature"]),
PublicKey.fromPem(node.id)):
print("getting chain")
self.get_full_accounts(data, node)
except Exception as e:
print(e)
try:
from node.unl import node_is_unl
if data["fullblockshash"] == 1 and node_is_unl(
node.id) and Ecdsa.verify(
"fullblockshash" + data["byte"],
Signature.fromBase64(data["signature"]),
PublicKey.fromPem(node.id)):
self.get_full_blockshash(data, node)
except Exception as e:
print(e)
try:
from node.unl import node_is_unl
if data["fullnodelist"] == 1 and node_is_unl(
node.id) and Ecdsa.verify(
"fullnodelist" + data["byte"],
Signature.fromBase64(data["signature"]),
PublicKey.fromPem(node.id)):
print("getting node list")
self.get_full_node_list(data["byte"])
except Exception as e:
print(e)
try:
if data["transactionrequest"] == 1:
self.get_transaction(data, node)
except Exception as e:
print(e)
try:
if data["action"] == "myblock":
self.get_candidate_block(data, node)
except Exception as e:
print(e)
try:
if data["action"] == "myblockhash":
self.get_candidate_block_hash(data, node)
except Exception as e:
print(e)
print("message_from_node from " + node.id + ": " + str(data))
