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 test_subaddress_valid_index(self):
sa1 = SubAddress(self.subaddr, 1)
self.assertEqual(sa1.index, 1)
sa2 = SubAddress(self.subaddr, 2)
self.assertEqual(sa2.index, 2)
sa3 = SubAddress(self.subaddr, 200)
self.assertEqual(sa3.index, 200)
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.is_mainnet(), self.mainnet)
self.assertEqual(a.is_testnet(), self.testnet)
self.assertEqual(a.is_stagenet(), self.stagenet)
self.assertEqual(a2.is_mainnet(), self.mainnet)
self.assertEqual(a2.is_testnet(), self.testnet)
self.assertEqual(a2.is_stagenet(), self.stagenet)
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.is_mainnet(), self.mainnet)
self.assertEqual(ia.is_testnet(), self.testnet)
self.assertEqual(ia.is_stagenet(), self.stagenet)
self.assertEqual(ia2.is_mainnet(), self.mainnet)
self.assertEqual(ia2.is_testnet(), self.testnet)
self.assertEqual(ia2.is_stagenet(), self.stagenet)
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.is_mainnet(), self.mainnet)
self.assertEqual(sa.is_testnet(), self.testnet)
self.assertEqual(sa.is_stagenet(), self.stagenet)
self.assertEqual(sa2.is_mainnet(), self.mainnet)
self.assertEqual(sa2.is_testnet(), self.testnet)
self.assertEqual(sa2.is_stagenet(), self.stagenet)
self.assertNotEqual(a, 0)
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_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_subaddress_cannot_into_integrated(self):
sa = SubAddress(self.subaddr)
self.assertRaises(TypeError, sa.with_payment_id, self.pid)
def monero_transaction(self, verify_validity=False, **kwargs):
"""
Function creates a transaction and
payment token using the sessions sales order
Calls MoneroSalesOrder.salesorder_payment_sync()
:param verify_validity:
:param kwargs:
:return:
"""
sales_order = request.website.sale_get_order()
_logger.info(f"received sales_order: {sales_order.id}")
_logger.info(f"processing sales_order: {sales_order.id}")
# Ensure there is something to proceed
if not sales_order or (sales_order and not sales_order.order_line):
return False
assert sales_order.partner_id.id != request.website.partner_id.id
# at this time the sales order has to be in xmr
# the user cannot use a fiat pricelist when checking out
# this won't be fixed until after a job is added to automatically
# update res.currency.rate
currency = request.env["res.currency"].sudo().browse(
sales_order.currency_id.id)
if currency.name != "XMR":
raise Exception(
"This pricelist is not supported, go back and select the "
"Monero Pricelist")
payment_acquirer_id = int(kwargs.get("acquirer_id"))
payment_partner_id = int(kwargs.get("partner_id"))
wallet_sub_address = SubAddress(kwargs.get("wallet_address"))
# define payment token
payment_token = {
"name": wallet_sub_address.__repr__(),
"partner_id": payment_partner_id,
# partner_id creating sales order
"active": False,
# token shoudn't be active, the subaddress shouldn't be reused
"acquirer_id": payment_acquirer_id,
# surrogate key for payment acquirer
"acquirer_ref": "payment.payment_acquirer_monero_rpc",
}
_logger.info(f"creating payment token "
f"for sales_order: {sales_order.id}")
token = request.env["payment.token"].sudo().create(payment_token)
token_id = token.id
token_short_name = token.short_name
# assign values for transaction creation
tx_val = {
"amount": sales_order.amount_total,
"reference": sales_order.name,
"currency_id": sales_order.currency_id.id,
"partner_id": sales_order.partner_id.id,
# Referencing the Sale Order Partner ID
"payment_token_id": token_id, # Associating the Payment Token ID.
"acquirer_id": payment_acquirer_id, # Payment Acquirer - Monero
"state": "pending",
# tx is pending,
# because the customer will know the address to send the tx to,
# but hasn't yet sent it
}
_logger.info(f"getting the transaction "
f"for sales_order: {sales_order.id}")
# transaction = sales_order._create_payment_transaction(tx_val)
transaction = sales_order.get_portal_last_transaction()
if transaction.id is False:
transaction = sales_order._create_payment_transaction(tx_val)
_logger.info(f"created transaction: {transaction.id}")
else:
_logger.info(f"retrieved transaction: {transaction.id}")
# store the new transaction into
# the transaction list and if there's an old one, we remove it
# until the day the ecommerce supports multiple orders at the same time
last_tx_id = request.session.get("__website_sale_last_tx_id")
last_tx = request.env["payment.transaction"].browse(
last_tx_id).sudo().exists()
if last_tx:
PaymentProcessing.remove_payment_transaction(last_tx)
PaymentProcessing.add_payment_transaction(transaction)
request.session["__website_sale_last_tx_id"] = transaction.id
# Sale Order is quotation sent
# , so the state should be set to "sent"
# , until the transaction has been verified
_logger.info(f'setting sales_order state to "sent" '
f"for sales_order: {sales_order.id}")
request.env.user.sale_order_ids.sudo().update({
"require_payment": "true",
"state": "sent"
})
payment_acquirer = (
request.env["payment.acquirer"].sudo().browse(payment_acquirer_id))
# set queue channel and max_retries settings
# for queue depending on num conf settings
num_conf_req = int(payment_acquirer.num_confirmation_required)
if num_conf_req == 0:
queue_channel = "monero_zeroconf_processing"
queue_max_retries = 44
else:
queue_channel = "monero_secure_processing"
queue_max_retries = num_conf_req * 25
# Add payment token and sale order to transaction processing queue
sales_order.with_delay(
channel=queue_channel,
max_retries=queue_max_retries).process_transaction(
transaction, token, num_conf_req)
if transaction:
res = {
"result": True,
"id": token_id,
"short_name": token_short_name,
"3d_secure": False,
"verified": False,
}
if verify_validity is not False:
token.validate()
res["verified"] = token.verified
return res
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)
