def sign(
self,
holder: int,
privKey: PrivateKey
) -> None:
self.holder = holder
self.signature = privKey.sign(self.signatureSerialize())
def mine(
self,
privKey: PrivateKey,
difficulty: int
) -> None:
self.header.proof = -1
while (
(self.header.proof == -1) or
((int.from_bytes(self.header.hash, "big") * difficulty) > int.from_bytes(bytes.fromhex("FF" * 32), "big"))
):
self.header.proof += 1
self.header.hash = RandomX(self.header.serializeHash())
self.header.signature = privKey.sign(self.header.hash).serialize()
self.header.hash = RandomX(self.header.hash + self.header.signature)
def HundredSixSignedElementsTest(rpc: RPC) -> None:
#Blockchain. Solely used to get the genesis Block hash.
blockchain: Blockchain = Blockchain()
#BLS Key.
blsPrivKey: PrivateKey = PrivateKey(
blake2b(b'\0', digest_size=32).digest())
sig: Signature = blsPrivKey.sign(bytes())
#Create a Data.
#This is required so the Verification isn't terminated early for having an unknown hash.
data: bytes = bytes.fromhex(rpc.call("personal", "data", ["AA"]))
#Create a signed Verification, SendDifficulty, and DataDifficulty.
elements: List[SignedElement] = [
SignedVerification(data, 1, sig),
SignedSendDifficulty(bytes.fromhex("00" * 32), 0, 1, sig),
SignedDataDifficulty(bytes.fromhex("00" * 32), 0, 1, sig)
]
for elem in elements:
#Handshake with the node.
rpc.meros.connect(254, 254, blockchain.blocks[0].header.hash)
#Send the Element.
rpc.meros.signedElement(elem)
#Sleep for a bit.
sleep(0.2)
#Verify the node didn't crash.
try:
if rpc.call("merit", "getHeight") != 1:
raise Exception()
except Exception:
raise TestError(
"Node crashed after being sent a malformed Element.")
cmVectors: Dict[str, Any] = json.loads(cmFile.read())
#Transactions.
transactions: Transactions = Transactions.fromJSON(cmVectors["transactions"])
#Blockchain.
blockchain: Blockchain = Blockchain.fromJSON(cmVectors["blockchain"])
cmFile.close()
#SpamFilter.
sendFilter: SpamFilter = SpamFilter(3)
#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()
#Grab the Claim hash.
claim: bytes = blockchain.blocks[-1].body.packets[0].hash
#Create a Send spending it twice.
send: Send = Send(
[(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.
#Ed25519 lib.
import ed25519
#Blake2b standard function.
from hashlib import blake2b
#JSON standard lib.
import json
#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()
#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.
def EightyEightTest(rpc: RPC) -> None:
#Ed25519 key.
edPrivKey: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32)
edPubKey: ed25519.VerifyingKey = edPrivKey.get_verifying_key()
#BLS key.
blsPrivKey: PrivateKey = PrivateKey(
blake2b(b'\0', digest_size=32).digest())
blsPubKey: str = blsPrivKey.toPublicKey().serialize().hex()
#Blocks.
file: IO[Any] = open("PythonTests/Vectors/Merit/BlankBlocks.json", "r")
blocks: List[Dict[str, Any]] = json.loads(file.read())
file.close()
#Merit.
merit: Merit = Merit()
#Spam Filter.
dataFilter: SpamFilter = SpamFilter(bytes.fromhex("CC" * 32))
#Handshake with the node.
rpc.meros.connect(254, 254, merit.blockchain.blocks[0].header.hash)
#Send the first Block.
block: Block = Block.fromJSON(merit.blockchain.keys, blocks[0])
merit.blockchain.add(block)
rpc.meros.blockHeader(block.header)
#Handle sync requests.
reqHash: bytes = bytes()
while True:
msg: bytes = rpc.meros.recv()
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.
rpc.meros.blockBody(merit.state.nicks, block)
elif MessageType(msg[0]) == MessageType.SyncingOver:
pass
elif MessageType(msg[0]) == MessageType.BlockHeader:
break
else:
raise TestError("Unexpected message sent: " + msg.hex().upper())
#Create two Datas.
datas: List[Data] = [Data(bytes(32), edPubKey.to_bytes())]
datas.append(Data(datas[0].hash, b"Hello there! General Kenobi."))
for data in datas:
#Sign them and have them beat the spam filter.
data.sign(edPrivKey)
data.beat(dataFilter)
#Transmit them.
rpc.meros.transaction(data)
#Verify both.
verifs: List[SignedVerification] = [
SignedVerification(datas[0].hash),
SignedVerification(datas[1].hash)
]
for verif in verifs:
verif.sign(0, blsPrivKey)
#Only transmit the second.
rpc.meros.signedElement(verifs[1])
sleep(0.5)
#Verify the block template has no verifications.
if bytes.fromhex(
rpc.call("merit", "getBlockTemplate",
[blsPubKey])["header"])[36:68] != bytes(32):
raise TestError("Block template has Verification Packets.")
#Transmit the first signed verification.
rpc.meros.signedElement(verifs[0])
sleep(0.5)
#Verify the block template has both verifications.
template: Dict[str, Any] = rpc.call("merit", "getBlockTemplate",
[blsPubKey])
template["header"] = bytes.fromhex(template["header"])
packets: List[VerificationPacket] = [
VerificationPacket(datas[0].hash, [0]),
VerificationPacket(datas[1].hash, [0])
]
if template["header"][36:68] != BlockHeader.createContents(
merit.state.nicks, packets):
raise TestError(
"Block template doesn't have both Verification Packets.")
#Mine the Block.
block = Block(
BlockHeader(
0,
block.header.hash,
BlockHeader.createContents(merit.state.nicks, packets),
1,
template["header"][-43:-39],
BlockHeader.createSketchCheck(template["header"][-43:-39],
packets),
0,
int.from_bytes(template["header"][-4:], byteorder="big"),
),
BlockBody(
packets, [],
Signature.aggregate([verifs[0].signature, verifs[1].signature])))
if block.header.serializeHash()[:-4] != template["header"]:
raise TestError("Failed to recreate the header.")
if block.body.serialize(merit.state.nicks, block.header.sketchSalt,
len(packets)) != bytes.fromhex(template["body"]):
raise TestError("Failed to recreate the body.")
block.mine(blsPrivKey, merit.blockchain.difficulty())
merit.blockchain.add(block)
#Publish it.
rpc.call("merit", "publishBlock", [
template["id"],
(template["header"] + block.header.proof.to_bytes(4, byteorder="big") +
block.header.signature + block.body.serialize(
merit.state.nicks, block.header.sketchSalt, len(packets))).hex()
])
#Verify the Blockchain.
verifyBlockchain(rpc, merit.blockchain)
#Transactions.
transactions: Transactions = Transactions.fromJSON(cmVectors["transactions"])
#Blockchain.
blockchain: Blockchain = Blockchain.fromJSON(cmVectors["blockchain"])
cmFile.close()
#SpamFilter.
sendFilter: SpamFilter = SpamFilter(bytes.fromhex("AA" * 32))
#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()
]
#Grab the Claim hash.
claim: bytes = blockchain.blocks[-1].body.packets[0].hash
#Create 12 Sends.
sends: List[Send] = []
sends.append(
Send(
[(claim, 0)],
def TElementTest(rpc: RPC) -> None:
#BLS key.
blsPrivKey: PrivateKey = PrivateKey(
blake2b(b'\0', digest_size=32).digest())
blsPubKey: str = blsPrivKey.toPublicKey().serialize().hex()
#Blocks.
file: IO[Any] = open("PythonTests/Vectors/Merit/BlankBlocks.json", "r")
blocks: List[Dict[str, Any]] = json.loads(file.read())
file.close()
#Merit.
merit: Merit = Merit()
#Handshake with the node.
rpc.meros.connect(254, 254, merit.blockchain.blocks[0].header.hash)
#Send the first Block.
block: Block = Block.fromJSON(merit.blockchain.keys, blocks[0])
merit.blockchain.add(block)
rpc.meros.blockHeader(block.header)
#Handle sync requests.
reqHash: bytes = bytes()
while True:
msg: bytes = rpc.meros.recv()
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.
rpc.meros.blockBody(merit.state.nicks, block)
elif MessageType(msg[0]) == MessageType.SyncingOver:
pass
elif MessageType(msg[0]) == MessageType.BlockHeader:
break
else:
raise TestError("Unexpected message sent: " + msg.hex().upper())
#Create and transmit a DataDifficulty.
dataDiff: SignedDataDifficulty = SignedDataDifficulty(
bytes.fromhex("00" * 32), 0, 0)
dataDiff.sign(0, blsPrivKey)
rpc.meros.signedElement(dataDiff)
sleep(0.5)
#Verify the block template has the DataDifficulty.
template: Dict[str, Any] = rpc.call("merit", "getBlockTemplate",
[blsPubKey])
template["header"] = bytes.fromhex(template["header"])
if template["header"][36:68] != BlockHeader.createContents(
merit.state.nicks, [], [dataDiff]):
raise TestError("Block template doesn't have the Data Difficulty.")
#Mine the Block.
block = Block(
BlockHeader(
0,
block.header.hash,
BlockHeader.createContents(merit.state.nicks, [], [dataDiff]),
1,
template["header"][-43:-39],
BlockHeader.createSketchCheck(template["header"][-43:-39], []),
0,
int.from_bytes(template["header"][-4:], byteorder="big"),
), BlockBody([], [dataDiff], dataDiff.signature))
if block.header.serializeHash()[:-4] != template["header"]:
raise TestError("Failed to recreate the header.")
if block.body.serialize(merit.state.nicks,
block.header.sketchSalt) != bytes.fromhex(
template["body"]):
raise TestError("Failed to recreate the body.")
block.mine(blsPrivKey, merit.blockchain.difficulty())
merit.blockchain.add(block)
#Publish it.
rpc.call("merit", "publishBlock", [
template["id"],
(template["header"] + block.header.proof.to_bytes(4, byteorder="big") +
block.header.signature + block.body.serialize(
merit.state.nicks, block.header.sketchSalt)).hex()
])
#Create and transmit a new DataDifficulty.
dataDiff = SignedDataDifficulty(bytes.fromhex("AA" * 32), 1, 0)
dataDiff.sign(0, blsPrivKey)
rpc.meros.signedElement(dataDiff)
sleep(0.5)
#Verify the block template has the DataDifficulty.
template = rpc.call("merit", "getBlockTemplate", [blsPubKey])
template["header"] = bytes.fromhex(template["header"])
if template["header"][36:68] != BlockHeader.createContents(
merit.state.nicks, [], [dataDiff]):
raise TestError("Block template doesn't have the new Data Difficulty.")
#Create and transmit a new DataDifficulty reusing an existing nonce.
signatures: List[Signature] = [dataDiff.signature]
dataDiff = SignedDataDifficulty(bytes.fromhex("BB" * 32), 1, 0)
dataDiff.sign(0, blsPrivKey)
signatures.append(dataDiff.signature)
rpc.meros.signedElement(dataDiff)
sleep(0.5)
#Verify the block template has a MeritRemoval.
mr: MeritRemoval = MeritRemoval(
SignedDataDifficulty(bytes.fromhex("AA" * 32), 1, 0),
SignedDataDifficulty(bytes.fromhex("BB" * 32), 1, 0), False)
template = rpc.call("merit", "getBlockTemplate", [blsPubKey])
template["header"] = bytes.fromhex(template["header"])
if template["header"][36:68] != BlockHeader.createContents(
merit.state.nicks, [], [mr]):
raise TestError("Block template doesn't have the Merit Removal.")
#Mine the Block.
block = Block(
BlockHeader(
0,
block.header.hash,
BlockHeader.createContents(merit.state.nicks, [], [mr]),
1,
template["header"][-43:-39],
BlockHeader.createSketchCheck(template["header"][-43:-39], []),
0,
int.from_bytes(template["header"][-4:], byteorder="big"),
), BlockBody([], [mr], Signature.aggregate(signatures)))
if block.header.serializeHash()[:-4] != template["header"]:
raise TestError("Failed to recreate the header.")
if block.body.serialize(merit.state.nicks,
block.header.sketchSalt) != bytes.fromhex(
template["body"]):
raise TestError("Failed to recreate the body.")
block.mine(blsPrivKey, merit.blockchain.difficulty())
merit.blockchain.add(block)
#Publish it.
rpc.call("merit", "publishBlock", [
template["id"],
(template["header"] + block.header.proof.to_bytes(4, byteorder="big") +
block.header.signature + block.body.serialize(
merit.state.nicks, block.header.sketchSalt)).hex()
])
#Verify the Blockchain.
verifyBlockchain(rpc, merit.blockchain)
def HundredFiftyFiveTest(rpc: RPC) -> None:
#Ed25519 keys.
edPrivKeys: List[ed25519.SigningKey] = [
ed25519.SigningKey(b'\0' * 32),
ed25519.SigningKey(b'\1' * 32)
]
edPubKeys: List[ed25519.VerifyingKey] = [
edPrivKeys[0].get_verifying_key(), edPrivKeys[1].get_verifying_key()
]
#BLS keys.
blsPrivKey: PrivateKey = PrivateKey(
bytes.fromhex(rpc.call("personal", "getMiner")))
blsPubKey: bytes = blsPrivKey.toPublicKey().serialize()
#Blockchain.
blockchain: Blockchain = Blockchain()
#Spam Filter.
dataFilter: SpamFilter = SpamFilter(5)
#Handshake with the node.
rpc.meros.liveConnect(blockchain.blocks[0].header.hash)
rpc.meros.syncConnect(blockchain.blocks[0].header.hash)
#Call getBlockTemplate just to get an ID.
#Skips the need to write a sync loop for the BlockBody.
template: Dict[str, Any] = rpc.call("merit", "getBlockTemplate",
[blsPubKey.hex()])
#Mine a Block.
block = Block(
BlockHeader(0, blockchain.blocks[0].header.hash, bytes(32), 1,
bytes(4), bytes(32), blsPubKey,
blockchain.blocks[0].header.time + 1200, 0), BlockBody())
block.mine(blsPrivKey, blockchain.difficulty())
blockchain.add(block)
#Publish it.
rpc.call("merit", "publishBlock",
[template["id"], block.serialize().hex()])
#Handle the fact Meros will now broadcast it to us.
if MessageType(rpc.meros.live.recv()[0]) != MessageType.BlockHeader:
raise TestError("Meros didn't broadcast the Block it just published.")
#Create the Datas.
datas: List[Data] = [
Data(bytes(32), edPubKeys[0].to_bytes()),
Data(bytes(32), edPubKeys[1].to_bytes())
]
for d in range(len(datas)):
#Sign, and mine the Data.
datas[d].sign(edPrivKeys[d])
datas[d].beat(dataFilter)
#Send the Data and verify Meros sends it back.
if rpc.meros.liveTransaction(datas[d]) != rpc.meros.live.recv():
raise TestError("Meros didn't send back the Data.")
#Verify Meros sends back a Verification.
res: bytes = rpc.meros.live.recv()
if MessageType(res[0]) != MessageType.SignedVerification:
raise TestError("Meros didn't send a SignedVerification.")
verif: SignedVerification = SignedVerification(datas[d].hash)
verif.sign(0, blsPrivKey)
if res[1:] != verif.signedSerialize():
raise TestError(
"Meros didn't send the correct SignedVerification.")
