def validate_metadata(self):
"""
Checks the fields in the metadata, namely proof and signature.
:raises: An exception if either the proof or signature are not valid hexadecimal of the appropriate length
"""
validate_hex(self.proof, 32, 'proof')
validate_hex(self.signature, 128, 'signature')
def validate(self):
assert type(self._data) == dict, "_data is not a dictionary"
assert self.SIG in self._data, "Signature field missing from _data: {}".format(self._data)
assert self.TS in self._data, "Timestamp field missing from _data: {}".format(self._data)
assert self.SENDER in self._data, "Sender field missing from _data: {}".format(self._data)
validate_hex(self._data[self.SIG], 128, self.SIG)
validate_hex(self._data[self.SENDER], 64, self.SENDER)
def create_currency_tx(sender_sk: str, receiver_vk: str, amount: int):
validate_hex(receiver_vk, 64, 'receiver verifying key')
code_str = ContractTemplate.interpolate_template('currency',
amount=amount,
receiver=receiver_vk)
return ContractTransactionBuilder.create_contract_tx(
sender_sk, code_str)
def validate(self):
assert validate_hex(self._data.hash, 64), 'Invalid hash'
assert validate_hex(self._data.prevBlockHash,
64), 'Invalid previous block hash'
assert validate_hex(self._data.merkleRoot, 64), 'Invalid merkle root'
assert len(self._data.merkleLeaves) % 64 == 0, 'Invalid merkle leaves'
assert validate_hex(self._data.masternodeSignature,
128), 'Invalid masternode signature'
assert validate_hex(self._data.masternodeVk,
64), 'Invalid masternode vk'
assert type(self._data.timestamp) == int, 'Invalid timestamp'
self.validate_block_data()
def validate_payload(self):
if self.amount <= 0:
raise Exception("Amount must be greater than 0 (amount={})".format(
self.amount))
if len(self.hashlock) != 64:
raise Exception(
"Hashlock incorrect length. Must be 64 bytes (length={})".
format(len(self.hashlock)))
if self.expiration < int(time.time()):
raise Exception("Expiration date is before now.")
validate_hex(self.receiver, length=64, field_name='Receiver')
validate_hex(self.sender, length=64, field_name='Sender')
def create_contract_tx(sender_sk: str, code_str: str):
validate_hex(sender_sk, 64, 'sender signing key')
struct = transaction_capnp.ContractTransaction.new_message()
struct.payload.sender = wallet.get_vk(sender_sk)
struct.payload.code = code_str
payload_binary = struct.payload.copy().to_bytes()
struct.metadata.proof = SHA3POW.find(payload_binary)[0]
struct.metadata.signature = wallet.sign(sender_sk, payload_binary)
return ContractTransaction.from_data(struct)
def verify(self, msg):
verifying_key = self.sender
if validate_hex(verifying_key, length=64, raise_err=False):
return wallet.verify(verifying_key, msg, self.signature)
else:
return False
def verify(self, msg):
verifying_key = self.sender
if validate_hex(verifying_key, length=64, raise_err=False):
return Constants.Protocol.Wallets.verify(verifying_key, msg,
self.signature)
else:
return False
def validate(self):
for hash in self._data.transactions:
validate_hex(hash, 64)
return True
def validate_payload(self):
validate_hex(self.sender, 64, 'sender')
def validate(self):
validate_hex(self.current_block_hash,
length=64,
field_name="Current Block Hash")
def validate_payload(self):
validate_hex(self.sender, 64, 'sender')
validate_hex(self.receiver, 64, 'receiver')
if self.amount <= 0:
raise Exception("Amount must be greater than 0 (amount={})".format(self.amount))
def validate_payload(self):
validate_hex(self.sender, 64, 'sender')
validate_hex(self.policy, None, 'policy')
