def fromJSON( blocks: List[Dict[str, Any]] ) -> Any: result = Blockchain() for block in blocks: result.add(Block.fromJSON(block)) return result
def __init__( self ) -> None: self.genesis: bytes = b"MEROS_DEVELOPER_NETWORK".rjust(32, b'\0') self.upcomingKey: bytes = self.genesis setRandomXKey(self.upcomingKey) self.blockTime: int = 60 self.difficulties: List[int] = [100] self.blocks: List[Block] = [ Block( BlockHeader( 0, self.genesis, bytes(32), 0, bytes(4), bytes(32), PublicKey().serialize(), 0 ), BlockBody() ) ] self.keys: Dict[bytes, int] = {}
def sendRepeatMeritRemoval() -> None: #Send the Block containing the modified Merit Removal. block: Block = Block.fromJSON(vectors["blockchains"][i][-1]) rpc.meros.liveBlockHeader(block.header) #Flag of if the Block's Body synced. blockBodySynced: bool = False #Handle sync requests. reqHash: bytes = bytes() while True: if blockBodySynced: #Sleep for a second so Meros handles the Block. sleep(1) #Try receiving from the Live socket, where Meros sends keep-alives. try: if len(rpc.meros.live.recv()) != 0: raise Exception() except TestError: #Verify the height is 3. #The genesis Block, the Block granting Merit, and the Block containing the MeritRemoval originally. try: if rpc.call("merit", "getHeight") != 3: raise Exception() except Exception: raise TestError( "Node added a Block containg a repeat MeritRemoval." ) #Since the node didn't add the Block, raise SuccessError. raise SuccessError( "Node didn't add a Block containing a repeat MeritRemoval." ) except Exception: raise TestError("Meros sent a keep-alive.") msg: bytes = rpc.meros.sync.recv() if 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. blockBodySynced = True rpc.meros.blockBody(block) else: raise TestError("Unexpected message sent: " + msg.hex().upper())
def sendBlock() -> None: #Send the Block with the MeritRemoval archived again. block: Block = Block.fromJSON(keys, vectors[-1]) rpc.meros.blockHeader(block.header) #Flag of if the Block's Body synced. blockBodySynced: bool = False #Handle sync requests. reqHash: bytes = bytes() while True: try: msg: bytes = rpc.meros.recv() except TestError: if not blockBodySynced: raise TestError( "Node disconnected us before syncing the body.") raise SuccessError( "Meros didn't add the same MeritRemoval twice.") if MessageType(msg[0]) == MessageType.Syncing: 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. blockBodySynced = True rpc.meros.blockBody([], block) elif MessageType(msg[0]) == MessageType.SyncingOver: pass elif MessageType(msg[0]) == MessageType.BlockHeader: #Raise a TestError if the Block was added. raise TestError( "Meros synced a Block with a repeat MeritRemoval.") else: raise TestError("Unexpected message sent: " + msg.hex().upper())
def sendBlock() -> None: #Send the Block with the MeritRemoval archived again. block: Block = Block.fromJSON(vectors[-1]) rpc.meros.liveBlockHeader(block.header) #Flag of if the Block's Body synced. blockBodySynced: bool = False #Handle sync requests. reqHash: bytes = bytes() while True: if blockBodySynced: #Try receiving from the Live socket, where Meros sends keep-alives. try: if len(rpc.meros.live.recv()) != 0: raise Exception() except TestError: raise SuccessError( "Meros didn't add the same MeritRemoval twice.") except Exception: raise TestError("Meros sent a keep-alive.") msg: bytes = rpc.meros.sync.recv() if 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. blockBodySynced = True rpc.meros.blockBody(block) else: raise TestError("Unexpected message sent: " + msg.hex().upper())
merit: Merit = Merit() #SpamFilter. dataFilter: SpamFilter = SpamFilter(5) #Ed25519 keys. edPrivKey: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32) edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #BLS keys. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) blsPubKey: PublicKey = blsPrivKey.toPublicKey() #Add 1 Blank Block. for i in range(1): merit.add(Block.fromJSON(blankBlocks[i])) #Create the Data and a successor. first: Data = Data(bytes(32), edPubKey.to_bytes()) first.sign(edPrivKey) first.beat(dataFilter) transactions.add(first) second: Data = Data(first.hash, bytes(1)) second.sign(edPrivKey) second.beat(dataFilter) transactions.add(second) #Verify them. firstVerif: SignedVerification = SignedVerification(first.hash) firstVerif.sign(0, blsPrivKey)
b"MEROS_DEVELOPER_NETWORK", 60, int( "FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 16), 100) #Ed25519 keys. edPrivKey: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32) edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #BLS keys. blsPrivKey: blspy.PrivateKey = blspy.PrivateKey.from_seed(b'\0') blsPubKey: blspy.PublicKey = blsPrivKey.get_public_key() #Add 5 Blank Blocks. for i in range(5): merit.add(transactions, consensus, Block.fromJSON(blankBlocks[i])) #Create the Data. data: Data = Data(edPubKey.to_bytes().rjust(48, b'\0'), bytes()) data.sign(edPrivKey) data.beat(consensus.dataFilter) data.verified = True transactions.add(data) #Verify it. verif: SignedVerification = SignedVerification(data.hash) verif.sign(blsPrivKey, 0) consensus.add(verif) #Generate another 6 Blocks. #Next block should have a record.
edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #BLS Keys. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) blsPubKey: PublicKey = blsPrivKey.toPublicKey() #SpamFilter. spamFilter: SpamFilter = SpamFilter(5) #Blockchains. e1Chain: Blockchain = Blockchain() e2Chain: Blockchain = Blockchain() #Generate a Block granting the holder Merit. block = Block( BlockHeader(0, e1Chain.last(), bytes(32), 1, bytes(4), bytes(32), blsPubKey.serialize(), e1Chain.blocks[-1].header.time + 1200), BlockBody()) #Mine it. block.mine(blsPrivKey, e1Chain.difficulty()) #Add it. e1Chain.add(block) e2Chain.add(block) print("Generated Hundred Thirty Three Block 1/2 " + str(len(e1Chain.blocks)) + ".") #Create the initial Data and two competing Datas. datas: List[Data] = [Data(bytes(32), edPubKey.to_bytes())] datas.append(Data(datas[0].hash, b"Initial Data.")) datas.append(Data(datas[0].hash, b"Second Data.")) for data in datas:
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())
#Blake2b standard function. from hashlib import blake2b #JSON standard lib. import json #Blockchain. blockchain: Blockchain = Blockchain() #Miner Private Key. privKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) #Create the Block. block: Block = Block( BlockHeader(0, blockchain.last(), bytes(32), 1, bytes(4), bytes(32), privKey.toPublicKey().serialize(), blockchain.blocks[-1].header.time + 1200), BlockBody()) #Generate blocks. for i in range(1, 26): #Mine the Block. block.mine(privKey, blockchain.difficulty()) #Add it locally. blockchain.add(block) print("Generated Blank Block " + str(i) + ".") #Create the next Block. block = Block( BlockHeader(0, blockchain.last(), bytes(32), 1, bytes(4), bytes(32), 0, blockchain.blocks[-1].header.time + 1200), BlockBody())
#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] = [] elements.append(SendDifficulty(0, 0, 1)) block = Block(
#Blake2b standard function. from hashlib import blake2b #JSON standard lib. import json #Blockchain. blockchain: Blockchain = Blockchain() #BLS Keys. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) blsPubKey: PublicKey = blsPrivKey.toPublicKey() #Generate a Block granting the holder Merit. block = Block( BlockHeader(0, blockchain.last(), bytes(32), 1, bytes(4), bytes(32), blsPubKey.serialize(), blockchain.blocks[-1].header.time + 1200), BlockBody()) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #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)
from hashlib import blake2b #JSON standard lib. import json #Miner Private Key. privKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) #Blockchains. bbFile: IO[Any] = open("PythonTests/Vectors/Merit/BlankBlocks.json", "r") blocks: List[Dict[str, Any]] = json.loads(bbFile.read()) main: Blockchain = Blockchain.fromJSON(blocks) #Only add the first 15 to the alt chain. alt: Blockchain = Blockchain() for b in range(15): alt.add(Block.fromJSON(blocks[b])) #Generate an alternative five Blocks. for i in range(1, 5): #Create the next Block. block = Block( BlockHeader( 0, alt.last(), bytes(32), 1, bytes(4), bytes(32), 0, alt.blocks[-1].header.time + 1 #Use a much shorter time to acquire more work.
#Ed25519 keys. edPrivKey: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32) edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #BLS keys. blsPrivKeys: List[PrivateKey] = [ PrivateKey(blake2b(b'\0', digest_size=32).digest()), PrivateKey(blake2b(b'\1', digest_size=32).digest()) ] blsPubKeys: List[PublicKey] = [ blsPrivKeys[0].toPublicKey(), blsPrivKeys[1].toPublicKey() ] #Add 4 Blank Blocks. for i in range(4): merit.add(Block.fromJSON(merit.blockchain.keys, blankBlocks[i])) #Add a 5th Block to another verifier. block: Block = Block( BlockHeader(0, merit.blockchain.last(), bytes(32), 1, bytes(4), bytes(32), blsPubKeys[1].serialize(), merit.blockchain.blocks[-1].header.time + 1200), BlockBody()) #Mine it. block.mine(blsPrivKeys[1], merit.blockchain.difficulty()) #Add it. merit.add(block) print("Generated Aggregated Claim Block " + str(len(merit.blockchain.blocks) - 1) + ".") #Create the Datas.
#Spam Filter. dataFilter: SpamFilter = SpamFilter(bytes.fromhex("CC" * 32)) #Ed25519 keys. edPrivKey: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32) edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #BLS Keys. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) blsPubKey: PublicKey = blsPrivKey.toPublicKey() #Add a single Block to create Merit. bbFile: IO[Any] = open("PythonTests/Vectors/Merit/BlankBlocks.json", "r") blocks: List[Dict[str, Any]] = json.loads(bbFile.read()) blockchain.add(Block.fromJSON(blockchain.keys, blocks[0])) bbFile.close() #Create a Data with an invalid signature. data: Data = Data(bytes(32), edPubKey.to_bytes()) data.signature = edPrivKey.sign(b"INVALID") data.beat(dataFilter) #Create a Verification. sv: SignedVerification = SignedVerification(data.hash) sv.sign(0, blsPrivKey) #Create packets out of the Verification. packets: List[VerificationPacket] = [VerificationPacket(data.hash, [0])] #Generate another Block.
cmFile.close() #Ed25519 keys. edPrivKey1: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32) edPubKey1: ed25519.VerifyingKey = edPrivKey1.get_verifying_key() edPubKey2: ed25519.VerifyingKey = ed25519.SigningKey(b'\1' * 32).get_verifying_key() #BLS keys. blsPrivKey1: blspy.PrivateKey = blspy.PrivateKey.from_seed(b'\0') blsPubKey1: blspy.PublicKey = blsPrivKey1.get_public_key() blsPrivKey2: blspy.PrivateKey = blspy.PrivateKey.from_seed(b'\1') blsPubKey2: blspy.PublicKey = blsPrivKey2.get_public_key() #Give the second key pair Merit. block: Block = Block( BlockHeader(13, blockchain.last(), int(time())), BlockBody([], [(blsPubKey2, 100)]) ) block.mine(blockchain.difficulty()) blockchain.add(block) print("Generated Competing Block " + str(block.header.nonce) + ".") #Grab the claim hash. claim: bytes = Verification.fromElement(consensus.holders[blsPubKey1.serialize()][1]).hash #Create two competing Sends. send1: Send = Send( [(claim, 0)], [( edPubKey1.to_bytes(), Claim.fromTransaction(transactions.txs[claim]).amount )]
#Transactions. transactions: Transactions = Transactions() #Blockchain. blockchain: Blockchain = Blockchain() #Ed25519 keys. edPrivKey: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32) edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #BLS keys. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) blsPubKey: PublicKey = blsPrivKey.toPublicKey() #Generate a Block granting the holder Merit. block = Block( BlockHeader(0, blockchain.last(), bytes(32), 1, bytes(4), bytes(32), blsPubKey.serialize(), blockchain.blocks[-1].header.time + 1200), BlockBody()) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated Invalid Competing Block " + str(len(blockchain.blocks)) + ".") #Create a Data using a bogus input. data: Data = Data(bytes.fromhex("11" * 32), bytes(1)) transactions.add(data) #Create a competing Data using the same input. competingData: Data = Data(bytes.fromhex("11" * 32), bytes(2)) transactions.add(competingData)
blsPubKey: PublicKey = blsPrivKey.toPublicKey() #SpamFilter. spamFilter: SpamFilter = SpamFilter(bytes.fromhex("CC" * 32)) #Blockchain. blockchain: Blockchain = Blockchain() #Generate a Block granting the holder Merit. block = Block( BlockHeader( 0, blockchain.last(), bytes(32), 1, bytes(4), bytes(32), blsPubKey.serialize(), blockchain.blocks[-1].header.time + 1200 ), BlockBody() ) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated Verify Competing Block " + str(len(blockchain.blocks)) + ".") #Create the initial Data and two competing Datas. datas: List[Data] = [Data(bytes(32), edPubKey.to_bytes())]
"FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 16)) #BLS Keys. privKey: blspy.PrivateKey = blspy.PrivateKey.from_seed(b'\0') pubKey: blspy.PublicKey = privKey.get_public_key() #Ed25519 keys. edKeys: List[ed25519.SigningKey] = [] for i in range(6): edKeys.append(ed25519.SigningKey(i.to_bytes(1, "big") * 32)) #Add a single Block to create Merit. bbFile: IO[Any] = open("PythonTests/Vectors/Merit/BlankBlocks.json", "r") blocks: List[Dict[str, Any]] = json.loads(bbFile.read()) blockchain.add(Block.fromJSON(blocks[0])) bbFile.close() #Create a Data per key. datas: List[Data] = [] for edPrivKey in edKeys: datas.append( Data(edPrivKey.get_verifying_key().to_bytes().rjust(48, b'\0'), bytes())) datas[-1].sign(edPrivKey) datas[-1].beat(consensus.dataFilter) #Create 1 Verification per Data. verifs: List[SignedVerification] = [] for d in range(len(datas)): verifs.append(SignedVerification(datas[d].hash))
#JSON standard lib. import json #Blockchains. main: Blockchain = Blockchain() alt: Blockchain = Blockchain() #Miner Private Keys. privKeys: List[PrivateKey] = [ PrivateKey(blake2b(b'\0', digest_size=32).digest()), PrivateKey(blake2b(b'\1', digest_size=32).digest()) ] #Create the Block to the first miner. block: Block = Block( BlockHeader(0, main.last(), bytes(32), 1, bytes(4), bytes(32), privKeys[0].toPublicKey().serialize(), main.blocks[-1].header.time + 1200), BlockBody()) block.mine(privKeys[0], main.difficulty()) main.add(block) alt.add(block) print("Generated Reorganizations Depth One Block 1.") #Create the Block to the second miner. block = Block( BlockHeader(0, main.last(), bytes(32), 1, bytes(4), bytes(32), privKeys[1].toPublicKey().serialize(), main.blocks[-1].header.time + 1200), BlockBody()) block.mine(privKeys[1], alt.difficulty()) main.add(block) alt.add(block) print("Generated Reorganizations Depth One Block 2.")
#BLS Keys. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) blsPubKey: PublicKey = blsPrivKey.toPublicKey() #Create a DataDifficulty. dataDiffs: List[SignedDataDifficulty] = [ SignedDataDifficulty(3, 0), SignedDataDifficulty(1, 1) ] for dataDiff in dataDiffs: dataDiff.sign(0, blsPrivKey) #Generate a Block containing the DataDifficulty. 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 DataDifficulty 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()) block.mine(blsPrivKey, blockchain.difficulty())
#Ed25519 keys. edPrivKey: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32) edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #BLS keys. blsPrivKeys: List[PrivateKey] = [ PrivateKey(blake2b(b'\0', digest_size=32).digest()), PrivateKey(blake2b(b'\1', digest_size=32).digest()) ] blsPubKeys: List[PublicKey] = [ blsPrivKeys[0].toPublicKey(), blsPrivKeys[1].toPublicKey() ] #Give the first key Merit. block: Block = Block( BlockHeader(0, blockchain.last(), bytes(32), 1, bytes(4), bytes(32), blsPubKeys[0].serialize(), blockchain.blocks[-1].header.time + 1200), BlockBody()) #Mine it. block.mine(blsPrivKeys[0], blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated Hundred Forty Two Block " + str(len(blockchain.blocks)) + ".") #Give the second key Merit. block: Block = Block( BlockHeader(0, blockchain.last(), bytes(32), 1, bytes(4), bytes(32), blsPubKeys[1].serialize(), blockchain.blocks[-1].header.time + 1200), BlockBody()) block.mine(blsPrivKeys[1], blockchain.difficulty())
merit: Merit = Merit() #SpamFilter. dataFilter: SpamFilter = SpamFilter(bytes.fromhex("CC" * 32)) #Ed25519 keys. edPrivKey: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32) edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #BLS keys. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) blsPubKey: PublicKey = blsPrivKey.toPublicKey() #Add 5 Blank Blocks. for i in range(5): merit.add(Block.fromJSON(merit.blockchain.keys, blankBlocks[i])) #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(
from hashlib import blake2b #JSON standard lib. import json #Miner Private Key. privKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) #Blockchains. bbFile: IO[Any] = open("PythonTests/Vectors/Merit/BlankBlocks.json", "r") blocks: List[Dict[str, Any]] = json.loads(bbFile.read()) main: Blockchain = Blockchain.fromJSON(blocks) #Only add the first 15 to the alt chain. alt: Blockchain = Blockchain() for b in range(15): alt.add(Block.fromJSON(blocks[b])) #Generate an alternative fifteen Blocks. for i in range(1, 15): #Create the next Block. block = Block( BlockHeader( 0, alt.last(), bytes(32), 1, bytes(4), bytes(32), 0, alt.blocks[-1].header.time + 1201 #Use a slightly different time to ensure a different hash. ),
#Time standard function. from time import time #JSON standard lib. import json #Blockchain. blockchain: Blockchain = Blockchain( b"MEROS_DEVELOPER_NETWORK", 60, int("FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 16) ) #Generate blocks. for i in range(1, 26): #Create the Block. block: Block = Block( BlockHeader(i, blockchain.last(), int(time())), BlockBody() ) block.mine(blockchain.difficulty()) #Add it locally. blockchain.add(block) print("Generated Blank Block " + str(i) + ".") vectors: IO[Any] = open("PythonTests/Vectors/Merit/BlankBlocks.json", "w") vectors.write(json.dumps(blockchain.toJSON())) vectors.close()
edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #BLS Keys. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) blsPubKey: PublicKey = blsPrivKey.toPublicKey() #SpamFilter. spamFilter: SpamFilter = SpamFilter(5) #Blockchains. packetedChain: Blockchain = Blockchain() reorderedChain: Blockchain = Blockchain() #Generate a Block granting the holder Merit. block = Block( BlockHeader(0, packetedChain.last(), bytes(32), 1, bytes(4), bytes(32), blsPubKey.serialize(), packetedChain.blocks[-1].header.time + 1200), BlockBody()) #Mine it. block.mine(blsPrivKey, packetedChain.difficulty()) #Add it. packetedChain.add(block) reorderedChain.add(block) print("Generated Hundred Twenty Three Packet Block 1/2 " + str(len(packetedChain.blocks)) + ".") #Create the initial Data and two competing Datas. datas: List[Data] = [Data(bytes(32), edPubKey.to_bytes())] datas.append(Data(datas[0].hash, b"Initial Data.")) datas.append(Data(datas[0].hash, b"Second Data.")) for data in datas:
blockchain: Blockchain = Blockchain( b"MEROS_DEVELOPER_NETWORK", 60, int( "FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 16)) #BLS Keys. privKey: blspy.PrivateKey = blspy.PrivateKey.from_seed(b'\0') pubKey: blspy.PublicKey = privKey.get_public_key() #Load a Multiple Block and load their MeritRemoval. snFile: IO[Any] = open( "PythonTests/Vectors/Consensus/MeritRemoval/SameNonce.json", "r") snVectors: Dict[str, Any] = json.loads(snFile.read()) blockchain.add(Block.fromJSON(snVectors["blockchain"][0])) removal1: SignedMeritRemoval = SignedMeritRemoval.fromJSON( snVectors["removal"]) snFile.close() #Create a second MeritRemoval. sv: SignedVerification = SignedVerification(b'\1' * 48) sv.sign(privKey, 0) removal2: SignedMeritRemoval = SignedMeritRemoval( removal1.se1, SignedElement.fromElement(sv)) #Add the second MeritRemoval to Consensus. consensus.add(removal2)
[(claim, 0), (claim, 0)], [(edPubKey.to_bytes(), Claim.fromTransaction(transactions.txs[claim]).amount * 2)]) 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) + ".") #Save the vector. result: Dict[str, Any] = { "blockchain": blockchain.toJSON(), "transactions": transactions.toJSON() }
#BLS Keys. blsPrivKey: PrivateKey = PrivateKey(blake2b(b'\0', digest_size=32).digest()) blsPubKey: PublicKey = blsPrivKey.toPublicKey() #Ed25519 keys. edPrivKey: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32) edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key() #Generate a Block granting the holder Merit. block = Block( BlockHeader( 0, blockchain.last(), bytes(32), 1, bytes(4), bytes(32), blsPubKey.serialize(), blockchain.blocks[-1].header.time + 1200 ), BlockBody() ) #Mine it. block.mine(blsPrivKey, blockchain.difficulty()) #Add it. blockchain.add(block) print("Generated Same Element Block " + str(len(blockchain.blocks)) + ".") #Create a SendDifficulty. sendDiff: SignedSendDifficulty = SignedSendDifficulty(4, 0)