def TGUImmediatelyTest(rpc: RPC) -> None:
recipient: ed25519.SigningKey = ed25519.SigningKey(b'\1' * 32)
recipientPub: bytes = recipient.get_verifying_key().to_bytes()
address: str = bech32_encode("mr",
convertbits(bytes([0]) + recipientPub, 8, 5))
vectors: Dict[str, Any]
with open("e2e/Vectors/RPC/Transactions/GetUTXOs.json", "r") as file:
vectors = json.loads(file.read())
transactions: Transactions = Transactions.fromJSON(vectors["transactions"])
send: Send = Send.fromJSON(vectors["send"])
spendingSend: Send = Send.fromJSON(vectors["spendingSend"])
def start() -> None:
#Send the Send.
if rpc.meros.liveTransaction(send) != rpc.meros.live.recv():
raise TestError("Meros didn't broadcast back a Send.")
if rpc.call("transactions", "getUTXOs", {"address": address}) != []:
raise TestError(
"Meros considered an unconfirmed Transaction's outputs as UTXOs."
)
#Immediately spend it.
if rpc.meros.liveTransaction(spendingSend) != rpc.meros.live.recv():
raise TestError("Meros didn't broadcast back a Send.")
if rpc.call("transactions", "getUTXOs", {"address": address}) != []:
raise TestError(
"Meros didn't consider a Transaction's inputs as spent.")
#Verify the Send and make sure it's not considered as a valid UTXO.
verify(rpc, send.hash)
if rpc.call("transactions", "getUTXOs", {"address": address}) != []:
raise TestError(
"Meros considered a just confirmed Transaction with a spender's outputs as UTXOs."
)
def verified() -> None:
#Verify the spender and verify the state is unchanged.
verify(rpc, spendingSend.hash)
if rpc.call("transactions", "getUTXOs", {"address": address}) != []:
raise TestError(
"Meros didn't consider a verified Transaction's inputs as spent."
)
def finalizedSend() -> None:
#Sanity check the spending TX has yet to also finalize.
if rpc.call("consensus", "getStatus",
{"hash": spendingSend.hash.hex()})["finalized"]:
raise Exception(
"Test meant to only finalize the first Send, not both.")
#Verify the state is unchanged.
if rpc.call("transactions", "getUTXOs", {"address": address}) != []:
raise TestError(
"Meros didn't consider a verified Transaction's inputs as spent after the input finalized."
)
def finalizedSpendingSend() -> None:
#Verify the state is unchanged.
if rpc.call("transactions", "getUTXOs", {"address": address}) != []:
raise TestError(
"Meros didn't consider a finalized Transaction's inputs as spent."
)
Liver(rpc, vectors["blockchain"], transactions, {
50: start,
51: verified,
56: finalizedSend,
57: finalizedSpendingSend
}).live()
proto: PrototypeChain = PrototypeChain(7)
proto.add(1)
proto.add(2)
proto.add(3)
proto.add(4)
proto.add(elements=[SendDifficulty(1, 0, 2), SendDifficulty(1, 0, 4)])
merit: Merit = Merit.fromJSON(proto.toJSON())
transactions: Transactions = Transactions()
claim: Claim = Claim([(merit.mints[-1], 0)],
ed25519.SigningKey(b'\0' *
32).get_verifying_key().to_bytes())
claim.sign(PrivateKey(0))
transactions.add(claim)
send: Send = Send([(claim.hash, 0)], [(ed25519.SigningKey(
b'\1' * 32).get_verifying_key().to_bytes(), claim.amount)])
send.sign(ed25519.SigningKey(b'\0' * 32))
send.beat(SpamFilter(3))
transactions.add(send)
datas: List[Data] = [
Data(bytes(32),
ed25519.SigningKey(b'\0' * 32).get_verifying_key().to_bytes())
]
for _ in range(4):
datas[-1].sign(ed25519.SigningKey(b'\0' * 32))
datas[-1].beat(SpamFilter(5))
transactions.add(datas[-1])
datas.append(Data(datas[-1].hash, b'\0'))
del datas[-1]
proto: PrototypeChain = PrototypeChain(40, keepUnlocked=True)
proto.add(1)
merit: Merit = Merit.fromJSON(proto.toJSON())
#Create a Claim.
claim: Claim = Claim([(merit.mints[-1], 0)], edPubKey)
claim.sign(PrivateKey(0))
transactions.add(claim)
merit.add(
PrototypeBlock(merit.blockchain.blocks[-1].header.time + 1200,
packets=[VerificationPacket(claim.hash, list(range(2)))
]).finish(2, merit))
sends: List[Send] = [Send([(claim.hash, 0)], [(edPubKey, claim.amount)])]
sends.append(
Send([(claim.hash, 0), (sends[0].hash, 0)],
[(edPubKey, claim.amount * 2)]))
for send in sends:
send.sign(edPrivKey)
send.beat(sendFilter)
transactions.add(send)
#Verify the 'impossible' TX, mentioning the only possible one.
merit.add(
PrototypeBlock(merit.blockchain.blocks[-1].header.time + 1200,
packets=[
VerificationPacket(sends[1].hash, [0]),
VerificationPacket(sends[0].hash, [1])
transactions: Transactions = Transactions()
sendFilter: SpamFilter = SpamFilter(3)
proto: PrototypeChain = PrototypeChain(40, keepUnlocked=True)
proto.add(1)
proto.add(2)
proto.add(3)
proto.add(4)
merit: Merit = Merit.fromJSON(proto.toJSON())
#Create a Claim and a Send splitting its outputs.
claim: Claim = Claim([(merit.mints[-1], 0)], edPubKey)
claim.sign(PrivateKey(0))
transactions.add(claim)
splitSend: Send = Send([(claim.hash, 0)], [(edPubKey, claim.amount // 2) for _ in range(2)])
splitSend.sign(edPrivKey)
splitSend.beat(sendFilter)
transactions.add(splitSend)
merit.add(
PrototypeBlock(
merit.blockchain.blocks[-1].header.time + 1200,
packets=[
VerificationPacket(claim.hash, list(range(5))),
VerificationPacket(splitSend.hash, list(range(5)))
]
).finish(5, merit)
)
#We need to define two families. Family A (send output 0) and family B (send output 1).
proto.add(2) proto.add(3) proto.add(4) proto.add(elements=[SendDifficulty(1, 0, 2), SendDifficulty(1, 0, 4)]) merit: Merit = Merit.fromJSON(proto.toJSON()) transactions: Transactions = Transactions() claim: Claim = Claim( [(merit.mints[-1], 0)], Ristretto.SigningKey(b'\0' * 32).get_verifying_key() ) claim.sign(PrivateKey(0)) transactions.add(claim) send: Send = Send( [(claim.hash, 0)], [(Ristretto.SigningKey(b'\1' * 32).get_verifying_key(), claim.amount)] ) send.sign(Ristretto.SigningKey(b'\0' * 32)) send.beat(SpamFilter(3)) transactions.add(send) datas: List[Data] = [ Data(bytes(32), Ristretto.SigningKey(b'\0' * 32).get_verifying_key()) ] for _ in range(4): datas[-1].sign(Ristretto.SigningKey(b'\0' * 32)) datas[-1].beat(SpamFilter(5)) transactions.add(datas[-1]) datas.append(Data(datas[-1].hash, b'\0')) del datas[-1]
def PublishTransactionTest(rpc: RPC) -> None:
privKey: Ristretto.SigningKey = Ristretto.SigningKey(b'\0' * 32)
pubKey: bytes = privKey.get_verifying_key()
sentToKey: Ristretto.SigningKey = Ristretto.SigningKey(b'\1' * 32)
sendFilter: SpamFilter = SpamFilter(3)
dataFilter: SpamFilter = SpamFilter(5)
vectors: Dict[str, Any]
with open("e2e/Vectors/Transactions/ClaimedMint.json", "r") as file:
vectors = json.loads(file.read())
transactions: Transactions = Transactions.fromJSON(vectors["transactions"])
if len(transactions.txs) != 1:
raise Exception("Transactions DAG doesn't have just the Claim.")
claim: Claim = Claim.fromTransaction(next(iter(transactions.txs.values())))
send: Send = Send([(claim.hash, 0)],
[(sentToKey.get_verifying_key(), claim.amount)])
send.sign(privKey)
send.beat(sendFilter)
data: Data = Data(bytes(32), pubKey)
data.sign(privKey)
data.beat(dataFilter)
def publishAndVerify() -> None:
if not rpc.call("transactions", "publishTransaction", {
"type": "Claim",
"transaction": claim.serialize().hex()
}, False):
raise TestError(
"Publishing a valid Transaction didn't return true.")
if rpc.meros.live.recv()[1:] != claim.serialize():
raise TestError(
"publishTransaction didn't broadcast the Transaction.")
if not rpc.call("transactions", "publishTransaction", {
"type": "Send",
"transaction": send.serialize().hex()
}, False):
raise TestError(
"Publishing a valid Transaction didn't return true.")
if rpc.meros.live.recv()[1:] != send.serialize():
raise TestError(
"publishTransaction didn't broadcast the Transaction.")
if not rpc.call("transactions", "publishTransaction", {
"type": "Data",
"transaction": data.serialize().hex()
}, False):
raise TestError(
"Publishing a valid Transaction didn't return true.")
if rpc.meros.live.recv()[1:] != data.serialize():
raise TestError(
"publishTransaction didn't broadcast the Transaction.")
#Verify all three were entered properly.
verifyTransaction(rpc, claim)
verifyTransaction(rpc, send)
verifyTransaction(rpc, data)
#Create a new Send/Data and publish them without work.
sendSentWithoutWork: Send = Send([(send.hash, 0)],
[(pubKey, claim.amount)])
sendSentWithoutWork.sign(sentToKey)
sendSentWithoutWork.beat(sendFilter)
dataSentWithoutWork: Data = Data(bytes(32),
sentToKey.get_verifying_key())
dataSentWithoutWork.sign(sentToKey)
dataSentWithoutWork.beat(dataFilter)
if not rpc.call(
"transactions", "publishTransactionWithoutWork", {
"type": "Send",
"transaction": sendSentWithoutWork.serialize()[:-4].hex()
}, True):
raise TestError(
"Publishing a valid Transaction without work didn't return true."
)
if rpc.meros.live.recv()[1:] != sendSentWithoutWork.serialize():
raise TestError(
"publishTransaction didn't broadcast the Transaction.")
if not rpc.call(
"transactions", "publishTransactionWithoutWork", {
"type": "Data",
"transaction": dataSentWithoutWork.serialize()[:-4].hex()
}, True):
raise TestError(
"Publishing a valid Transaction without work didn't return true."
)
if rpc.meros.live.recv()[1:] != dataSentWithoutWork.serialize():
raise TestError(
"publishTransaction didn't broadcast the Transaction.")
#Call verify now, which will test ours with work against Meros's with generated work.
#Both should terminate on the earliest valid proof, making them identical.
verifyTransaction(rpc, sendSentWithoutWork)
verifyTransaction(rpc, dataSentWithoutWork)
#Re-publishing a Transaction should still return true.
if not rpc.call("transactions", "publishTransaction", {
"type": "Data",
"transaction": data.serialize().hex()
}, False):
raise TestError(
"Publishing an existing Transaction didn't return true.")
if MessageType(rpc.meros.live.recv()[0]) == MessageType.Data:
raise TestError(
"publishTransaction broadcasted an existing Transaction.")
#No arguments.
try:
rpc.call("transactions", "publishTransaction")
except TestError as e:
if str(e) != "-32602 Invalid params.":
raise TestError(
"publishTransaction didn't error when passed no arguments."
)
#Invalid type.
try:
rpc.call("transactions", "publishTransaction", {
"type": "",
"transaction": data.serialize().hex()
}, False)
raise TestError("")
except TestError as e:
if str(e) != "-3 Invalid Transaction type specified.":
raise TestError(
"publishTransaction didn't error when passed an invalid type."
)
#Data sent with Send as a type.
try:
rpc.call("transactions", "publishTransaction", {
"type": "Send",
"transaction": data.serialize().hex()
}, False)
raise TestError("")
except TestError as e:
if str(
e
) != "-3 Transaction is invalid: parseSend handed the wrong amount of data.":
raise TestError(
"publishTransaction didn't error when passed a non-parsable Send (a Data)."
)
#Invalid Data (signature).
invalidData: Data = Data(bytes(32), sentToKey.get_verifying_key())
invalidData.sign(sentToKey)
sig: bytes = invalidData.signature
newData: bytearray = bytearray(invalidData.data)
newData[-1] = newData[-1] ^ 1
#Reconstruct to rehash.
invalidData = Data(bytes(32), bytes(newData))
invalidData.signature = sig
invalidData.beat(dataFilter)
try:
rpc.call("transactions", "publishTransaction", {
"type": "Data",
"transaction": invalidData.serialize().hex()
}, False)
raise TestError("")
except TestError as e:
if str(
e
) != "-3 Transaction is invalid: Data has an invalid Signature.":
raise TestError(
"publishTransaction didn't error when passed an invalid Transaction."
)
#Spam.
spamData: Data = data
if spamData.proof == 0:
spamData = dataSentWithoutWork
if spamData.proof == 0:
raise Exception("Neither Data is considered as Spam.")
spamData.proof = 0
try:
rpc.call("transactions", "publishTransaction", {
"type": "Data",
"transaction": spamData.serialize().hex()
}, False)
raise TestError("")
except TestError as e:
if str(e) != "2 Transaction didn't beat the spam filter.":
raise TestError(
"publishTransaction didn't error when passed a Transaction which didn't beat its difficulty."
)
#Test publishTransactionWithoutWork requires authorization.
try:
rpc.call(
"transactions", "publishTransactionWithoutWork", {
"type": "Data",
"transaction": dataSentWithoutWork.serialize()[:-4].hex()
}, False)
raise TestError("")
except Exception as e:
if str(e) != "HTTP status isn't 200: 401":
raise TestError(
"Called publishTransactionWithoutWork despite not being authed."
)
Liver(rpc, vectors["blockchain"][:-1], transactions, {
7: publishAndVerify
}).live()
def publishAndVerify() -> None:
if not rpc.call("transactions", "publishTransaction", {
"type": "Claim",
"transaction": claim.serialize().hex()
}, False):
raise TestError(
"Publishing a valid Transaction didn't return true.")
if rpc.meros.live.recv()[1:] != claim.serialize():
raise TestError(
"publishTransaction didn't broadcast the Transaction.")
if not rpc.call("transactions", "publishTransaction", {
"type": "Send",
"transaction": send.serialize().hex()
}, False):
raise TestError(
"Publishing a valid Transaction didn't return true.")
if rpc.meros.live.recv()[1:] != send.serialize():
raise TestError(
"publishTransaction didn't broadcast the Transaction.")
if not rpc.call("transactions", "publishTransaction", {
"type": "Data",
"transaction": data.serialize().hex()
}, False):
raise TestError(
"Publishing a valid Transaction didn't return true.")
if rpc.meros.live.recv()[1:] != data.serialize():
raise TestError(
"publishTransaction didn't broadcast the Transaction.")
#Verify all three were entered properly.
verifyTransaction(rpc, claim)
verifyTransaction(rpc, send)
verifyTransaction(rpc, data)
#Create a new Send/Data and publish them without work.
sendSentWithoutWork: Send = Send([(send.hash, 0)],
[(pubKey, claim.amount)])
sendSentWithoutWork.sign(sentToKey)
sendSentWithoutWork.beat(sendFilter)
dataSentWithoutWork: Data = Data(bytes(32),
sentToKey.get_verifying_key())
dataSentWithoutWork.sign(sentToKey)
dataSentWithoutWork.beat(dataFilter)
if not rpc.call(
"transactions", "publishTransactionWithoutWork", {
"type": "Send",
"transaction": sendSentWithoutWork.serialize()[:-4].hex()
}, True):
raise TestError(
"Publishing a valid Transaction without work didn't return true."
)
if rpc.meros.live.recv()[1:] != sendSentWithoutWork.serialize():
raise TestError(
"publishTransaction didn't broadcast the Transaction.")
if not rpc.call(
"transactions", "publishTransactionWithoutWork", {
"type": "Data",
"transaction": dataSentWithoutWork.serialize()[:-4].hex()
}, True):
raise TestError(
"Publishing a valid Transaction without work didn't return true."
)
if rpc.meros.live.recv()[1:] != dataSentWithoutWork.serialize():
raise TestError(
"publishTransaction didn't broadcast the Transaction.")
#Call verify now, which will test ours with work against Meros's with generated work.
#Both should terminate on the earliest valid proof, making them identical.
verifyTransaction(rpc, sendSentWithoutWork)
verifyTransaction(rpc, dataSentWithoutWork)
#Re-publishing a Transaction should still return true.
if not rpc.call("transactions", "publishTransaction", {
"type": "Data",
"transaction": data.serialize().hex()
}, False):
raise TestError(
"Publishing an existing Transaction didn't return true.")
if MessageType(rpc.meros.live.recv()[0]) == MessageType.Data:
raise TestError(
"publishTransaction broadcasted an existing Transaction.")
#No arguments.
try:
rpc.call("transactions", "publishTransaction")
except TestError as e:
if str(e) != "-32602 Invalid params.":
raise TestError(
"publishTransaction didn't error when passed no arguments."
)
#Invalid type.
try:
rpc.call("transactions", "publishTransaction", {
"type": "",
"transaction": data.serialize().hex()
}, False)
raise TestError("")
except TestError as e:
if str(e) != "-3 Invalid Transaction type specified.":
raise TestError(
"publishTransaction didn't error when passed an invalid type."
)
#Data sent with Send as a type.
try:
rpc.call("transactions", "publishTransaction", {
"type": "Send",
"transaction": data.serialize().hex()
}, False)
raise TestError("")
except TestError as e:
if str(
e
) != "-3 Transaction is invalid: parseSend handed the wrong amount of data.":
raise TestError(
"publishTransaction didn't error when passed a non-parsable Send (a Data)."
)
#Invalid Data (signature).
invalidData: Data = Data(bytes(32), sentToKey.get_verifying_key())
invalidData.sign(sentToKey)
sig: bytes = invalidData.signature
newData: bytearray = bytearray(invalidData.data)
newData[-1] = newData[-1] ^ 1
#Reconstruct to rehash.
invalidData = Data(bytes(32), bytes(newData))
invalidData.signature = sig
invalidData.beat(dataFilter)
try:
rpc.call("transactions", "publishTransaction", {
"type": "Data",
"transaction": invalidData.serialize().hex()
}, False)
raise TestError("")
except TestError as e:
if str(
e
) != "-3 Transaction is invalid: Data has an invalid Signature.":
raise TestError(
"publishTransaction didn't error when passed an invalid Transaction."
)
#Spam.
spamData: Data = data
if spamData.proof == 0:
spamData = dataSentWithoutWork
if spamData.proof == 0:
raise Exception("Neither Data is considered as Spam.")
spamData.proof = 0
try:
rpc.call("transactions", "publishTransaction", {
"type": "Data",
"transaction": spamData.serialize().hex()
}, False)
raise TestError("")
except TestError as e:
if str(e) != "2 Transaction didn't beat the spam filter.":
raise TestError(
"publishTransaction didn't error when passed a Transaction which didn't beat its difficulty."
)
#Test publishTransactionWithoutWork requires authorization.
try:
rpc.call(
"transactions", "publishTransactionWithoutWork", {
"type": "Data",
"transaction": dataSentWithoutWork.serialize()[:-4].hex()
}, False)
raise TestError("")
except Exception as e:
if str(e) != "HTTP status isn't 200: 401":
raise TestError(
"Called publishTransactionWithoutWork despite not being authed."
)
txs: List[Transaction] = []
#Create the Claim.
claim: Claim = Claim([(merit.mints[-1], 0)], edPubKey)
claim.sign(PrivateKey(0))
txs.append(claim)
transactions.add(claim)
#Create a Verification for this Claim.
verif: SignedVerification = SignedVerification(claim.hash)
verif.sign(0, PrivateKey(0))
#Create two Sends, so the missing packets exceeds the capacity.
#This and the above Verification are used to actually test #175.
for s in range(2):
send: Send = Send([(txs[-1].hash, 0)],
[(edPubKey, merit.mints[-1].outputs[0][1])])
send.sign(edPrivKey)
send.beat(spamFilter)
txs.append(send)
transactions.add(send)
#Manually add the next Block.
#This wouldn't be needed if we could convert the Merit to a PrototypeChain.
#That said, this is easier than writing that algorithm.
#This remains true despite multiple generators needing this.
merit.blockchain.add(
PrototypeBlock(merit.blockchain.blocks[-1].header.time + 1200,
[VerificationPacket(tx.hash, [0])
for tx in txs]).finish(0, merit))
with open("e2e/Vectors/Merit/HundredSeventyFive.json", "w") as vectors:
def BeatenTest(rpc: RPC) -> None:
vectors: Dict[str, Any]
with open("e2e/Vectors/Consensus/Beaten.json", "r") as file:
vectors = json.loads(file.read())
sends: List[Send] = [Send.fromJSON(send) for send in vectors["sends"]]
verif: SignedVerification = SignedVerification.fromSignedJSON(
vectors["verification"])
#Used to get the Block Template.
blsPubKey: str = PrivateKey(0).toPublicKey().serialize().hex()
def sendSends() -> None:
for send in sends[:4]:
if rpc.meros.liveTransaction(send) != rpc.meros.live.recv():
raise TestError("Meros didn't broadcast a Send.")
if rpc.meros.signedElement(verif) != rpc.meros.live.recv():
raise TestError("Meros didn't broadcast a Verification.")
#Sanity check to verify the Block Template contains the Verification.
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 verifyBeaten() -> None:
#Verify beaten was set. The fourth Transaction is also beaten, yet should be pruned.
#That's why we don't check its status.
for send in sends[1:3]:
if not rpc.call("consensus", "getStatus",
{"hash": send.hash.hex()})["beaten"]:
raise TestError(
"Meros didn't mark a child and its descendant as beaten.")
#Check the pending Verification for the beaten descendant was deleted.
if ((rpc.call("consensus", "getStatus",
{"hash": sends[2].hash.hex()})["verifiers"] != [0])
or (bytes.fromhex(
rpc.call("merit", "getBlockTemplate",
{"miner": blsPubKey})["header"])[36:68] !=
bytes(32))):
raise TestError("Block template still has the Verification.")
#Verify the fourth Transaction was pruned.
with raises(TestError):
rpc.call("transactions", "getTransaction",
{"hash": sends[3].hash.hex()})
#Verify neither the second or third Transaction tree can be appended to.
#Publishes a never seen-before Send for the descendant.
#Re-broadcasts the pruned Transaction for the parent.
for send in sends[3:]:
#Most of these tests use a socket connection for this.
#This has identical effects, returns an actual error instead of a disconnect,
#and doesn't force us to wait a minute for our old socket to be cleared.
with raises(TestError):
rpc.call("transactions", "publishTransaction", {
"type": "Send",
"transaction": send.serialize().hex()
})
#Not loaded above as it can only be loqaded after the chain starts, which is done by the Liver.
#RandomX cache keys and all that.
blockWBeatenVerif: Block = Block.fromJSON(
vectors["blockWithBeatenVerification"])
#The following code used to test behavior which was removed, in order to be more forgiving for nodes a tad behind.
#Verify we can't add that SignedVerification now.
#rpc.meros.signedElement(verif)
#try:
# rpc.meros.live.recv()
# #Hijacks a random Exception type for our purposes.
# raise MessageException("Meros didn't disconnect us after we sent a Verification for a beaten Transaction.")
#except TestError:
# pass
#except MessageException as e:
# raise TestError(e.message)
#sleep(65)
#rpc.meros.liveConnect(blockWBeatenVerif.header.last)
#Verify we can't add a Block containing that Verification.
rpc.meros.liveBlockHeader(blockWBeatenVerif.header)
#BlockBody sync request.
rpc.meros.handleBlockBody(blockWBeatenVerif)
#Sketch hash sync request.
hashReqs: bytes = rpc.meros.sync.recv()[37:]
for h in range(0, len(hashReqs), 8):
for packet in blockWBeatenVerif.body.packets:
if int.from_bytes(hashReqs[h:h + 8],
byteorder="little") == Sketch.hash(
blockWBeatenVerif.header.sketchSalt,
packet):
rpc.meros.packet(packet)
break
try:
rpc.meros.live.recv()
raise MessageException(
"Meros didn't disconnect us after we sent a Block containing a Verification of a beaten Transaction."
)
except TestError:
pass
except MessageException as e:
raise TestError(e.message)
sleep(65)
rpc.meros.liveConnect(blockWBeatenVerif.header.last)
rpc.meros.syncConnect(blockWBeatenVerif.header.last)
Liver(rpc,
vectors["blockchain"],
Transactions.fromJSON(vectors["transactions"]),
callbacks={
42: sendSends,
43: verifyTemplate,
48: verifyBeaten
}).live()
proto.add(1)
merit: Merit = Merit.fromJSON(proto.toJSON())
#Create a Claim.
claim: Claim = Claim([(merit.mints[-1], 0)], edPubKey)
claim.sign(PrivateKey(0))
transactions.add(claim)
merit.add(
PrototypeBlock(merit.blockchain.blocks[-1].header.time + 1200,
packets=[VerificationPacket(claim.hash, list(range(2)))
]).finish(0, merit))
sends: List[Send] = [
#Transaction which will win.
Send([(claim.hash, 0)], [(bytes(32), claim.amount)]),
#Transaction which will be beaten.
Send([(claim.hash, 0)], [(edPubKey, claim.amount // 2),
(edPubKey, claim.amount // 2)])
]
#Children. One which will have a Verification, one which won't.
sends += [
Send([(sends[1].hash, 0)], [(edPubKey, claim.amount // 2)]),
Send([(sends[1].hash, 1)], [(edPubKey, claim.amount // 2)])
]
#Send which spend the remaining descendant of the beaten Transaction.
sends.append(Send([(sends[2].hash, 0)], [(bytes(32), claim.amount // 2)]))
for s in range(len(sends)):
sends[s].sign(edPrivKey)
def test() -> None:
#Send to the first address from outside the Wallet. First address is now funded.
sendHash: bytes = createSend(
rpc, claims[0], decodeAddress(rpc.call("personal", "getAddress")))
#Send to the second address with all of the funds. Second address is now funded.
#Tests send's minimal case (single input, no change).
nextAddr: str = rpc.call("personal", "getAddress")
sends: List[str] = [
rpc.call(
"personal", "send", {
"outputs": [{
"address": nextAddr,
"amount": str(claims[0].amount)
}]
})
]
checkSend(
rpc, sends[-1], {
"inputs": [{
"hash": sendHash.hex().upper(),
"nonce": 0
}],
"outputs": [{
"key": decodeAddress(nextAddr).hex().upper(),
"amount": str(claims[0].amount)
}]
})
verify(rpc, bytes.fromhex(sends[-1]))
#Send to the third address with some of the funds. Third and change addresses are now funded.
#Tests send's capability to create a change output.
mnemonic: str = rpc.call("personal", "getMnemonic")
nextAddr = rpc.call("personal", "getAddress")
sends.append(
rpc.call(
"personal", "send", {
"outputs": [{
"address": nextAddr,
"amount": str(claims[0].amount - 1)
}]
}))
checkSend(
rpc, sends[-1], {
"inputs": [{
"hash": sends[-2],
"nonce": 0
}],
"outputs":
[{
"key": decodeAddress(nextAddr).hex().upper(),
"amount": str(claims[0].amount - 1)
}, {
"key": getChangePublicKey(mnemonic, "", 0).hex().upper(),
"amount": "1"
}]
})
verify(rpc, bytes.fromhex(sends[-1]))
#Send all funds out of Wallet.
#Tests MuSig signing and change UTXO detection.
privKey: ed25519.SigningKey = ed25519.SigningKey(b'\0' * 32)
pubKey: bytes = privKey.get_verifying_key().to_bytes()
sends.append(
rpc.call(
"personal", "send", {
"outputs": [{
"address":
bech32_encode("mr",
convertbits(bytes([0]) + pubKey, 8, 5)),
"amount":
str(claims[0].amount)
}]
}))
checkSend(
rpc, sends[-1], {
"inputs": [{
"hash": sends[-2],
"nonce": 0
}, {
"hash": sends[-2],
"nonce": 1
}],
"outputs": [{
"key": pubKey.hex().upper(),
"amount": str(claims[0].amount)
}]
})
verify(rpc, bytes.fromhex(sends[-1]))
#Clear Wallet. Set a password this time around to make sure the password is properly carried.
#Send two instances of funds to the first address.
rpc.call("personal", "setWallet", {"password": "******"})
mnemonic = rpc.call("personal", "getMnemonic")
nodeKey: bytes = decodeAddress(rpc.call("personal", "getAddress"))
send: Send = Send([(bytes.fromhex(sends[-1]), 0)],
[(nodeKey, claims[0].amount // 2),
(nodeKey, claims[0].amount // 2)])
send.sign(ed25519.SigningKey(b'\0' * 32))
send.beat(SpamFilter(3))
if rpc.meros.liveTransaction(send) != rpc.meros.live.recv():
raise TestError("Meros didn't send back a Send.")
verify(rpc, send.hash)
sends = [send.hash.hex().upper()]
#Send to self.
#Tests send's capability to handle multiple UTXOs per key/lack of aggregation when all keys are the same/multiple output Sends.
nextAddr = rpc.call("personal", "getAddress")
changeKey: bytes = getChangePublicKey(mnemonic, "test", 0)
sends.append(
rpc.call(
"personal", "send", {
"outputs": [{
"address": nextAddr,
"amount": str(claims[0].amount - 1)
}],
"password":
"******"
}))
checkSend(
rpc, sends[-1], {
"inputs": [{
"hash": sends[-2],
"nonce": 0
}, {
"hash": sends[-2],
"nonce": 1
}],
"outputs": [{
"key": decodeAddress(nextAddr).hex().upper(),
"amount": str(claims[0].amount - 1)
}, {
"key": changeKey.hex().upper(),
"amount": "1"
}]
})
verify(rpc, bytes.fromhex(sends[-1]))
#Externally send to the second/change address.
#Enables entering multiple instances of each key into MuSig, which is significant as we originally only used the unique keys.
sends.append(
createSend(rpc, claims[1], decodeAddress(nextAddr)).hex().upper())
sends.append(createSend(rpc, claims[2], changeKey).hex().upper())
#Check personal_getUTXOs.
utxos: List[Dict[str, Any]] = [{
"hash": sends[-3],
"nonce": 0,
"address": nextAddr
}, {
"hash":
sends[-3],
"nonce":
1,
"address":
bech32_encode("mr", convertbits(bytes([0]) + changeKey, 8, 5))
}, {
"hash": sends[-2],
"nonce": 0,
"address": nextAddr
}, {
"hash":
sends[-1],
"nonce":
0,
"address":
bech32_encode("mr", convertbits(bytes([0]) + changeKey, 8, 5))
}]
if sortUTXOs(rpc.call("personal", "getUTXOs")) != sortUTXOs(utxos):
raise TestError("personal_getUTXOs was incorrect.")
for utxo in utxos:
del utxo["address"]
#Send to any address with all funds minus one.
#Test MuSig signing, multiple inputs per key on account chains, change output creation to the next change key...
sends.append(
rpc.call(
"personal", "send", {
"outputs": [{
"address":
nextAddr,
"amount":
str(claims[0].amount + claims[1].amount +
claims[2].amount - 1)
}],
"password":
"******"
}))
checkSend(
rpc, sends[-1], {
"inputs":
utxos,
"outputs": [{
"key":
decodeAddress(nextAddr).hex().upper(),
"amount":
str(claims[0].amount + claims[1].amount +
claims[2].amount - 1)
}, {
"key":
getChangePublicKey(mnemonic, "test", 1).hex().upper(),
"amount":
"1"
}]
})
verify(rpc, bytes.fromhex(sends[-1]))
#Mine a Block so we can reboot the node without losing data.
blsPrivKey: PrivateKey = PrivateKey(
bytes.fromhex(rpc.call("personal", "getMeritHolderKey")))
for _ in range(6):
template: Dict[str, Any] = rpc.call(
"merit", "getBlockTemplate",
{"miner": blsPrivKey.toPublicKey().serialize().hex()})
proof: int = -1
tempHash: bytes = bytes()
tempSignature: bytes = bytes()
while ((proof == -1) or (
(int.from_bytes(tempHash, "little") * template["difficulty"]) >
int.from_bytes(bytes.fromhex("FF" * 32), "little"))):
proof += 1
tempHash = RandomX(
bytes.fromhex(template["header"]) +
proof.to_bytes(4, "little"))
tempSignature = blsPrivKey.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()
})
#Reboot the node and verify it still tracks the same change address.
#Also reload the Wallet and verify it still tracks the same change address.
#Really should be part of address discovery; we just have the opportunity right here.
#Due to the timing of how the codebase was developed, and a personal frustration for how long this has taken...
rpc.quit()
sleep(3)
rpc.meros = Meros(rpc.meros.db, rpc.meros.tcp, rpc.meros.rpc)
if rpc.call("personal", "getTransactionTemplate",
{"outputs": [{
"address": nextAddr,
"amount": "1"
}]})["outputs"][1]["key"] != getChangePublicKey(
mnemonic, "test", 2).hex().upper():
raise TestError(
"Rebooting the node caused the WalletDB to stop tracking the next change address."
)
rpc.call("personal", "setAccount", rpc.call("personal", "getAccount"))
if rpc.call("personal", "getTransactionTemplate",
{"outputs": [{
"address": nextAddr,
"amount": "1"
}]})["outputs"][1]["key"] != getChangePublicKey(
mnemonic, "test", 2).hex().upper():
raise TestError(
"Reloading the Wallet caused the WalletDB to stop tracking the next change address."
)
raise SuccessError()
def restOfTest() -> None:
#Move expected into scope.
expected: str = getAddress(mnemonic, password, 0)
#Send to the new address, then call getAddress again. Verify a new address appears.
last: Send = createSend(
rpc,
Claim.fromTransaction(iter(transactions.txs.values()).__next__()),
expected)
hashes: List[bytes] = [last.hash]
expected = getAddress(mnemonic, password, 1)
if rpc.call("personal", "getAddress") != expected:
raise TestError(
"Meros didn't move to the next address once the existing one was used."
)
#Send to the new unused address, spending the funds before calling getAddress again.
#Checks address usage isn't defined as having an UTXO, yet rather any TXO.
#Also confirm the spending TX with full finalization before checking.
#Ensures the TXO isn't unspent by any definition.
last = createSend(rpc, last, expected)
hashes.append(last.hash)
#Spending TX.
send: Send = Send([(hashes[-1], 0)], [(bytes(32), 1)])
send.signature = ed.sign(b"MEROS" + send.hash,
getPrivateKey(mnemonic, password, 1))
send.beat(SpamFilter(3))
if rpc.meros.liveTransaction(send) != rpc.meros.live.recv():
raise TestError("Meros didn't broadcast back the spending Send.")
hashes.append(send.hash)
#In order to finalize, we need to mine 6 Blocks once this Transaction and its parent have Verifications.
for txHash in hashes:
sv: SignedVerification = SignedVerification(txHash)
sv.sign(0, PrivateKey(0))
if rpc.meros.signedElement(sv) != rpc.meros.live.recv():
raise TestError("Meros didn't broadcast back a Verification.")
#Close the sockets while we mine.
rpc.meros.live.connection.close()
rpc.meros.sync.connection.close()
#Mine these to the Wallet on the node so we can test getMeritHolderNick.
privKey: PrivateKey = PrivateKey(
bytes.fromhex(rpc.call("personal", "getMeritHolderKey")))
blockchain: Blockchain = Blockchain.fromJSON(vectors["blockchain"])
for _ in range(6):
template: Dict[str, Any] = rpc.call(
"merit", "getBlockTemplate",
{"miner": privKey.toPublicKey().serialize().hex()})
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 = privKey.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()
})
blockchain.add(
Block.fromJSON(
rpc.call("merit", "getBlock",
{"block": len(blockchain.blocks)})))
#Verify a new address is returned.
expected = getAddress(mnemonic, password, 2)
if rpc.call("personal", "getAddress") != expected:
raise TestError(
"Meros didn't move to the next address once the existing one was used."
)
#Get a new address after sending to the address after it.
#Use both, and then call getAddress.
#getAddress should detect X is used, move to Y, detect Y is used, and move to Z.
#It shouldn't assume the next address after an used address is unused.
#Actually has two Ys as one iteration of the code only ran for the next address; not all future addresses.
#Send to the next next addresses.
for i in range(2):
addy: str = getAddress(mnemonic, password, 3 + i)
#Reopen the sockets. This isn't done outside of the loop due to the time deriving the final address can take.
#Due to how slow the reference Python code is, it is necessary to redo the socket connections.
sleep(65)
rpc.meros.liveConnect(Blockchain().blocks[0].header.hash)
rpc.meros.syncConnect(Blockchain().blocks[0].header.hash)
last = createSend(rpc, last, addy)
if MessageType(rpc.meros.live.recv()
[0]) != MessageType.SignedVerification:
raise TestError(
"Meros didn't create and broadcast a SignedVerification for this Send."
)
if i == 0:
#Close them again.
rpc.meros.live.connection.close()
rpc.meros.sync.connection.close()
#Verify getAddress returns the existing next address.
if rpc.call("personal", "getAddress") != expected:
raise TestError(
"Sending to the address after this address caused Meros to consider this address used."
)
#Send to the next address.
last = createSend(rpc, last, expected)
if MessageType(
rpc.meros.live.recv()[0]) != MessageType.SignedVerification:
raise TestError(
"Meros didn't create and broadcast a SignedVerification for this Send."
)
#Verify getAddress returns the address after the next next addresses.
expected = getAddress(mnemonic, password, 5)
if rpc.call("personal", "getAddress") != expected:
raise TestError(
"Meros didn't return the correct next address after using multiple addresses in a row."
)
#Now that we have mined a Block as part of this test, ensure the Merit Holder nick is set.
if rpc.call("personal", "getMeritHolderNick") != 1:
raise TestError(
"Merit Holder nick wasn't made available despite having one.")
#Sanity check off Mnemonic.
if rpc.call("personal", "getMnemonic") != mnemonic:
raise TestError("getMnemonic didn't return the correct Mnemonic.")
#Existing values used to test getMnemonic/getMeritHolderKey/getMeritHolderNick/getAccount/getAddress consistency.
existing: Dict[str, Any] = {
#Should be equal to the mnemonic variable, which is verified in a check above.
"getMnemonic": rpc.call("personal", "getMnemonic"),
"getMeritHolderKey": rpc.call("personal", "getMeritHolderKey"),
"getMeritHolderNick": rpc.call("personal", "getMeritHolderNick"),
"getAccount": rpc.call("personal", "getAccount"),
#Should be equal to expected, which is also verified in a check above.
"getAddress": rpc.call("personal", "getAddress")
}
#Set a new seed and verify the Merit Holder nick is cleared.
rpc.call("personal", "setWallet")
try:
rpc.call("personal", "getMeritHolderNick")
raise TestError("")
except TestError as e:
if str(
e
) != "-2 Wallet doesn't have a Merit Holder nickname assigned.":
raise TestError(
"getMeritHolderNick returned something or an unexpected error when a new Mnemonic was set."
)
#Set back the old seed and verify consistency.
rpc.call("personal", "setWallet", {
"mnemonic": mnemonic,
"password": password
})
for method in existing:
if rpc.call("personal", method) != existing[method]:
raise TestError(
"Setting an old seed caused the WalletDB to improperly reload."
)
#Verify calling getAddress returns the expected address.
if rpc.call("personal", "getAddress") != expected:
raise TestError(
"Meros returned an address that wasn't next after reloading the seed."
)
#Reboot the node and verify consistency.
rpc.quit()
sleep(3)
rpc.meros = Meros(rpc.meros.db, rpc.meros.tcp, rpc.meros.rpc)
for method in existing:
if rpc.call("personal", method) != existing[method]:
raise TestError(
"Rebooting the node caused the WalletDB to improperly reload."
)
#Used so Liver doesn't run its own post-test checks.
#Since we added our own Blocks, those will fail.
raise SuccessError()
def test() -> None:
recipient: ed25519.SigningKey = ed25519.SigningKey(b'\1' * 32)
recipientPub: bytes = recipient.get_verifying_key().to_bytes()
address: str = bech32_encode(
"mr", convertbits(bytes([0]) + recipientPub, 8, 5))
otherRecipient: bytes = ed25519.SigningKey(
b'\2' * 32).get_verifying_key().to_bytes()
otherAddress: str = bech32_encode(
"mr", convertbits(bytes([0]) + otherRecipient, 8, 5))
#Create a Send.
send: Send = Send.fromJSON(vectors["send"])
if rpc.meros.liveTransaction(send) != rpc.meros.live.recv():
raise TestError("Meros didn't broadcast back a Send.")
if rpc.call("transactions", "getUTXOs", {"address": address}) != []:
raise TestError(
"Meros considered an unconfirmed Transaction's outputs as UTXOs."
)
verify(rpc, send.hash)
#Finalize the parent.
for _ in range(6):
mineBlock(rpc)
#Spend it.
spendingSend: Send = Send.fromJSON(vectors["spendingSend"])
if rpc.meros.liveTransaction(spendingSend) != rpc.meros.live.recv():
raise TestError("Meros didn't broadcast back a Send.")
verify(rpc, spendingSend.hash)
if rpc.call("transactions", "getUTXOs", {"address": address}) != []:
raise TestError(
"Meros didn't consider a verified Transaction's inputs as spent."
)
if rpc.call("transactions", "getUTXOs", {"address": otherAddress}) != [
{
"hash": spendingSend.hash.hex().upper(),
"nonce": 0
}
]:
raise TestError(
"Meros didn't consider a verified Transaction's outputs as UTXOs."
)
#Unverify the spending Send. This would also unverify the parent if it wasn't finalized.
#This is done via causing a Merit Removal.
#Uses two competing Datas to not change the Send's status to competing.
datas: List[Data] = [Data(bytes(32), recipientPub)]
for _ in range(2):
datas.append(Data(datas[0].hash, datas[-1].hash))
for data in datas:
data.sign(recipient)
data.beat(SpamFilter(5))
if rpc.meros.liveTransaction(data) != rpc.meros.live.recv():
raise TestError("Meros didn't broadcast back a Data.")
verify(rpc, data.hash, mr=(datas[-1].hash == data.hash))
#Verify the MeritRemoval happened and the spending Send is no longer verified.
#These first two checks are more likely to symbolize a failure in testing methodology than Meros.
if not rpc.call("merit", "getMerit", {"nick": 0})["malicious"]:
raise TestError("Meros didn't create a Merit Removal.")
if not rpc.call("consensus", "getStatus",
{"hash": send.hash.hex()})["verified"]:
raise TestError("Finalized Transaction became unverified.")
if rpc.call("consensus", "getStatus",
{"hash": spendingSend.hash.hex()})["verified"]:
raise TestError(
"Meros didn't unverify a Transaction which is currently below the required threshold."
)
#Even after unverification, since the Transaction still exists, the input shouldn't be considered a UTXO.
if rpc.call("transactions", "getUTXOs", {"address": address}) != []:
raise TestError(
"Meros didn't consider a unverified yet existing Transaction's inputs as spent."
)
#That said, its outputs should no longer be considered a UTXO.
if rpc.call("transactions", "getUTXOs",
{"address": otherAddress}) != []:
raise TestError(
"Meros considered a unverified Transaction's outputs as UTXOs."
)
raise SuccessError()
def GetTransactionTest(rpc: RPC) -> None:
privKey: Ristretto.SigningKey = Ristretto.SigningKey(b'\0' * 32)
pubKey: bytes = privKey.get_verifying_key()
sendFilter: SpamFilter = SpamFilter(3)
dataFilter: SpamFilter = SpamFilter(5)
vectors: Dict[str, Any]
with open("e2e/Vectors/Transactions/ClaimedMint.json", "r") as file:
vectors = json.loads(file.read())
transactions: Transactions = Transactions.fromJSON(vectors["transactions"])
if len(transactions.txs) != 1:
raise Exception("Transactions DAG doesn't have just the Claim.")
claim: Claim = Claim.fromTransaction(next(iter(transactions.txs.values())))
send: Send = Send(
[(claim.hash, 0)],
[(Ristretto.SigningKey(b'\1' * 32).get_verifying_key(), claim.amount)])
send.sign(privKey)
send.beat(sendFilter)
data: Data = Data(bytes(32), pubKey)
data.sign(privKey)
data.beat(dataFilter)
def sendAndVerify() -> None:
rpc.meros.liveTransaction(send)
rpc.meros.liveTransaction(data)
rpc.meros.live.recv()
rpc.meros.live.recv()
#We now have a Mint, a Claim, a Send, a Data, a lion, a witch, and a wardrobe.
#Check the Mint.
mint: Mint = Merit.fromJSON(vectors["blockchain"]).mints[0]
#pylint: disable=invalid-name
EXPECTED_MINT: Dict[str, Any] = {
"descendant":
"Mint",
"inputs": [],
"outputs": [{
"amount": str(txOutput[1]),
"nick": txOutput[0]
} for txOutput in mint.outputs],
"hash":
mint.hash.hex().upper()
}
#Also sanity check against the in-house JSON.
if mint.toJSON() != EXPECTED_MINT:
raise TestError("Python's Mint toJSON doesn't match the spec.")
if rpc.call("transactions", "getTransaction",
{"hash": mint.hash.hex()}, False) != EXPECTED_MINT:
raise TestError("getTransaction didn't report the Mint properly.")
#Check the Claim.
#pylint: disable=invalid-name
EXPECTED_CLAIM: Dict[str, Any] = {
"descendant":
"Claim",
"inputs": [{
"hash": txInput[0].hex().upper(),
"nonce": txInput[1]
} for txInput in claim.inputs],
"outputs": [{
"amount": str(claim.amount),
"key": claim.output.hex().upper()
}],
"hash":
claim.hash.hex().upper(),
"signature":
claim.signature.hex().upper()
}
if claim.amount == 0:
raise Exception(
"Python didn't instantiate the Claim with an amount, leading to invalid testing methodology."
)
if claim.toJSON() != EXPECTED_CLAIM:
raise TestError("Python's Claim toJSON doesn't match the spec.")
if rpc.call("transactions", "getTransaction",
{"hash": claim.hash.hex()}, False) != EXPECTED_CLAIM:
raise TestError("getTransaction didn't report the Claim properly.")
#Check the Send.
#pylint: disable=invalid-name
EXPECTED_SEND: Dict[str, Any] = {
"descendant":
"Send",
"inputs": [{
"hash": txInput[0].hex().upper(),
"nonce": txInput[1]
} for txInput in send.inputs],
"outputs": [{
"amount": str(txOutput[1]),
"key": txOutput[0].hex().upper()
} for txOutput in send.outputs],
"hash":
send.hash.hex().upper(),
"signature":
send.signature.hex().upper(),
"proof":
send.proof
}
if send.toJSON() != EXPECTED_SEND:
raise TestError("Python's Send toJSON doesn't match the spec.")
if rpc.call("transactions", "getTransaction",
{"hash": send.hash.hex()}, False) != EXPECTED_SEND:
raise TestError("getTransaction didn't report the Send properly.")
#Check the Data.
#pylint: disable=invalid-name
EXPECTED_DATA: Dict[str, Any] = {
"descendant": "Data",
"inputs": [{
"hash": data.txInput.hex().upper()
}],
"outputs": [],
"hash": data.hash.hex().upper(),
"data": data.data.hex().upper(),
"signature": data.signature.hex().upper(),
"proof": data.proof
}
if data.toJSON() != EXPECTED_DATA:
raise TestError("Python's Data toJSON doesn't match the spec.")
if rpc.call("transactions", "getTransaction",
{"hash": data.hash.hex()}, False) != EXPECTED_DATA:
raise TestError("getTransaction didn't report the Data properly.")
#Non-existent hash; should cause an IndexError
nonExistentHash: str = data.hash.hex()
if data.hash[0] == "0":
nonExistentHash = "1" + nonExistentHash[1:]
else:
nonExistentHash = "0" + nonExistentHash[1:]
try:
rpc.call("transactions", "getTransaction",
{"hash": nonExistentHash}, False)
except TestError as e:
if str(e) != "-2 Transaction not found.":
raise TestError(
"getTransaction didn't raise IndexError on a non-existent hash."
)
#Invalid argument; should cause a ParamError
#This is still a hex value
try:
rpc.call("transactions", "getTransaction",
{"hash": "00" + data.hash.hex()}, False)
raise TestError(
"Meros didn't error when we asked for a 33-byte hex value.")
except TestError as e:
if str(e) != "-32602 Invalid params.":
raise TestError(
"getTransaction didn't raise on invalid parameters.")
Liver(rpc, vectors["blockchain"], transactions, {8: sendAndVerify}).live()
newerClaim: Claim = Claim([(merit.mints[-1], 0)], pubKey)
newerClaim.sign(PrivateKey(0))
transactions.add(newerClaim)
merit.add(
PrototypeBlock(
merit.blockchain.blocks[-1].header.time + 1200,
packets=[VerificationPacket(newerClaim.hash, [0])]
).finish(0, merit)
)
coreMerit: List[Dict[str, Any]] = merit.toJSON()
send: Send = Send(
[(olderClaim.hash, 0)],
[(recipientPub, 1), (pubKey, olderClaim.amount - 1)]
)
send.sign(privKey)
send.beat(SpamFilter(3))
transactions.add(send)
otherRecipient: bytes = Ristretto.SigningKey(b'\2' * 32).get_verifying_key()
spendingSend: Send = Send([(send.hash, 0)], [(otherRecipient, 1)])
spendingSend.sign(recipientPriv)
spendingSend.beat(SpamFilter(3))
transactions.add(spendingSend)
#Used by the basic and immediately spent tests.
#Staggered finalization.
merit.add(
def GetBlockTest(rpc: RPC) -> None:
blockchain: Blockchain
claim: Claim
send: Send
datas: List[Data]
txKey: Callable[[Dict[str, Any]], str] = lambda tx: tx["hash"]
def verify() -> None:
for b in range(len(blockchain.blocks)):
block: Dict[str, Any] = rpc.call(
"merit", "getBlock",
{"block": blockchain.blocks[b].header.hash.hex().upper()},
False)
if rpc.call("merit", "getBlock", {"block": b}, False) != block:
raise TestError(
"Meros reported different Blocks depending on if nonce/hash indexing."
)
#Python doesn't keep track of the removals.
#That said, they should all be empty except for the last one.
if b != (len(blockchain.blocks) - 1):
if block["removals"] != []:
raise TestError("Meros reported the Block had removals.")
del block["removals"]
if blockchain.blocks[b].toJSON() != block:
raise TestError(
"Meros's JSON serialization of Blocks differs from Python's."
)
#Test the key serialization of the first Block.
#The final Block uses a nick, hence the value in this.
if rpc.call("merit", "getBlock", {"block": 1},
False)["header"]["miner"] != PrivateKey(
0).toPublicKey().serialize().hex().upper():
raise TestError("Meros didn't serialize a miner's key properly.")
#Manually test the final, and most complex, block.
final: Dict[str, Any] = rpc.call("merit", "getBlock",
{"block": len(blockchain.blocks) - 1},
False)
final["transactions"].sort(key=txKey)
final["removals"].sort()
if final != {
"hash":
blockchain.blocks[-1].header.hash.hex().upper(),
"header": {
"version":
blockchain.blocks[-1].header.version,
"last":
blockchain.blocks[-1].header.last.hex().upper(),
"contents":
blockchain.blocks[-1].header.contents.hex().upper(),
"packets":
blockchain.blocks[-1].header.packetsQuantity,
"sketchSalt":
blockchain.blocks[-1].header.sketchSalt.hex().upper(),
"sketchCheck":
blockchain.blocks[-1].header.sketchCheck.hex().upper(),
"miner":
blockchain.blocks[-1].header.minerKey.hex().upper()
if blockchain.blocks[-1].header.newMiner else
blockchain.blocks[-1].header.minerNick,
"time":
blockchain.blocks[-1].header.time,
"proof":
blockchain.blocks[-1].header.proof,
"signature":
blockchain.blocks[-1].header.signature.hex().upper()
},
"transactions":
sorted([{
"hash": claim.hash.hex().upper(),
"holders": [0]
}, {
"hash": send.hash.hex().upper(),
"holders": [0, 1, 2]
}, {
"hash": datas[0].hash.hex().upper(),
"holders": [0, 2]
}, {
"hash": datas[1].hash.hex().upper(),
"holders": [0, 1, 3]
}, {
"hash": datas[2].hash.hex().upper(),
"holders": [0, 1, 2, 3, 4]
}, {
"hash": datas[3].hash.hex().upper(),
"holders": [0, 1, 2, 3]
}],
key=txKey),
"elements": [
{
"descendant": "DataDifficulty",
"holder": 3,
"nonce": 0,
"difficulty": 8
},
{
"descendant": "SendDifficulty",
"holder": 0,
"nonce": 0,
"difficulty": 1
},
{
"descendant": "DataDifficulty",
"holder": 3,
"nonce": 0,
"difficulty": 4
},
{
"descendant": "DataDifficulty",
"holder": 4,
"nonce": 2,
"difficulty": 1
},
{
"descendant": "SendDifficulty",
"holder": 4,
"nonce": 1,
"difficulty": 3
},
{
"descendant": "SendDifficulty",
"holder": 2,
"nonce": 1,
"difficulty": 2
},
{
"descendant": "DataDifficulty",
"holder": 0,
"nonce": 0,
"difficulty": 7
},
],
"removals": [0, 3],
"aggregate":
blockchain.blocks[-1].body.aggregate.serialize().hex().upper()
}:
raise TestError("Final Block wasn't correct.")
#Test invalid calls.
try:
rpc.call("merit", "getBlock", {"block": 100}, False)
raise Exception("")
except Exception as e:
if str(e) != "-2 Block not found.":
raise TestError(
"getBlock didn't error when we used a non-existent nonce.")
try:
rpc.call("merit", "getBlock", {"block": -5}, False)
raise Exception("")
except Exception as e:
if str(e) != "-32602 Invalid params.":
raise TestError(
"getBlock didn't error when we used a negative (signed) integer for a nonce."
)
try:
rpc.call(
"merit", "getBlock", {
"block":
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
}, False)
raise Exception("")
except Exception as e:
if str(e) != "-2 Block not found.":
raise TestError(
"getBlock didn't error when we used a non-existent hash.")
try:
rpc.call("merit", "getBlock", {"block": ""}, False)
raise Exception("")
except Exception as e:
if str(e) != "-32602 Invalid params.":
raise TestError(
"getBlock didn't error when we used an invalid hash.")
with open("e2e/Vectors/RPC/Merit/GetBlock.json", "r") as file:
vectors: Dict[str, Any] = json.loads(file.read())
blockchain = Blockchain.fromJSON(vectors["blockchain"])
claim = Claim.fromJSON(vectors["claim"])
send = Send.fromJSON(vectors["send"])
datas = [Data.fromJSON(data) for data in vectors["datas"]]
transactions: Transactions = Transactions.fromJSON(
vectors["transactions"])
Liver(rpc, vectors["blockchain"], transactions, {
(len(blockchain.blocks) - 1): verify
}).live()