def live(self) -> None:
#Handshake with the node.
self.rpc.meros.connect(254, 254,
self.merit.blockchain.blocks[0].header.hash)
#Send each Block.
for b in range(1, len(self.merit.blockchain.blocks)):
#Grab the Block.
block: Block = self.merit.blockchain.blocks[b]
#Send the Block.
self.rpc.meros.blockHeader(block.header)
#Handle sync requests.
reqHash: bytes = bytes()
while True:
msg: bytes = self.rpc.meros.recv()
if MessageType(msg[0]) == MessageType.Syncing:
self.rpc.meros.syncingAcknowledged()
elif MessageType(msg[0]) == MessageType.BlockBodyRequest:
reqHash = msg[1:33]
if reqHash != block.header.hash:
raise TestError(
"Meros asked for a Block Body that didn't belong to the Block we just sent it."
)
#Send the BlockBody.
self.rpc.meros.blockBody(self.merit.state.nicks, block)
elif MessageType(msg[0]) == MessageType.SketchHashesRequest:
if not block.body.packets:
raise TestError(
"Meros asked for Sketch Hashes from a Block without any."
)
reqHash = msg[1:33]
if reqHash != block.header.hash:
raise TestError(
"Meros asked for Sketch Hashes that didn't belong to the Block we just sent it."
)
#Create the haashes.
hashes: List[int] = []
for packet in block.body.packets:
hashes.append(
Sketch.hash(block.header.sketchSalt, packet))
#Send the Sketch Hashes.
self.rpc.meros.sketchHashes(hashes)
elif MessageType(msg[0]) == MessageType.SketchHashRequests:
if not block.body.packets:
raise TestError(
"Meros asked for Verification Packets from a Block without any."
)
reqHash = msg[1:33]
if reqHash != block.header.hash:
raise TestError(
"Meros asked for Verification Packets that didn't belong to the Block we just sent it."
)
#Create a lookup of hash to packets.
packets: Dict[int, VerificationPacket] = {}
for packet in block.body.packets:
packets[Sketch.hash(block.header.sketchSalt,
packet)] = packet
#Look up each requested packet and respond accordingly.
for h in range(int.from_bytes(msg[33:37],
byteorder="big")):
sketchHash: int = int.from_bytes(msg[37 + (h * 8):45 +
(h * 8)],
byteorder="big")
if sketchHash not in packets:
raise TestError(
"Meros asked for a non-existent Sketch Hash.")
self.rpc.meros.packet(packets[sketchHash])
elif MessageType(msg[0]) == MessageType.TransactionRequest:
reqHash = msg[1:33]
if self.transactions is None:
raise TestError(
"Meros asked for a Transaction when we have none.")
if reqHash not in self.transactions.txs:
raise TestError(
"Meros asked for a non-existent Transaction.")
self.rpc.meros.transaction(self.transactions.txs[reqHash])
elif MessageType(msg[0]) == MessageType.SyncingOver:
pass
elif MessageType(msg[0]) == MessageType.BlockHeader:
break
else:
raise TestError("Unexpected message sent: " +
msg.hex().upper())
#Add any new nicks to the lookup table.
if self.merit.blockchain.blocks[b].header.newMiner:
self.merit.state.nicks.append(
self.merit.blockchain.blocks[b].header.minerKey)
#If there's a callback at this height, call it.
if b in self.callbacks:
self.callbacks[b]()
#Execute the every-Block callback, if it exists.
if self.everyBlock is not None:
self.everyBlock(b)
#Verify the Blockchain.
verifyBlockchain(self.rpc, self.merit.blockchain)
#Verify the Transactions.
if self.transactions is not None:
verifyTransactions(self.rpc, self.transactions)
#Reset the node.
self.rpc.reset()
def live(self) -> None:
#Handshake with the node.
self.rpc.meros.connect(254, 254, 1)
#Send each Block.
for b in range(1, len(self.blockchain.blocks)):
#Grab the Block.
block: Block = self.blockchain.blocks[b]
#Send the Block.
self.rpc.meros.blockHeader(block.header)
#Handle sync requests.
reqHash: bytes = bytes()
while True:
msg: bytes = self.rpc.meros.recv()
if MessageType(msg[0]) == MessageType.Syncing:
self.rpc.meros.acknowledgeSyncing()
elif MessageType(msg[0]) == MessageType.BlockBodyRequest:
reqHash = msg[1:49]
if reqHash != block.header.hash:
raise TestError(
"Meros asked for a Block Body that didn't belong to the header we just sent it."
)
#Send the BlockBody.
self.rpc.meros.blockBody(block.body)
elif MessageType(msg[0]) == MessageType.ElementRequest:
holder: bytes = msg[1:49]
nonce: int = int.from_bytes(msg[49:53], "big")
if self.consensus is None:
raise TestError(
"Meros asked for an Element when we have none.")
if holder not in self.consensus.holders:
raise TestError(
"Meros asked for an Element from a holder we don't have."
)
if nonce >= len(self.consensus.holders[holder]):
raise TestError(
"Meros asked for an Element we don't have.")
self.rpc.meros.element(
self.consensus.holders[holder][nonce])
elif MessageType(msg[0]) == MessageType.TransactionRequest:
reqHash = msg[1:49]
if self.transactions is None:
raise TestError(
"Meros asked for a Transaction when we have none.")
if reqHash not in self.transactions.txs:
raise TestError(
"Meros asked for a Transaction we don't have.")
self.rpc.meros.transaction(self.transactions.txs[reqHash])
elif MessageType(msg[0]) == MessageType.SyncingOver:
pass
elif MessageType(msg[0]) == MessageType.BlockHeader:
break
else:
raise TestError("Unexpected message sent: " +
msg.hex().upper())
#If there's a callback at this height, call it.
if b in self.callbacks:
self.callbacks[b]()
#Execute the every-Block callback, if it exists.
if self.everyBlock is not None:
self.everyBlock(b)
#Verify the Blockchain.
verifyBlockchain(self.rpc, self.blockchain)
#Verify the Consensus.
if self.consensus is not None:
verifyConsensus(self.rpc, self.consensus)
#Verify the Transactions.
if self.transactions is not None:
verifyTransactions(self.rpc, self.transactions)
#Reset the RPC.
self.rpc.reset()
def sync(self) -> None:
#Handshake with the node.
self.rpc.meros.syncConnect(
self.merit.blockchain.blocks[self.settings["height"]].header.hash)
#Handle sync requests.
reqHash: bytes = bytes()
while True:
#Break out of the for loop if the sync finished.
#This means we sent every Block, every Element, every Transaction...
if ((self.blockHashes == set()) and (self.packets == {})
and (self.txs == set())):
break
msg: bytes = self.rpc.meros.sync.recv()
if MessageType(msg[0]) == MessageType.BlockListRequest:
reqHash = msg[3:35]
for b in range(len(self.merit.blockchain.blocks)):
if self.merit.blockchain.blocks[b].header.hash == reqHash:
blockList: List[bytes] = []
for bl in range(1, msg[2] + 2):
if msg[1] == 0:
if b - bl < 0:
break
blockList.append(self.merit.blockchain.blocks[
b - bl].header.hash)
if b - bl != 0:
self.blocks.append(
self.merit.blockchain.blocks[b - bl])
elif msg[1] == 1:
if b + bl > self.settings["height"]:
break
blockList.append(self.merit.blockchain.blocks[
b + bl].header.hash)
self.blocks.append(
self.merit.blockchain.blocks[b + bl])
else:
raise TestError(
"Meros asked for an invalid direction in a BlockListRequest."
)
if blockList == []:
self.rpc.meros.dataMissing()
break
self.rpc.meros.blockList(blockList)
break
if b == self.settings["height"]:
self.rpc.meros.dataMissing()
elif MessageType(msg[0]) == MessageType.BlockHeaderRequest:
if (self.txs != set()) or (self.packets != {}):
raise TestError(
"Meros asked for a new Block before syncing the last Block's Transactions and Packets."
)
reqHash = msg[1:33]
if reqHash != self.blocks[-1].header.hash:
raise TestError(
"Meros asked for a BlockHeader other than the next Block's on the last BlockList."
)
self.rpc.meros.syncBlockHeader(self.blocks[-1].header)
elif MessageType(msg[0]) == MessageType.BlockBodyRequest:
reqHash = msg[1:33]
if reqHash != self.blocks[-1].header.hash:
raise TestError(
"Meros asked for a BlockBody other than the next Block's on the last BlockList."
)
self.rpc.meros.blockBody(self.blocks[-1])
self.blockHashes.remove(self.blocks[-1].header.hash)
#Set packets/transactions.
self.packets = {}
for packet in self.blocks[-1].body.packets:
if packet.hash not in self.synced:
self.txs.add(packet.hash)
self.packets[Sketch.hash(self.blocks[-1].header.sketchSalt,
packet)] = packet
#Update the list of mentioned Transactions.
noVCMRs: bool = True
for elem in self.blocks[-1].body.elements:
if isinstance(elem, MeritRemoval):
if isinstance(elem.e1,
(Verification, VerificationPacket)):
self.txs.add(elem.e1.hash)
noVCMRs = False
if isinstance(elem.e2,
(Verification, VerificationPacket)):
self.txs.add(elem.e2.hash)
noVCMRs = False
if (self.packets == {}) and noVCMRs:
del self.blocks[-1]
elif MessageType(msg[0]) == MessageType.SketchHashesRequest:
reqHash = msg[1:33]
if reqHash != self.blocks[-1].header.hash:
raise TestError(
"Meros asked for Sketch Hashes that didn't belong to the header we just sent it."
)
#Get the haashes.
hashes: List[int] = list(self.packets)
#Send the Sketch Hashes.
self.rpc.meros.sketchHashes(hashes)
elif MessageType(msg[0]) == MessageType.SketchHashRequests:
if not self.packets:
raise TestError(
"Meros asked for Verification Packets from a Block without any."
)
reqHash = msg[1:33]
if reqHash != self.blocks[-1].header.hash:
raise TestError(
"Meros asked for Verification Packets that didn't belong to the Block we just sent it."
)
#Look up each requested packet and respond accordingly.
for h in range(int.from_bytes(msg[33:37], byteorder="big")):
sketchHash: int = int.from_bytes(msg[37 + (h * 8):45 +
(h * 8)],
byteorder="big")
if sketchHash not in self.packets:
raise TestError(
"Meros asked for a non-existent Sketch Hash.")
self.rpc.meros.packet(self.packets[sketchHash])
del self.packets[sketchHash]
elif MessageType(msg[0]) == MessageType.TransactionRequest:
reqHash = msg[1:33]
if self.transactions is None:
raise TestError(
"Meros asked for a Transaction when we have none.")
if reqHash not in self.transactions.txs:
raise TestError(
"Meros asked for a Transaction we don't have.")
if reqHash not in self.txs:
raise TestError(
"Meros asked for a Transaction we haven't mentioned.")
self.rpc.meros.syncTransaction(self.transactions.txs[reqHash])
self.synced.add(reqHash)
self.txs.remove(reqHash)
if self.txs == set():
del self.blocks[-1]
else:
raise TestError("Unexpected message sent: " +
msg.hex().upper())
#Verify the Blockchain.
verifyBlockchain(self.rpc, self.merit.blockchain)
#Verify the Transactions.
if self.transactions is not None:
verifyTransactions(self.rpc, self.transactions)
if self.settings["playback"]:
#Playback their messages.
self.rpc.meros.sync.playback()
def sync(self) -> None:
#Handshake with the node.
self.rpc.meros.connect(254, 254, self.settings["height"] + 1)
#Handle sync requests.
reqHash: bytes = bytes()
lastBlock: int = 0
hadTips: bool = False
while True:
msg: bytes = self.rpc.meros.recv()
if MessageType(msg[0]) == MessageType.Syncing:
self.rpc.meros.acknowledgeSyncing()
elif MessageType(msg[0]) == MessageType.GetBlockHash:
height: int = int.from_bytes(msg[1:5], "big")
if height == 0:
self.rpc.meros.blockHash(self.blockchain.blocks[
self.settings["height"]].header.hash)
else:
if height > self.settings["height"]:
raise TestError(
"Meros asked for a Block Hash we don't have.")
self.rpc.meros.blockHash(
self.blockchain.blocks[height].header.hash)
elif MessageType(msg[0]) == MessageType.BlockHeaderRequest:
reqHash = msg[1:49]
for block in self.blockchain.blocks:
if block.header.hash == reqHash:
self.rpc.meros.blockHeader(block.header)
break
if block.header.hash == self.blockchain.blocks[
self.settings["height"]].header.hash:
raise TestError(
"Meros asked for a Block Header we don't have.")
elif MessageType(msg[0]) == MessageType.BlockBodyRequest:
reqHash = msg[1:49]
if self.tips != {}:
raise TestError(
"Meros requested a new BlockBody despite not finishing syncing the existing tips."
)
for block in self.blockchain.blocks:
if block.header.hash == reqHash:
#Update the tips.
hadTips = self.updateTips(block.header.nonce,
block.body.records)
#Send the BlockBody.
self.rpc.meros.blockBody(block.body)
lastBlock = block.header.nonce + 1
#We check to load the tail tips AFTER an ElementRequest,
#Therefore, if there aren't any tips before in in the second to last block, we won't load them.
#This handles that case.
if ((not hadTips)
and (lastBlock == self.settings["height"])):
self.loadTailTips()
break
if block.header.hash == self.blockchain.blocks[
self.settings["height"]].header.hash:
raise TestError(
"Meros asked for a Block Body we don't have.")
elif MessageType(msg[0]) == MessageType.ElementRequest:
holder: bytes = msg[1:49]
nonce: int = int.from_bytes(msg[49:53], "big")
if self.consensus is None:
raise TestError(
"Meros asked for an Element when we have none.")
if holder not in self.consensus.holders:
raise TestError(
"Meros asked for an Element from a holder we don't have."
)
if nonce >= len(self.consensus.holders[holder]):
raise TestError(
"Meros asked for an Element we don't have.")
if holder not in self.tips:
raise TestError(
"Meros asked for an Element from a holder we haven't mentioned/they already fully synced."
)
self.rpc.meros.element(self.consensus.holders[holder][nonce])
if nonce == self.tips[holder]:
del self.tips[holder]
#If this is the Block before the tail, and tips is empty, correct the tips/TXs.
if ((lastBlock == self.settings["height"])
and (self.tips == {})):
self.loadTailTips()
elif MessageType(msg[0]) == MessageType.TransactionRequest:
reqHash = msg[1:49]
if self.transactions is None:
raise TestError(
"Meros asked for a Transaction when we have none.")
if reqHash not in self.transactions.txs:
raise TestError(
"Meros asked for a Transaction we don't have.")
if reqHash not in self.txs:
raise TestError(
"Meros asked for a Transaction we haven't mentioned/they already synced."
)
self.rpc.meros.transaction(self.transactions.txs[reqHash])
self.synced[reqHash] = True
del self.txs[reqHash]
elif MessageType(msg[0]) == MessageType.SyncingOver:
#Break out of the foor loop if the sync finished.
#This means we sent every Block, every Element, every Transaction...
if ((lastBlock == self.settings["height"])
and (self.tips == {}) and (self.txs == {})):
#Make sure we handled the tail tips.
handled: bool = True
for holder in self.tailTips:
if holder not in self.allTips:
handled = False
break
if self.allTips[holder] != self.tailTips[holder]:
handled = False
break
if handled:
break
else:
raise TestError("Unexpected message sent: " +
msg.hex().upper())
#Verify the Blockchain.
verifyBlockchain(self.rpc, self.blockchain)
#Verify the Consensus.
try:
verifyConsensus(self.rpc, self.consensus)
except AttributeError:
pass
#Verify the Transactions.
try:
verifyTransactions(self.rpc, self.transactions)
except AttributeError:
pass
if self.settings["playback"]:
#Playback their messages.
self.rpc.meros.playback()
def live(self) -> None:
#Handshake with the node.
self.rpc.meros.liveConnect(self.merit.blockchain.blocks[0].header.hash)
self.rpc.meros.syncConnect(self.merit.blockchain.blocks[0].header.hash)
#Send each Block.
for b in range(1, len(self.merit.blockchain.blocks)):
#Grab the Block.
block: Block = self.merit.blockchain.blocks[b]
#Set loop variables with pending data.
pendingBody: bool = True
pendingPackets: List[bytes] = []
pendingTXs: List[bytes] = []
for packet in block.body.packets:
pendingPackets.append(packet.hash)
if packet.hash not in self.rpc.meros.sentTXs:
pendingTXs.append(packet.hash)
for elem in block.body.elements:
if isinstance(elem, MeritRemoval):
#pylint: disable=consider-merging-isinstance
if ((isinstance(elem.e1, Verification)
or isinstance(elem.e1, VerificationPacket))
and (elem.e1.hash not in self.rpc.meros.sentTXs)
and (elem.e1.hash not in pendingTXs)):
pendingTXs.append(elem.e1.hash)
if ((isinstance(elem.e2, Verification)
or isinstance(elem.e2, VerificationPacket))
and (elem.e2.hash not in self.rpc.meros.sentTXs)
and (elem.e2.hash not in pendingTXs)):
pendingTXs.append(elem.e2.hash)
#Send the Block.
self.rpc.meros.liveBlockHeader(block.header)
#Handle sync requests.
reqHash: bytes = bytes()
while True:
#If we sent every bit of data, break.
if ((not pendingBody) and (not pendingPackets)
and (not pendingTXs)):
break
#Receive the next message.
msg: bytes = self.rpc.meros.sync.recv()
if MessageType(msg[0]) == MessageType.BlockBodyRequest:
#If we already sent the body, raise.
if not pendingBody:
raise TestError(
"Meros asked for the same Block Body multiple times."
)
#Verify Meros asked for the right Block Body.
reqHash = msg[1:33]
if reqHash != block.header.hash:
raise TestError(
"Meros asked for a Block Body that didn't belong to the Block we just sent it."
)
#Send the BlockBody.
self.rpc.meros.blockBody(block)
#Mark the body as sent.
pendingBody = False
elif MessageType(msg[0]) == MessageType.SketchHashesRequest:
if not block.body.packets:
raise TestError(
"Meros asked for Sketch Hashes from a Block without any."
)
reqHash = msg[1:33]
if reqHash != block.header.hash:
raise TestError(
"Meros asked for Sketch Hashes that didn't belong to the Block we just sent it."
)
#Create the haashes.
hashes: List[int] = []
for packet in block.body.packets:
hashes.append(
Sketch.hash(block.header.sketchSalt, packet))
#Send the Sketch Hashes.
self.rpc.meros.sketchHashes(hashes)
elif MessageType(msg[0]) == MessageType.SketchHashRequests:
if not block.body.packets:
raise TestError(
"Meros asked for Verification Packets from a Block without any."
)
reqHash = msg[1:33]
if reqHash != block.header.hash:
raise TestError(
"Meros asked for Verification Packets that didn't belong to the Block we just sent it."
)
#Create a lookup of hash to packets.
packets: Dict[int, VerificationPacket] = {}
for packet in block.body.packets:
packets[Sketch.hash(block.header.sketchSalt,
packet)] = packet
#Look up each requested packet and respond accordingly.
for h in range(int.from_bytes(msg[33:37],
byteorder="big")):
sketchHash: int = int.from_bytes(msg[37 + (h * 8):45 +
(h * 8)],
byteorder="big")
if sketchHash not in packets:
raise TestError(
"Meros asked for a non-existent Sketch Hash.")
self.rpc.meros.packet(packets[sketchHash])
#Delete the VerificationPacket from pending.
del pendingPackets[pendingPackets.index(
packets[sketchHash].hash)]
#Make sure Meros asked for every packet.
if pendingPackets:
raise TestError(
"Meros didn't ask for every Verification Packet.")
elif MessageType(msg[0]) == MessageType.TransactionRequest:
reqHash = msg[1:33]
if self.transactions is None:
raise TestError(
"Meros asked for a Transaction when we have none.")
if reqHash not in pendingTXs:
raise TestError(
"Meros asked for a non-existent Transaction, a Transaction part of a different Block, or an already sent Transaction."
)
self.rpc.meros.syncTransaction(
self.transactions.txs[reqHash])
#Delete the Transaction from pending.
del pendingTXs[pendingTXs.index(reqHash)]
else:
raise TestError("Unexpected message sent: " +
msg.hex().upper())
#Receive the BlockHeader from Meros.
if MessageType(
self.rpc.meros.live.recv()[0]) != MessageType.BlockHeader:
raise TestError("Meros didn't broadcast the new BlockHeader.")
#Add any new nicks to the lookup table.
if self.merit.blockchain.blocks[b].header.newMiner:
self.merit.state.nicks.append(
self.merit.blockchain.blocks[b].header.minerKey)
#If there's a callback at this height, call it.
if b in self.callbacks:
self.callbacks[b]()
#Execute the every-Block callback, if it exists.
if self.everyBlock is not None:
self.everyBlock(b)
#Verify the Blockchain.
verifyBlockchain(self.rpc, self.merit.blockchain)
#Verify the Transactions.
if self.transactions is not None:
verifyTransactions(self.rpc, self.transactions)
#Reset the node.
self.rpc.reset()