def test_xor_bytes(self):
a = b"12345"
b = b"09876"
expected_result = b'\x01\x0b\x0b\x03\x03'
# Should work
result = Helper.xor_bytes(a, b)
self.assertEqual(result, expected_result)
# Should not work on inequal length byte objects
with self.assertRaises(AssertionError) as context:
Helper.xor_bytes(a, b"x")
def Verify(self):
"""
Verify block using the verification script.
Returns:
bool: True if valid. False otherwise.
"""
if not self.Hash.ToBytes() == GetGenesis().Hash.ToBytes():
return False
bc = GetBlockchain()
if not bc.ContainsBlock(self.Index):
return False
if self.Index > 0:
prev_header = GetBlockchain().GetHeader(self.PrevHash.ToBytes())
if prev_header is None:
return False
if prev_header.Index + 1 != self.Index:
return False
if prev_header.Timestamp >= self.Timestamp:
return False
# this should be done to actually verify the block
if not Helper.VerifyScripts(self):
return False
return True
def Sign(self, context, key=None):
"""
Sign the verifiable items ( Transaction, Block, etc ) in the context with the Keypairs in this wallet.
Args:
context (ContractParameterContext): the context to sign.
Returns:
bool: if signing is successful for all contracts in this wallet.
"""
success = False
for hash in context.ScriptHashes:
contract = self.GetContract(hash)
if contract is None:
continue
if key is None:
key = self.GetKeyByScriptHash(hash)
signature = Helper.Sign(context.Verifiable, keypair=key)
res = context.AddSignature(contract, key.PublicKey, signature)
success |= res
return success
def RawData(self):
"""
Get the data used for hashing.
Returns:
bytes:
"""
return Helper.GetHashData(self)
def ToArray(self):
"""
Get the byte data of self.
Returns:
bytes:
"""
return Helper.ToArray(self)
def test_publickey_to_scripthash(self):
expected_scripthash = binascii.unhexlify(
'79ecf967a02f9bdbd147fc97b18efd7877d27f78')
priv_key = KeyPair.PrivateKeyFromWIF(
'L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP')
kp = KeyPair(priv_key=priv_key)
pub_bytes = kp.PublicKey.encode_point(True)
result = Helper.pubkey_to_pubhash(pub_bytes)
self.assertEqual(result, expected_scripthash)
def test_compute_root_multiple_hashes(self):
expected_hash = Helper.bin_dbl_sha256(
binascii.unhexlify(b'aa' * 32 + b'bb' * 32))
hash1 = UInt256(data=binascii.unhexlify(b'aa' * 32))
hash2 = UInt256(data=binascii.unhexlify(b'bb' * 32))
hashes = [hash1, hash2]
root = MerkleTree.ComputeRoot(hashes)
self.assertEqual(expected_hash, root.ToArray())
def test_scripthash_to_address_with_alternative_version(self):
default_address_version = Helper.ADDRESS_VERSION
Helper.ADDRESS_VERSION = 42
scripthash = binascii.unhexlify(
'42112378ffa32c4c65d513aa350689dff6381154')
expected_address = 'J1DfV2jS511SMtP6dH5ckr3Nwf26kbFx7s'
address = Helper.scripthash_to_address(scripthash)
self.assertEqual(address, expected_address)
Helper.ADDRESS_VERSION = default_address_version
def test_publickey_to_redeemscript_to_scripthash_to_address(self):
# NEP 2 testvector
expected_redeemscript = binascii.unhexlify(
'21026241e7e26b38bb7154b8ad49458b97fb1c4797443dc921c5ca5774f511a2bbfcac'
)
expected_scripthash = binascii.unhexlify(
'79ecf967a02f9bdbd147fc97b18efd7877d27f78')
expected_address = 'AStZHy8E6StCqYQbzMqi4poH7YNDHQKxvt'
priv_key = KeyPair.PrivateKeyFromWIF(
'L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP')
kp = KeyPair(priv_key=priv_key)
pub_bytes = kp.PublicKey.encode_point(True)
redeemscript = Helper.pubkey_to_redeem(pub_bytes)
scripthash = Helper.redeem_to_scripthash(redeemscript)
address = Helper.scripthash_to_address(scripthash)
self.assertEqual(redeemscript, expected_redeemscript)
self.assertEqual(scripthash, expected_scripthash)
self.assertEqual(address, expected_address)
def test_base256_padding(self):
result = Helper.base256_encode(1230, minwidth=5)
self.assertEqual(5, len(result))
def test_base256_negative_input(self):
with self.assertRaises(ValueError) as context:
Helper.base256_encode(-1)
self.assertTrue(
"Negative numbers not supported" in str(context.exception))
def test_base256_zero_input(self):
result = Helper.base256_encode(0)
self.assertEqual(bytearray.fromhex('00'), result)
def test_random_key(self):
a = Helper.random_key()
self.assertEqual(len(a), 64)
b = Helper.random_key()
self.assertNotEqual(a, b)
def test_base256_encode(self):
val = 1234567890
res = Helper.base256_encode(val)
self.assertEqual(res, bytearray(b'\xd2\x02\x96I'))
def Hash(self):
if not self._hash:
self._hash = bin_dbl_sha256(Helper.GetHashData(self))
return self._hash
def GetMessage(self):
return Helper.GetHashData(self)
def test_double_sha256(self):
expected_hash = '4f8b42c22dd3729b519ba6f68d2da7cc5b2d606d05daed5ad5128cc03e6c6358' # https://www.dlitz.net/crypto/shad256-test-vectors/
result = Helper.double_sha256(b'abc')
self.assertEqual(result, expected_hash)
