def test_from_and_to_string(self):
a = Address(self.addr)
self.assertEqual(str(a), self.addr)
self.assertEqual("{:s}".format(a), self.addr)
self.assertEqual(a.spend_key(), self.psk)
self.assertEqual(a.view_key(), self.pvk)
self.assertEqual(hash(a), hash(self.addr))
ba = Address(self.addr.encode())
self.assertEqual(ba, a)
ba = address(self.addr.encode())
self.assertEqual(ba, a)
ia = IntegratedAddress(self.iaddr)
self.assertEqual(ia.payment_id(), self.pid)
self.assertEqual(str(ia), self.iaddr)
self.assertEqual("{:s}".format(ia), self.iaddr)
self.assertEqual(ia.spend_key(), self.psk)
self.assertEqual(ia.view_key(), self.pvk)
self.assertEqual(ia.base_address(), a)
ba = IntegratedAddress(self.iaddr.encode())
self.assertEqual(ba, ia)
ba = address(self.iaddr.encode())
self.assertEqual(ba, ia)
sa = SubAddress(self.subaddr)
self.assertEqual(str(sa), self.subaddr)
self.assertEqual("{:s}".format(sa), self.subaddr)
ba = SubAddress(self.subaddr.encode())
self.assertEqual(ba, sa)
ba = address(self.subaddr.encode())
self.assertEqual(ba, sa)
def test_recognition_and_comparisons(self):
a = Address(self.addr)
a2 = address(self.addr)
self.assertIsInstance(a2, Address)
self.assertEqual(a, a2)
self.assertEqual(a, self.addr)
self.assertEqual(self.addr, a)
self.assertEqual(a.is_testnet(), self.testnet)
self.assertEqual(a2.is_testnet(), self.testnet)
ia = IntegratedAddress(self.iaddr)
ia2 = address(self.iaddr)
self.assertIsInstance(ia, IntegratedAddress)
self.assertEqual(ia, ia2)
self.assertEqual(ia, self.iaddr)
self.assertEqual(self.iaddr, ia)
self.assertEqual(ia.is_testnet(), self.testnet)
self.assertEqual(ia2.is_testnet(), self.testnet)
self.assertEqual(ia2.get_base_address(), a)
sa = SubAddress(self.subaddr)
sa2 = address(self.subaddr)
self.assertIsInstance(sa2, SubAddress)
self.assertEqual(sa, sa2)
self.assertEqual(sa, self.subaddr)
self.assertEqual(self.subaddr, sa)
self.assertEqual(sa.is_testnet(), self.testnet)
self.assertEqual(sa2.is_testnet(), self.testnet)
def get_address_ex(private_view_key: str, master_addr: str, major: int,
minor: int) -> str:
"""
Calculates sub-address for account index (`major`) and address index within
the account (`minor`).
:rtype: :class:`BaseAddress <monero.address.BaseAddress>`
"""
# ensure indexes are within uint32
if major < 0 or major >= 2**32:
raise ValueError(
'major index {} is outside uint32 range'.format(major))
if minor < 0 or minor >= 2**32:
raise ValueError(
'minor index {} is outside uint32 range'.format(minor))
master_address = Address(master_addr) # self.address()
if major == minor == 0: # 如果是 (0, 0) 则直接返回
return str(master_address)
# spk = Address(master_addr).spend_key() #根据master address 直接获取 public_key
# = Address(master_addr).view_key()
priv_view_key = private_view_key # seed.secret_view_key()
# print(f'private_view_key: {priv_view_key}')
master_svk = unhexlify(priv_view_key)
pub_spend_key = Address(master_addr).spend_key()
master_psk = unhexlify(pub_spend_key)
# m = Hs("SubAddr\0" || master_svk || major || minor)
hsdata = b''.join([
b'SubAddr\0', master_svk,
struct.pack('<I', major),
struct.pack('<I', minor)
])
m = keccak_256(hsdata).digest()
# print(f'subprivate_view_key: { hexlify(m) }')
# D = master_psk + m * B
D = ed25519.edwards_add(ed25519.decodepoint(master_psk),
ed25519.scalarmult_B(ed25519.decodeint(m)))
# print(f'{D}')
# print(f'public_spend_key: { hexlify( ed25519.encodepoint(D) ) }')
# C = master_svk * D
C = ed25519.scalarmult(D, ed25519.decodeint(master_svk))
# print(f'public_view_key: { hexlify( ed25519.encodepoint(C) ) }')
netbyte = bytearray(
[const.SUBADDR_NETBYTES[const.NETS.index(master_address.net)]])
data = netbyte + ed25519.encodepoint(D) + ed25519.encodepoint(C)
checksum = keccak_256(data).digest()[:4]
subaddr = address.SubAddress(base58.encode(hexlify(data + checksum)))
logging.info(f'subaddr : {subaddr}')
return str(subaddr)
def test_from_and_to_string(self):
a = Address(self.addr)
self.assertEqual(str(a), self.addr)
self.assertEqual(a.get_spend_key(), self.psk)
self.assertEqual(a.get_view_key(), self.pvk)
ia = IntegratedAddress(self.iaddr)
self.assertEqual(ia.get_payment_id(), self.pid)
self.assertEqual(str(ia), self.iaddr)
self.assertEqual(ia.get_spend_key(), self.psk)
self.assertEqual(ia.get_view_key(), self.pvk)
self.assertEqual(ia.get_base_address(), a)
sa = SubAddress(self.subaddr)
self.assertEqual(str(sa), self.subaddr)
def test_idempotence(self):
a = Address(self.addr)
a_idem = Address(a)
self.assertEqual(a, a_idem)
a_idem = Address(str(a))
self.assertEqual(a, a_idem)
a_idem = address(a)
self.assertEqual(a, a_idem)
ia = IntegratedAddress(self.iaddr)
ia_idem = IntegratedAddress(ia)
self.assertEqual(ia, ia_idem)
ia_idem = IntegratedAddress(str(ia))
self.assertEqual(ia, ia_idem)
ia_idem = address(ia)
self.assertEqual(ia, ia_idem)
def gen_addrs(master_addr, private_view_key, addr_count) -> int:
try:
assert len(master_addr) == 95
assert len(private_view_key) == 64
assert addr_count > 0 and addr_count < 200000
primary_addr = Address(master_addr)
timestr = datetime.datetime.now().strftime('%Y-%m-%d_%H_%M_%S')
filename = f'XMR_主网_子地址_{str(addr_count).strip()}个_{timestr}.txt'
with open(filename, 'w') as outfile:
print('starting gen addr write into file......')
for index in range(
1, addr_count): # 从 1 开始, (0, 0) 是 standard address 不能泄露
line = f'{index}\t{get_address_ex( master_addr= primary_addr, major=0, minor=index, private_view_key=private_view_key)}\n'
outfile.write(line)
print('done')
except Exception as e:
with open('error.log', 'w') as errlog:
errlog.write(str(e))
return 1
return 0
def validate_monero_address(value):
try:
address = Address(value)
except ValueError as e:
raise ValidationError(_("%(value)s is not a valid address"),
params={"value": value})
network = getattr(settings, "DJCL_MONERO_NETWORK", None)
if not network:
raise ValidationError(
_("Please configure the monero network in the settings file"))
if network == "mainnet" and not address.is_mainnet():
raise ValidationError(_("Invalid address for mainnet"))
elif network == "stagenet" and not address.is_stagenet():
raise ValidationError(_("Invalid address for stagenet"))
elif network == "testnet" and not address.is_testnet():
raise ValidationError(_("Invalid address for testnet"))
def test_check_private_spend_key(self):
a = Address(self.addr)
self.assertTrue(a.check_private_spend_key(self.ssk))
self.assertFalse(a.check_private_spend_key(self.svk))
self.assertFalse(a.check_private_spend_key(self.psk))
self.assertFalse(a.check_private_spend_key(self.pvk))
self.assertFalse(a.check_private_spend_key('0000000000000000000000000000000000000000000000000000000000000000'))
def test_recognition_and_comparisons(self):
a = Address(self.addr)
a2 = address(self.addr)
self.assertIsInstance(a2, Address)
self.assertEqual(a, a2)
self.assertEqual(a, self.addr)
self.assertEqual(self.addr, a)
self.assertEqual(hash(a), hash(self.addr))
self.assertEqual(a.net, self.net)
self.assertEqual(a2.net, self.net)
ia = IntegratedAddress(self.iaddr)
ia2 = address(self.iaddr)
self.assertIsInstance(ia, IntegratedAddress)
self.assertEqual(ia, ia2)
self.assertEqual(ia, self.iaddr)
self.assertEqual(self.iaddr, ia)
self.assertEqual(hash(ia), hash(self.iaddr))
self.assertEqual(ia.net, self.net)
self.assertEqual(ia2.net, self.net)
self.assertEqual(ia2.base_address(), a)
self.assertEqual(ia.view_key(), a.view_key())
self.assertEqual(ia.spend_key(), a.spend_key())
sa = SubAddress(self.subaddr)
sa2 = address(self.subaddr)
self.assertIsInstance(sa2, SubAddress)
self.assertEqual(sa, sa2)
self.assertEqual(sa, self.subaddr)
self.assertEqual(self.subaddr, sa)
self.assertEqual(hash(sa), hash(self.subaddr))
self.assertEqual(sa.net, self.net)
self.assertEqual(sa2.net, self.net)
self.assertNotEqual(a, 0)
def test_check_private_view_key(self):
a = Address(self.addr)
self.assertFalse(a.check_private_view_key(self.ssk))
self.assertTrue(a.check_private_view_key(self.svk))
self.assertFalse(a.check_private_view_key(self.psk))
self.assertFalse(a.check_private_view_key(self.pvk))
self.assertFalse(
a.check_private_view_key(
"0000000000000000000000000000000000000000000000000000000000000000"
))
def test_invalid(self):
self.assertRaises(ValueError, Address, self.addr_invalid)
self.assertRaises(ValueError, Address, self.iaddr_invalid)
a = Address(self.addr)
self.assertRaises(TypeError, a.with_payment_id, 2**64 + 1)
self.assertRaises(TypeError, a.with_payment_id, "%x" % (2**64 + 1))
s = SubAddress(self.subaddr)
self.assertRaises(TypeError, s.with_payment_id, 0)
self.assertRaises(ValueError, address, 'whatever')
self.assertRaises(ValueError, Address, 'whatever')
self.assertRaises(ValueError, SubAddress, 'whatever')
self.assertRaises(ValueError, IntegratedAddress, 'whatever')
# Aeon
self.assertRaises(
ValueError, address,
'Wmtj8UAJhdrhbKvwyBJmLEUZKHcffv2VHNBaq6oTxJFwJjUj3QwMUSS32mddSX7vchbxXdmb4QuZA9TsN47441f61yAYLQYTo'
)
# invalid netbyte
self.assertRaises(
ValueError, address,
'Cf6RinMUztY5otm6NEFjg3UWBBkXK6Lh23wKrLFMEcCY7i3A6aPLH9i4QMCkf6CdWk8Q9N7yoJf7ANKgtQMuPM6JANXgCWs'
)
def test_payment_id(self):
a = Address(self.addr)
ia = a.with_payment_id(self.pid)
self.assertIsInstance(ia, IntegratedAddress)
self.assertEqual(ia.payment_id(), self.pid)
self.assertEqual(str(ia), self.iaddr)
def test_invalid(self):
self.assertRaises(ValueError, Address, self.addr_invalid)
self.assertRaises(ValueError, Address, self.iaddr_invalid)
a = Address(self.addr)
self.assertRaises(TypeError, a.with_payment_id, 2**64 + 1)
self.assertRaises(TypeError, a.with_payment_id, "%x" % (2**64 + 1))
def test_recognition_and_comparisons(self):
a = Address(self.addr)
a2 = address(self.addr)
self.assertIsInstance(a2, Address)
self.assertEqual(a, a2)
self.assertEqual(a, self.addr)
self.assertEqual(self.addr, a)
self.assertEqual(hash(a), hash(self.addr))
self.assertEqual(a.net, self.net)
with pytest.deprecated_call():
self.assertEqual(a.is_mainnet(), self.net == const.NET_MAIN)
with pytest.deprecated_call():
self.assertEqual(a.is_testnet(), self.net == const.NET_TEST)
with pytest.deprecated_call():
self.assertEqual(a.is_stagenet(), self.net == const.NET_STAGE)
self.assertEqual(a2.net, self.net)
with pytest.deprecated_call():
self.assertEqual(a2.is_mainnet(), self.net == const.NET_MAIN)
with pytest.deprecated_call():
self.assertEqual(a2.is_testnet(), self.net == const.NET_TEST)
with pytest.deprecated_call():
self.assertEqual(a2.is_stagenet(), self.net == const.NET_STAGE)
ia = IntegratedAddress(self.iaddr)
ia2 = address(self.iaddr)
self.assertIsInstance(ia, IntegratedAddress)
self.assertEqual(ia, ia2)
self.assertEqual(ia, self.iaddr)
self.assertEqual(self.iaddr, ia)
self.assertEqual(hash(ia), hash(self.iaddr))
self.assertEqual(ia.net, self.net)
with pytest.deprecated_call():
self.assertEqual(ia.is_mainnet(), self.net == const.NET_MAIN)
with pytest.deprecated_call():
self.assertEqual(ia.is_testnet(), self.net == const.NET_TEST)
with pytest.deprecated_call():
self.assertEqual(ia.is_stagenet(), self.net == const.NET_STAGE)
self.assertEqual(ia2.net, self.net)
with pytest.deprecated_call():
self.assertEqual(ia2.is_mainnet(), self.net == const.NET_MAIN)
with pytest.deprecated_call():
self.assertEqual(ia2.is_testnet(), self.net == const.NET_TEST)
with pytest.deprecated_call():
self.assertEqual(ia2.is_stagenet(), self.net == const.NET_STAGE)
self.assertEqual(ia2.base_address(), a)
self.assertEqual(ia.view_key(), a.view_key())
self.assertEqual(ia.spend_key(), a.spend_key())
sa = SubAddress(self.subaddr)
sa2 = address(self.subaddr)
self.assertIsInstance(sa2, SubAddress)
self.assertEqual(sa, sa2)
self.assertEqual(sa, self.subaddr)
self.assertEqual(self.subaddr, sa)
self.assertEqual(hash(sa), hash(self.subaddr))
self.assertEqual(sa.net, self.net)
with pytest.deprecated_call():
self.assertEqual(sa.is_mainnet(), self.net == const.NET_MAIN)
with pytest.deprecated_call():
self.assertEqual(sa.is_testnet(), self.net == const.NET_TEST)
with pytest.deprecated_call():
self.assertEqual(sa.is_stagenet(), self.net == const.NET_STAGE)
self.assertEqual(sa2.net, self.net)
with pytest.deprecated_call():
self.assertEqual(sa2.is_mainnet(), self.net == const.NET_MAIN)
with pytest.deprecated_call():
self.assertEqual(sa2.is_testnet(), self.net == const.NET_TEST)
with pytest.deprecated_call():
self.assertEqual(sa2.is_stagenet(), self.net == const.NET_STAGE)
self.assertNotEqual(a, 0)
