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)
