def verifyRecreation() -> None: template: Dict[str, Any] = rpc.call("merit", "getBlockTemplate", [key.toPublicKey().serialize().hex()]) if bytes.fromhex( template["header"])[36:68] != BlockHeader.createContents( [VerificationPacket(data.hash, [1])]): raise TestError( "New Block template doesn't have a properly recreated packet.") #Mining it further verifies the internal state. header: bytes = bytes.fromhex(template["header"]) proof: int = 0 sig: bytes while True: initial: bytes = RandomX(header + proof.to_bytes(4, byteorder="little")) sig = key.sign(initial).serialize() final: bytes = RandomX(initial + sig) if (int.from_bytes(final, "little") * template["difficulty"]) < int.from_bytes( bytes.fromhex("FF" * 32), "little"): break proof += 1 rpc.call("merit", "publishBlock", [ template["id"], (header + proof.to_bytes(4, byteorder="little") + sig).hex() ]) raise SuccessError( "Stop Liver from trying to verify the vector chain which doesn't have this Block." )
def verifyTemplate() -> None: if bytes.fromhex( rpc.call("merit", "getBlockTemplate", {"miner": blsPubKey })["header"])[36:68] != BlockHeader.createContents( [VerificationPacket(sends[2].hash, [1])]): raise TestError( "Meros didn't add a SignedVerification to the Block Template.")
def sendDataAndVerifications() -> None: if rpc.meros.liveTransaction(data) != rpc.meros.live.recv(): raise TestError("Meros didn't rebroadcast a Transaction we sent it.") for sv in svs: if rpc.meros.signedElement(sv) != rpc.meros.live.recv(): raise TestError("Meros didn't rebroadcast a SignedVerification we sent it.") #As we don't have a quality RPC route for this, we need to use getTemplate. if bytes.fromhex( rpc.call("merit", "getBlockTemplate", [key.toPublicKey().serialize().hex()])["header"] )[36 : 68] != BlockHeader.createContents([VerificationPacket(data.hash, [0, 1])]): raise TestError("New Block template doesn't have a properly created packet.")
competingData: Data = Data(bytes.fromhex("11" * 32), bytes(2)) transactions.add(competingData) #Verify the Datas. verif: SignedVerification = SignedVerification(data.hash) verif.sign(0, blsPrivKey) competingVerif: SignedVerification = SignedVerification(competingData.hash) competingVerif.sign(0, blsPrivKey) #Create a MeritRemoval out of the conflicting Verifications. mr: SignedMeritRemoval = SignedMeritRemoval(verif, competingVerif) #Generate a Block containing the MeritRemoval. block = Block( BlockHeader(0, blockchain.last(), BlockHeader.createContents([], [mr]), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), []), 0, blockchain.blocks[-1].header.time + 1200), BlockBody([], [mr], mr.signature)) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated Invalid Competing Block " + str(len(blockchain.blocks)) + ".") result: Dict[str, Any] = { "blockchain": blockchain.toJSON(), "transactions": transactions.toJSON(), "removal": mr.toSignedJSON() }
#Create a Data and verify it by both parties. data: Data = Data(bytes(32), edPubKey.to_bytes()) data.sign(edPrivKey) data.beat(spamFilter) transactions.add(data) verifs: List[SignedVerification] = [ SignedVerification(data.hash), SignedVerification(data.hash) ] verifs[0].sign(0, blsPrivKeys[0]) verifs[1].sign(1, blsPrivKeys[1]) packets: List[VerificationPacket] = [VerificationPacket(data.hash, [0])] block = Block( BlockHeader(0, blockchain.last(), BlockHeader.createContents(packets), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), packets), 1, blockchain.blocks[-1].header.time + 1200), BlockBody(packets, [], verifs[0].signature)) for _ in range(6): block.mine(blsPrivKeys[1], blockchain.difficulty()) blockchain.add(block) print("Generated Hundred Forty Two Block " + str(len(blockchain.blocks)) + ".") #Create the next Block. block = Block( BlockHeader(0, blockchain.last(), bytes(32), 1, bytes(4), bytes(32), 1, blockchain.blocks[-1].header.time + 1200), BlockBody()) #Save the appended data (3 Blocks and 12 Sends).
str(len(blockchain.blocks)) + ".") #Create conflicting Data Difficulties. dataDiffs: List[SignedDataDifficulty] = [ SignedDataDifficulty(3, 0), SignedDataDifficulty(4, 0) ] dataDiffs[0].sign(0, blsPrivKey) dataDiffs[1].sign(0, blsPrivKey) #Create a MeritRemoval out of the conflicting Data Difficulties. mr: SignedMeritRemoval = SignedMeritRemoval(dataDiffs[0], dataDiffs[1]) #Generate a Block containing the MeritRemoval. block = Block( BlockHeader(0, blockchain.last(), BlockHeader.createContents([], [mr]), 1, bytes(4), bytes(32), 0, blockchain.blocks[-1].header.time + 1200), BlockBody([], [mr], mr.signature)) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated Hundred Twenty Three Swap Block " + str(len(blockchain.blocks)) + ".") #Create a MeritRemoval with the Elements swapped. swapped: SignedMeritRemoval = SignedMeritRemoval(dataDiffs[1], dataDiffs[0]) #Generate a Block containing the swapped MeritRemoval.
blocks: List[Dict[str, Any]] = json.loads(bbFile.read()) blockchain: Blockchain = Blockchain.fromJSON(blocks) bbFile.close() #BLS Keys. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) blsPubKey: PublicKey = blsPrivKey.toPublicKey() #Create a SendDifficulty. sendDiff: SignedSendDifficulty = SignedSendDifficulty(5, 0) sendDiff.sign(0, blsPrivKey) #Generate a Block containing the SendDifficulty. block = Block( BlockHeader(0, blockchain.last(), BlockHeader.createContents([], [sendDiff]), 1, bytes(4), bytes(32), 0, blockchain.blocks[-1].header.time + 1200), BlockBody([], [sendDiff], sendDiff.signature)) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated SendDifficulty Block " + str(len(blockchain.blocks)) + ".") #Mine 24 more Blocks until there's a vote. for _ in range(24): block = Block( BlockHeader(0, blockchain.last(), bytes(32), 1, bytes(4), bytes(32), 0, blockchain.blocks[-1].header.time + 1200), BlockBody()) #Mine it.
def getBlockTemplateTest(rpc: RPC) -> None: edPrivKey: Ristretto.SigningKey = Ristretto.SigningKey(b'\0' * 32) edPubKey: bytes = edPrivKey.get_verifying_key() blockchain: Blockchain = Blockchain() #Get multiple templates to verify they share an ID if they're requested within the same second. templates: List[Dict[str, Any]] = [] startTime: float = nextSecond() for k in range(5): templates.append( rpc.call("merit", "getBlockTemplate", {"miner": getMiner(k)}, False)) if int(startTime) != int(time.time()): #Testing https://github.com/MerosCrypto/Meros/issues/278 has a much more forgiving timer of < 1 second each. #That said, this test was written on the fair assumption of all the above taking place in a single second. raise Exception( "getBlockTemplate is incredibly slow, to the point an empty Block template takes > 0.2 seconds to grab, invalidating this test." ) for k, template in zip(range(5), templates): if template["id"] != int(startTime): raise TestError("Template ID isn't the time.") #Also check general accuracy. if bytes.fromhex(template["key"]) != blockchain.genesis: raise TestError("Template has the wrong RandomX key.") bytesHeader: bytes = bytes.fromhex(template["header"]) serializedHeader: bytes = BlockHeader( 0, blockchain.blocks[0].header.hash, bytes(32), 0, bytes(4), bytes(32), PrivateKey(k).toPublicKey().serialize(), int(startTime)).serialize()[:-52] #Skip over the randomized sketch salt. if (bytesHeader[:72] + bytesHeader[76:]) != (serializedHeader[:72] + serializedHeader[76:]): raise TestError("Template has an invalid header.") #Difficulty modified as this is a new miner. if template["difficulty"] != (blockchain.difficulty() * 11 // 10): raise TestError("Template's difficulty is wrong.") currTime: int = int(nextSecond()) template: Dict[str, Any] = rpc.call("merit", "getBlockTemplate", {"miner": getMiner(0)}, False) if template["id"] != currTime: raise TestError("Template ID wasn't advanced with the time.") #Override the ID to enable easy comparison against a historical template. template["id"] = int(startTime) if int.from_bytes(bytes.fromhex(template["header"])[-4:], "little") != currTime: raise TestError("The header has the wrong time.") template["header"] = ( bytes.fromhex(template["header"])[:72] + #Use the header we'll compare to's salt. bytes.fromhex(templates[0]["header"])[72:76] + bytes.fromhex(template["header"])[76:-4] + #Also use its time. int(startTime).to_bytes(4, "little")).hex().upper() if template != templates[0]: raise TestError( "Template, minus the time difference, doesn't match the originally provided template." ) #Test that the templates are deleted whenever a new Block appears. #This is done by checking the error given when we use an old template. with open("e2e/Vectors/Merit/BlankBlocks.json", "r") as file: block: Block = Block.fromJSON(json.loads(file.read())[0]) blockchain.add(block) rpc.meros.liveConnect(blockchain.blocks[0].header.hash) rpc.meros.syncConnect(blockchain.blocks[0].header.hash) rpc.meros.liveBlockHeader(block.header) rpc.meros.rawBlockBody(block, 0) time.sleep(1) #Sanity check. if rpc.call("merit", "getHeight", auth=False) != 2: raise Exception("Didn't successfully send Meros the Block.") #Get a new template so Meros realizes the template situation has changed. rpc.call("merit", "getBlockTemplate", {"miner": getMiner(0)}, False) try: rpc.call("merit", "publishBlock", { "id": int(startTime), "header": "" }, False) raise Exception("") except Exception as e: if str(e) != "-2 Invalid ID.": raise TestError("Meros didn't delete old template IDs.") #Test VerificationPacket inclusion. data: Data = Data(bytes(32), edPubKey) data.sign(edPrivKey) data.beat(SpamFilter(5)) verif: SignedVerification = SignedVerification(data.hash) verif.sign(0, PrivateKey(0)) packet = VerificationPacket(data.hash, [0]) rpc.meros.liveTransaction(data) rpc.meros.signedElement(verif) time.sleep(1) if bytes.fromhex( rpc.call("merit", "getBlockTemplate", {"miner": getMiner(0)}, False)["header"])[36:68] != BlockHeader.createContents( [packet]): raise TestError( "Meros didn't include the Verification in its new template.") #Test Element inclusion. sendDiff: SignedSendDifficulty = SignedSendDifficulty(0, 0) sendDiff.sign(0, PrivateKey(0)) rpc.meros.signedElement(sendDiff) time.sleep(1) if bytes.fromhex( rpc.call("merit", "getBlockTemplate", {"miner": getMiner(0)}, False)["header"])[36:68] != BlockHeader.createContents( [packet], [sendDiff]): raise TestError( "Meros didn't include the Element in its new template.") #The 88 test checks for the non-inclusion of Verifications with unmentioned predecessors. #Test for non-inclusion of Elements with unmentioned predecessors. sendDiffChild: SignedSendDifficulty = SignedSendDifficulty(0, 2) sendDiffChild.sign(0, PrivateKey(0)) rpc.meros.signedElement(sendDiffChild) time.sleep(1) if bytes.fromhex( rpc.call("merit", "getBlockTemplate", {"miner": getMiner(0)}, False)["header"])[36:68] != BlockHeader.createContents( [packet], [sendDiff]): raise TestError( "Meros did include an Element with an unmentioned parent in its new template." ) #If we send a block with a time in the future, yet within FTL (of course), make sure Meros can still generate a template. #Naively using the current time will create a negative clock, which isn't allowed. #Start by closing the sockets to give us time to work. rpc.meros.live.connection.close() rpc.meros.sync.connection.close() #Sleep to reset the connection state. time.sleep(35) #Create and mine the Block. header: BlockHeader = BlockHeader( 0, blockchain.blocks[-1].header.hash, bytes(32), 0, bytes(4), bytes(32), PrivateKey(0).toPublicKey().serialize(), 0, ) miningStart: int = 0 #If this block takes longer than 10 seconds to mine, try another. #Low future time (20 seconds) is chosen due to feasibility + supporting lowering the FTL in the future. while time.time() > miningStart + 10: miningStart = int(time.time()) header = BlockHeader( 0, blockchain.blocks[-1].header.hash, bytes(32), 0, bytes(4), bytes(32), #Mod by something is due to a 2-byte limit (IIRC -- Kayaba). #100 is just clean. +11 ensures an offset from the above, which really shouldn't be necessary. #If we did need one, +1 should work, as we only ever work with PrivateKey(0) on the blockchain. PrivateKey((miningStart % 100) + 10).toPublicKey().serialize(), int(time.time()) + 20, ) header.mine(PrivateKey((miningStart % 100) + 10), blockchain.difficulty() * 11 // 10) blockchain.add(Block(header, BlockBody())) #Send it and verify it. rpc.meros.liveConnect(blockchain.blocks[0].header.hash) rpc.meros.syncConnect(blockchain.blocks[0].header.hash) rpc.meros.liveBlockHeader(header) rpc.meros.rawBlockBody(Block(header, BlockBody()), 0) rpc.meros.live.connection.close() rpc.meros.sync.connection.close() time.sleep(1) #Ensure a stable template ID. currTime = int(nextSecond()) template = rpc.call("merit", "getBlockTemplate", {"miner": getMiner(0)}, False) if template["id"] != currTime: raise TestError( "Template ID isn't the time when the previous Block is in the future." ) if int.from_bytes(bytes.fromhex(template["header"])[-4:], "little") != (header.time + 1): raise TestError( "Meros didn't handle generating a template off a Block in the future properly." ) #Verify a Block with three Elements from a holder, where two form a Merit Removal. #Only the two which cause a MeritRemoval should be included. #Mine a Block to a new miner and clear the current template with it (might as well). #Also allows us to test template clearing. template: Dict[str, Any] = rpc.call("merit", "getBlockTemplate", {"miner": getMiner(1)}, False) #Mine the Block. proof: int = -1 tempHash: bytes = bytes() tempSignature: bytes = bytes() while ((proof == -1) or ((int.from_bytes(tempHash, "little") * (blockchain.difficulty() * 11 // 10)) > int.from_bytes( bytes.fromhex("FF" * 32), "little"))): proof += 1 tempHash = RandomX( bytes.fromhex(template["header"]) + proof.to_bytes(4, "little")) tempSignature = PrivateKey(1).sign(tempHash).serialize() tempHash = RandomX(tempHash + tempSignature) rpc.call( "merit", "publishBlock", { "id": template["id"], "header": template["header"] + proof.to_bytes(4, "little").hex() + tempSignature.hex() }) time.sleep(1) #Verify the template was cleared. currTime = int(nextSecond()) bytesHeader: bytes = bytes.fromhex( rpc.call("merit", "getBlockTemplate", {"miner": getMiner(0)}, False)["header"]) serializedHeader: bytes = BlockHeader( 0, tempHash, bytes(32), 0, bytes(4), bytes(32), 0, #Ensures that the previous time manipulation doesn't come back to haunt us. max(currTime, blockchain.blocks[-1].header.time + 1)).serialize()[:-52] #Skip over the randomized sketch salt and time (which we don't currently have easy access to). if (bytesHeader[:72] + bytesHeader[76:-4]) != (serializedHeader[:72] + serializedHeader[76:-4]): raise TestError("Template wasn't cleared.") #Sleep so we can reconnect. time.sleep(35) rpc.meros.liveConnect(blockchain.blocks[0].header.hash) #Finally create the Elements. dataDiff: SignedDataDifficulty = SignedDataDifficulty(1, 0) dataDiff.sign(2, PrivateKey(1)) rpc.meros.signedElement(dataDiff) sendDiffs: List[SignedSendDifficulty] = [ SignedSendDifficulty(1, 1), SignedSendDifficulty(2, 1) ] for sd in sendDiffs: sd.sign(2, PrivateKey(1)) rpc.meros.signedElement(sd) time.sleep(1) #`elem for elem` is used below due to Pyright not handling inheritance properly when nested. #pylint: disable=unnecessary-comprehension if bytes.fromhex( rpc.call("merit", "getBlockTemplate", {"miner": getMiner(0)}, False)["header"])[36:68] != BlockHeader.createContents( [], [elem for elem in sendDiffs[::-1]]): raise TestError( "Meros didn't include just the malicious Elements in its new template." )
) send.sign(edPrivKey) send.beat(sendFilter) transactions.add(send) #Create a Verification/VerificationPacket for the Send. sv: SignedVerification = SignedVerification(send.hash) sv.sign(0, blsPrivKey) packet: VerificationPacket = VerificationPacket(send.hash, [0]) #Add a Block verifying it. block: Block = Block( BlockHeader( 0, blockchain.last(), BlockHeader.createContents([packet]), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), [packet]), 0, blockchain.blocks[-1].header.time + 1200 ), BlockBody([packet], [], sv.signature) ) #Mine the Block. block.mine(blsPrivKey, blockchain.difficulty()) #Add the Block. blockchain.add(block) print("Generated Same Input Block " + str(len(blockchain.blocks) - 1) + ".")
toAggregate = [] for h in order[0]: for s in order[0][h]: if s not in packets: packets[s] = VerificationPacket(sends[s].hash, []) packets[s].holders.append(h) verif: SignedVerification = SignedVerification(sends[s].hash) verif.sign(h, blsPrivKeys[h]) toAggregate.append(verif.signature) block: Block = Block( BlockHeader( 0, blockchain.last(), BlockHeader.createContents(list(packets.values())), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), list(packets.values())), order[1], blockchain.blocks[-1].header.time + 1200), BlockBody(list(packets.values()), [], Signature.aggregate(toAggregate))) miner: Union[bytes, int] = order[1] if isinstance(miner, bytes): for k in range(len(blsPubKeys)): if miner == blsPubKeys[k].serialize(): block.mine(blsPrivKeys[k], blockchain.difficulty()) break else: block.mine(blsPrivKeys[miner], blockchain.difficulty()) blockchain.add(block)
for v in range(2): verifs[-1][v].sign(v, blsPrivKeys[v]) #Create the packets. packets: List[SignedVerificationPacket] = [] for packet in verifs: packets.append( SignedVerificationPacket( packet[0].hash, [0, 1], Signature.aggregate([packet[0].signature, packet[1].signature]))) #Create Blocks containing these packets. for packet in packets: block = Block( BlockHeader(0, merit.blockchain.last(), BlockHeader.createContents([packet]), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), [packet]), 1, merit.blockchain.blocks[-1].header.time + 1200), BlockBody([packet], [], packet.signature)) block.mine(blsPrivKeys[1], merit.blockchain.difficulty()) merit.add(block) print("Generated Aggregated Claim Block " + str(len(merit.blockchain.blocks) - 1) + ".") #Generate another 5 Blocks to close the Epochs. #Next block should have the packet. for _ in range(5): block = Block( BlockHeader(0, merit.blockchain.last(), bytes(32), 1, bytes(4), bytes(32), 0, merit.blockchain.blocks[-1].header.time + 1200),
print("Generated Hundred Twenty Three Partial Block " + str(len(blockchain.blocks)) + ".") #Create conflicting Data Difficulties. dataDiffs: List[SignedDataDifficulty] = [ SignedDataDifficulty(3, 0), SignedDataDifficulty(4, 0) ] dataDiffs[0].sign(0, blsPrivKey) dataDiffs[1].sign(0, blsPrivKey) #Generate a Block containing the first Data Difficulty. block = Block( BlockHeader( 0, blockchain.last(), BlockHeader.createContents([], [dataDiffs[0]]), 1, bytes(4), bytes(32), 0, blockchain.blocks[-1].header.time + 1200 ), BlockBody([], [dataDiffs[0]], dataDiffs[0].signature) ) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated Hundred Twenty Three Partial Block " + str(len(blockchain.blocks)) + ".")
b'\3', digest_size=32).digest()).toPublicKey().serialize(), PrivateKey(blake2b( b'\4', digest_size=32).digest()).toPublicKey().serialize() ], Signature.aggregate([ blsPrivKey.sign(verifs[2].signatureSerialize()), PrivateKey(blake2b(b'\3', digest_size=32).digest()).sign( verifs[2].signatureSerialize()), PrivateKey(blake2b(b'\4', digest_size=32).digest()).sign( verifs[2].signatureSerialize()) ])), 0) #Generate a Block containing the modified MeritRemoval. block = Block( BlockHeader(0, blockchain.last(), BlockHeader.createContents([], [packeted]), 1, bytes(4), bytes(32), 0, blockchain.blocks[-1].header.time + 1200), BlockBody([], [packeted], packeted.signature)) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated Hundred Thirty Five Block " + str(len(blockchain.blocks)) + ".") result: Dict[str, Any] = { "blockchain": blockchain.toJSON(), "datas": [datas[0].toJSON(), datas[1].toJSON(), datas[2].toJSON()], "removal": mr.toSignedJSON() }
blsPubKey.serialize(), blockchain.blocks[-1].header.time + 1200 ), BlockBody() ) blank.mine(blsPrivKey, blockchain.difficulty()) blockchain.add(blank) #Generate a Block which has a VP with no holders. vp: VerificationPacket = VerificationPacket(b'z' * 32, []) blocks.append( Block( BlockHeader( 0, blockchain.last(), BlockHeader.createContents([vp]), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), [vp]), 0, blockchain.blocks[-1].header.time + 1200 ), BlockBody([vp], [], blsPrivKey.sign(b'')) ) ) blocks[-1].mine(blsPrivKey, blockchain.difficulty()) #Generate a Block which has a MR VP with no holders. mr: MeritRemoval = MeritRemoval( MeritRemovalVerificationPacket(b'z' * 32, []), MeritRemovalVerificationPacket(b'z' * 32, []),
PrivateKey(blake2b(b'\1', digest_size=32).digest()).toPublicKey().serialize() ], PrivateKey(blake2b(b'\1', digest_size=32).digest()).sign(verifs[1].signatureSerialize()) ) ] #Create a MeritRemoval out of the conflicting Verifications. e1MR: SignedMeritRemoval = SignedMeritRemoval(verifs[1], packets[0], 0) e2MR: SignedMeritRemoval = SignedMeritRemoval(packets[1], verifs[2], 0) #Generate a Block containing the MeritRemoval for each chain. block = Block( BlockHeader( 0, e1Chain.last(), BlockHeader.createContents([], [e1MR]), 1, bytes(4), bytes(32), 0, e1Chain.blocks[-1].header.time + 1200 ), BlockBody([], [e1MR], e1MR.signature) ) block.mine(blsPrivKey, e1Chain.difficulty()) e1Chain.add(block) print("Generated Hundred Twenty Three Packet Block 1 " + str(len(e1Chain.blocks)) + ".") block = Block( BlockHeader( 0,
blsPubKey.serialize(), blockchain.blocks[-1].header.time + 1200 ), BlockBody() ) blank.mine(blsPrivKey, blockchain.difficulty()) blockchain.add(blank) #Generate a Block which has a VP with no holders. vp: VerificationPacket = VerificationPacket(b'z' * 32, []) blocks.append( Block( BlockHeader( 0, blockchain.last(), BlockHeader.createContents([vp]), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), [vp]), 0, blockchain.blocks[-1].header.time + 1200 ), BlockBody([vp], [], blsPrivKey.sign(b'')) ) ) blocks[-1].mine(blsPrivKey, blockchain.difficulty()) with open("e2e/Vectors/Consensus/TwoHundredFour.json", "w") as vectors: vectors.write(json.dumps({ "blank": blank.toJSON(), "blocks": [block.toJSON() for block in blocks]
edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #BLS Private Key. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) #Create a Data for the VerificationPacket. data: Data = Data(bytes(32), edPubKey.to_bytes()) data.sign(edPrivKey) data.beat(dataFilter) transactions.add(data) #Generate the VerificationPacket Block. block = Block( BlockHeader( 0, blockchain.last(), BlockHeader.createContents([VerificationPacket(data.hash, [1])]), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), [VerificationPacket(data.hash, [1])]), blsPrivKey.toPublicKey().serialize(), blockchain.blocks[-1].header.time + 1200), BlockBody([VerificationPacket(data.hash, [1])], [], blsPrivKey.sign(b""))) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it to the vectors. blocks.append(block.toJSON()) print("Generated Hundred Six Block Elements VerificationPacket Block.") #Generate the SendDifficulty Block. elements: List[Element] = []
data.sign(edPrivKey) data.beat(dataFilter) transactions.add(data) #Verify them in unique Blocks. packet: List[VerificationPacket] for data in datas: verif: SignedVerification = SignedVerification(data.hash) verif.sign(0, blsPrivKey) packet = [VerificationPacket(data.hash, [0])] block = Block( BlockHeader( 0, merit.blockchain.last(), BlockHeader.createContents(packet), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), packet), 0, merit.blockchain.blocks[-1].header.time + 1200 ), BlockBody(packet, [], verif.signature) ) block.mine(blsPrivKey, merit.blockchain.difficulty()) merit.add(block) #Generate another 5 Blocks to close the Epochs. for _ in range(5): block = Block( BlockHeader(
#Create the Data. data: Data = Data(bytes(32), edPubKey.to_bytes()) data.sign(edPrivKey) data.beat(dataFilter) transactions.add(data) #Verify it. verif: SignedVerification = SignedVerification(data.hash) verif.sign(0, blsPrivKey) #Generate another 6 Blocks. #Next block should have a packet. block: Block = Block( BlockHeader( 0, merit.blockchain.last(), BlockHeader.createContents([VerificationPacket(verif.hash, [0])]), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), [VerificationPacket(verif.hash, [0])]), 0, merit.blockchain.blocks[-1].header.time + 1200), BlockBody([VerificationPacket(verif.hash, [0])], [], verif.signature)) for _ in range(6): #Mine it. block.mine(blsPrivKey, merit.blockchain.difficulty()) #Add it. merit.add(block) print("Generated Claimed Mint Block " + str(len(merit.blockchain.blocks) - 1) + ".") #Create the next Block.
#Create Verifications for all 3. verifs: List[SignedVerification] = [] packets: List[VerificationPacket] = [] for data in datas: verifs.append(SignedVerification(data.hash, 0)) verifs[-1].sign(0, blsPrivKey) packets.append(VerificationPacket(data.hash, [0])) #Create a MeritRemoval out of the conflicting Verifications. mr: SignedMeritRemoval = SignedMeritRemoval(verifs[1], verifs[2]) #Generate a Block containing the MeritRemoval. block = Block( BlockHeader(0, blockchain.last(), BlockHeader.createContents(packets, [mr]), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), packets), 0, blockchain.blocks[-1].header.time + 1200), BlockBody( packets, [mr], Signature.aggregate([ verifs[0].signature, verifs[1].signature, verifs[2].signature, mr.signature ]))) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated Verify Competing Block " + str(len(blockchain.blocks)) + ".")
#Add it. blockchain.add(block) print("Generated Hundred Twenty Block " + str(len(blockchain.blocks)) + ".") #Create a DataDifficulty. dataDiff: SignedDataDifficulty = SignedDataDifficulty(3, 0) dataDiff.sign(0, blsPrivKey) #Create a conflicting DataDifficulty with the same nonce. dataDiffConflicting = SignedDataDifficulty(1, 0) dataDiffConflicting.sign(0, blsPrivKey) #Generate a Block containing the competing Data difficulty. block = Block( BlockHeader(0, blockchain.last(), BlockHeader.createContents([], [dataDiffConflicting]), 1, bytes(4), bytes(32), 0, blockchain.blocks[-1].header.time + 1200), BlockBody([], [dataDiffConflicting], dataDiffConflicting.signature)) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated Hundred Twenty Block " + str(len(blockchain.blocks)) + ".") result: Dict[str, Any] = { "blockchain": blockchain.toJSON(), "mempoolDataDiff": dataDiff.toSignedJSON(), "blockchainDataDiff": dataDiffConflicting.toJSON() }
#This will verify Meros properly handles out-of-order Elements included in a Block. dataDiffs: List[SignedDataDifficulty] = [ SignedDataDifficulty(1, 1), SignedDataDifficulty(2, 0) ] for dataDiff in dataDiffs: dataDiff.sign(0, blsPrivKey) for _ in range(2): block = Block( BlockHeader( 0, blockchain.last(), #Used so the type checkers realize List[SignedDataDifficulty] is a viable List[Element]. #pylint: disable=unnecessary-comprehension BlockHeader.createContents([], [e for e in dataDiffs]), 0, bytes(4), bytes(32), 0, blockchain.blocks[-1].header.time + 1200), #pylint: disable=unnecessary-comprehension BlockBody([], [e for e in dataDiffs], Signature.aggregate([d.signature for d in dataDiffs]))) block.mine(blsPrivKey, blockchain.difficulty()) blockchain.add(block) #To verify the nonce isn't improperly set, add one more Data Difficulty with a nonce of 2. dataDiffs = [SignedDataDifficulty(4, 2)] dataDiffs[0].sign(0, blsPrivKey)
secondVerif: SignedVerification = SignedVerification(second.hash) secondVerif.sign(0, blsPrivKey) packets: List[VerificationPacket] = [ VerificationPacket(first.hash, [0]), VerificationPacket(second.hash, [0]), ] #Generate another 6 Blocks. #Next block should have the packets. block: Block = Block( BlockHeader( 0, merit.blockchain.last(), BlockHeader.createContents(packets), 1, bytes(4), BlockHeader.createSketchCheck(bytes(4), packets), 0, merit.blockchain.blocks[-1].header.time + 1200 ), BlockBody(packets, [], Signature.aggregate([firstVerif.signature, secondVerif.signature])) ) for _ in range(6): #Mine it. block.mine(blsPrivKey, merit.blockchain.difficulty()) #Add it. merit.add(block) print("Generated Competing Finalized Block " + str(len(merit.blockchain.blocks) - 1) + ".")
for data in datas: data.sign(edPrivKey) data.beat(spamFilter) #Create Verifications for all 3. verifs: List[SignedVerification] = [] for data in datas: verifs.append(SignedVerification(data.hash, 0)) verifs[-1].sign(0, blsPrivKey) #Create a MeritRemoval out of the conflicting Verifications. mr: SignedMeritRemoval = SignedMeritRemoval(verifs[1], verifs[2]) #Generate a Block containing the MeritRemoval. block = Block( BlockHeader(0, packetedChain.last(), BlockHeader.createContents([], [mr]), 1, bytes(4), bytes(32), 0, packetedChain.blocks[-1].header.time + 1200), BlockBody([], [mr], mr.signature)) #Mine it. block.mine(blsPrivKey, packetedChain.difficulty()) #Add it. packetedChain.add(block) print("Generated Hundred Twenty Three Packet Block 1 " + str(len(packetedChain.blocks)) + ".") #Create a MeritRemoval with random keys. packeted: SignedMeritRemoval = SignedMeritRemoval( SignedMeritRemovalVerificationPacket( SignedVerificationPacket(verifs[1].hash), [