def test_invalid_ss58_format_range_exceptions(self):
with self.assertRaises(ValueError) as cm:
ss58_encode(self.alice_keypair['public_key'], ss58_format=-1)
self.assertEqual('Invalid value for ss58_format', str(cm.exception))
with self.assertRaises(ValueError) as cm:
ss58_encode(self.alice_keypair['public_key'], ss58_format=16384)
self.assertEqual('Invalid value for ss58_format', str(cm.exception))
def test_invalid_reserved_ss58_format(self):
with self.assertRaises(ValueError) as cm:
ss58_encode(self.alice_keypair['public_key'], ss58_format=46)
self.assertEqual('Invalid value for ss58_format', str(cm.exception))
with self.assertRaises(ValueError) as cm:
ss58_encode(self.alice_keypair['public_key'], ss58_format=47)
self.assertEqual('Invalid value for ss58_format', str(cm.exception))
def setup_arbitrator(self, arbitrator_key: str):
"""
Set up constants required for arbitrator functionality
"""
self.keypair = sr25519.pair_from_seed(bytes.fromhex(arbitrator_key))
self.arbitrator_account_id = self.keypair[0].hex()
self.arbitrator_address = ss58_encode(self.keypair[0],
ss58_format=self.address_type)
def test_create_multi_sig_address(self):
MultiAccountId = RuntimeConfiguration().get_decoder_class("MultiAccountId")
multi_sig_account = MultiAccountId.create_from_account_list(
["CdVuGwX71W4oRbXHsLuLQxNPns23rnSSiZwZPN4etWf6XYo",
"J9aQobenjZjwWtU2MsnYdGomvcYbgauCnBeb8xGrcqznvJc",
"HvqnQxDQbi3LL2URh7WQfcmi8b2ZWfBhu7TEDmyyn5VK8e2"], 2)
multi_sig_address = ss58_encode(multi_sig_account.value.replace('0x', ''), 2)
self.assertEqual(multi_sig_address, "HFXXfXavDuKhLLBhFQTat2aaRQ5CMMw9mwswHzWi76m6iLt")
def __init__(self, address_type=0, *, mnemonic=None, hex=None):
if mnemonic:
seed_bytes = bip39.bip39_to_mini_secret(mnemonic, "")
seed_hex = bytearray(seed_bytes).hex()
self.hex = seed_hex
if hex:
self.hex = hex
self.keypair = sr25519.pair_from_seed(bytes.fromhex(self.hex))
self.public_key = self.keypair[0].hex()
self.private_key = self.keypair[1].hex()
self.address = ss58_encode(self.keypair[0], ss58_format=address_type)
def order_addresses(addresses: list, address_type: int = 0):
bytearray_public_keys = []
ordered_addresses = []
# Convert address to public keys and then to byte array
for address in addresses:
public_key = ss58_decode(address, valid_ss58_format=address_type)
public_key_bytearray = bytearray()
public_key_bytearray.extend(map(ord, public_key))
bytearray_public_keys.append(public_key_bytearray)
sorted_bytearray = sorted(bytearray_public_keys)
# Convert back to addresses
for byte_array in sorted_bytearray:
ordered_addresses.append(
ss58_encode(byte_array.decode(), ss58_format=address_type))
return ordered_addresses
def get_escrow_address(self,
buyer_address: str,
seller_address: str,
threshold: int = 2) -> str:
"""
Returns an escrow address for multisignature transactions
"""
MultiAccountId = self.runtime_config.get_decoder_class(
"MultiAccountId")
multi_sig_account_id = MultiAccountId.create_from_account_list(
[buyer_address, seller_address, self.arbitrator_address],
2,
)
multi_sig_address = ss58_encode(multi_sig_account_id.value.replace(
"0x", ""),
ss58_format=self.address_type)
return multi_sig_address
def test_encode_4_bytes_account_index(self):
self.assertEqual('zswfoZa',
ss58_encode_account_index(67305985, ss58_format=2))
self.assertEqual('zswfoZa', ss58_encode('0x01020304', ss58_format=2))
def test_encode_2_bytes_account_index(self):
self.assertEqual('3xygo', ss58_encode_account_index(256,
ss58_format=2))
self.assertEqual('3xygo', ss58_encode('0x0001', ss58_format=2))
def test_encode_1_byte_account_index_with_format(self):
self.assertEqual('g4b', ss58_encode_account_index(1, ss58_format=2))
self.assertEqual('g4b', ss58_encode('0x01', ss58_format=2))
def test_invalid_public_key(self):
with self.assertRaises(ValueError) as cm:
ss58_encode(self.alice_keypair['public_key'][:30])
self.assertEqual('Invalid length for address', str(cm.exception))
def test_invalid_reserved_ss58_format(self):
with self.assertRaises(ValueError):
ss58_encode(self.alice_keypair['public_key'], ss58_format=46)
ss58_encode(self.alice_keypair['public_key'], ss58_format=47)
def test_encode_with_2_byte_prefix(self):
public_key = ss58_decode(
'5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua')
self.assertEqual('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k',
ss58_encode(public_key, ss58_format=255))
def test_encode_33_byte_address(self):
self.assertEqual(
'KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou',
ss58_encode(
'0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077'
))
def test_invalid_public_key(self):
with self.assertRaises(ValueError):
ss58_encode(self.alice_keypair['public_key'][:30])
def test_encode_8_bytes_account_index(self):
self.assertEqual('848Gh2GcGaZia',
ss58_encode('0x2a2c0a0000000000', ss58_format=2))
def test_encode_subkey_generated_pairs(self):
for subkey_pair in self.subkey_pairs:
self.assertEqual(
subkey_pair['address'],
ss58_encode(address=subkey_pair['public_key'],
ss58_format=subkey_pair['ss58_format']))
def test_invalid_ss58_format_range_exceptions(self):
with self.assertRaises(ValueError):
ss58_encode(self.alice_keypair['public_key'], ss58_format=-1)
ss58_encode(self.alice_keypair['public_key'], ss58_format=16384)
