robosats/tests/test_trade_pipeline.py

from datetime import datetime
from decimal import Decimal

from decouple import config
from django.contrib.auth.models import User
from django.urls import reverse

from api.models import Currency, Order
from api.tasks import cache_market
from django.contrib.admin.sites import AdminSite
from control.models import BalanceLog
from control.tasks import compute_node_balance, do_accounting
from tests.test_api import BaseAPITestCase
from tests.utils.node import add_invoice, set_up_regtest_network
from tests.utils.pgp import sign_message
from tests.utils.trade import Trade

from api.admin import OrderAdmin


def read_file(file_path):
    """
    Read a file and return its content.
    """
    with open(file_path, "r") as file:
        return file.read()


class TradeTest(BaseAPITestCase):
    su_pass = "12345678"
    su_name = config("ESCROW_USERNAME", cast=str, default="admin")

    @classmethod
    def setUpTestData(cls):
        """
        Set up initial data for the test case.
        """
        # Create super user
        User.objects.create_superuser(cls.su_name, "super@user.com", cls.su_pass)

        # Fetch currency prices from external APIs
        cache_market()

        # Initialize bitcoin core, mine some blocks, connect nodes, open channel
        set_up_regtest_network()

        # Take the first node balances snapshot
        compute_node_balance()

    def assert_order_logs(self, order_id):
        order = Order.objects.get(id=order_id)
        order_admin = OrderAdmin(model=Order, admin_site=AdminSite())
        try:
            result = order_admin._logs(order)
            self.assertIsInstance(result, str)
        except Exception as e:
            self.fail(f"Exception occurred: {e}")

    def test_login_superuser(self):
        """
        Test the login functionality for the superuser.
        """
        path = reverse("admin:login")
        data = {"username": self.su_name, "password": self.su_pass}
        response = self.client.post(path, data)
        self.assertEqual(response.status_code, 302)
        self.assertResponse(
            response
        )  # should skip given that /coordinator/login is not documented

    def test_cache_market(self):
        """
        Test if the cache_market() call during test setup worked
        """
        usd = Currency.objects.get(id=1)
        self.assertIsInstance(
            usd.exchange_rate,
            Decimal,
            f"Exchange rate is not a Decimal. Got {type(usd.exchange_rate)}",
        )
        self.assertGreater(
            usd.exchange_rate, 0, "Exchange rate is not higher than zero"
        )
        self.assertIsInstance(
            usd.timestamp, datetime, "External price timestamp is not a datetime"
        )

    def test_initial_balance_log(self):
        """
        Test if the initial node BalanceLog is correct.
        One channel should exist with 0.5BTC in local.
        No onchain balance should exist.
        """
        balance_log = BalanceLog.objects.latest()

        self.assertIsInstance(balance_log.time, datetime)
        self.assertTrue(balance_log.total > 0)
        self.assertTrue(balance_log.ln_local > 0)
        self.assertTrue(balance_log.ln_local_unsettled >= 0)
        self.assertTrue(balance_log.ln_remote > 0)
        self.assertEqual(balance_log.ln_remote_unsettled, 0)
        self.assertTrue(balance_log.onchain_total > 0)
        self.assertTrue(balance_log.onchain_confirmed > 0)
        self.assertEqual(balance_log.onchain_unconfirmed, 0)
        self.assertTrue(balance_log.onchain_fraction > 0)

    def assert_robot(self, response, robot_index):
        """
        Assert that the robot is created correctly.
        """
        nickname = read_file(f"tests/robots/{robot_index}/nickname")
        pub_key = read_file(f"tests/robots/{robot_index}/pub_key")
        enc_priv_key = read_file(f"tests/robots/{robot_index}/enc_priv_key")

        data = response.json()

        self.assertEqual(response.status_code, 200)
        self.assertResponse(response)

        self.assertEqual(
            data["nickname"],
            nickname,
            f"Robot created nickname is not {nickname}",
        )
        self.assertEqual(
            data["public_key"], pub_key, "Returned public Kky does not match"
        )
        self.assertEqual(
            data["encrypted_private_key"],
            enc_priv_key,
            "Returned encrypted private key does not match",
        )
        self.assertEqual(
            len(data["tg_token"]), 15, "String is not exactly 15 characters long"
        )
        self.assertEqual(
            data["tg_bot_name"],
            config(
                "TELEGRAM_BOT_NAME", cast=str, default="RoboCoordinatorNotificationBot"
            ),
            "Telegram bot name is not correct",
        )
        self.assertFalse(
            data["tg_enabled"], "The new robot's telegram seems to be enabled"
        )
        self.assertEqual(data["earned_rewards"], 0, "The new robot's rewards are not 0")

    def test_create_robots(self):
        """
        Test the creation of two robots to be used in the trade tests
        """
        trade = Trade(self.client)
        for robot_index in [1, 2]:
            response = trade.create_robot(robot_index)
            self.assert_robot(response, robot_index)

    def test_make_order(self):
        """
        Test the creation of an order.
        """
        trade = Trade(
            self.client
        )  # init of Trade calls make_order() with the default maker form.
        data = trade.response.json()

        # Checks
        self.assertResponse(trade.response)

        self.assertIsInstance(data["id"], int, "Order ID is not an integer")
        self.assertEqual(
            data["status"],
            Order.Status.WFB,
            "Newly created order status is not 'Waiting for maker bond'",
        )
        self.assertIsInstance(
            datetime.fromisoformat(data["created_at"]),
            datetime,
            "Order creation timestamp is not datetime",
        )
        self.assertIsInstance(
            datetime.fromisoformat(data["expires_at"]),
            datetime,
            "Order expiry time is not datetime",
        )
        self.assertEqual(
            data["type"], Order.Types.BUY, "Buy order is not of type value BUY"
        )
        self.assertEqual(data["currency"], 1, "Order for USD is not of currency USD")
        self.assertIsNone(
            data["amount"], "Order with range has a non-null simple amount"
        )
        self.assertTrue(data["has_range"], "Order with range has a False has_range")
        self.assertAlmostEqual(
            float(data["min_amount"]),
            trade.maker_form["min_amount"],
            "Order min amount does not match",
        )
        self.assertAlmostEqual(
            float(data["max_amount"]),
            trade.maker_form["max_amount"],
            "Order max amount does not match",
        )
        self.assertEqual(
            data["payment_method"],
            trade.maker_form["payment_method"],
            "Order payment method does not match",
        )
        self.assertEqual(
            data["escrow_duration"],
            trade.maker_form["escrow_duration"],
            "Order escrow duration does not match",
        )
        self.assertAlmostEqual(
            float(data["bond_size"]),
            trade.maker_form["bond_size"],
            "Order bond size does not match",
        )
        self.assertAlmostEqual(
            float(data["latitude"]),
            trade.maker_form["latitude"],
            "Order latitude does not match",
        )
        self.assertAlmostEqual(
            float(data["longitude"]),
            trade.maker_form["longitude"],
            "Order longitude does not match",
        )
        self.assertAlmostEqual(
            float(data["premium"]),
            trade.maker_form["premium"],
            "Order premium does not match",
        )
        self.assertFalse(
            data["is_explicit"], "Relative pricing order has True is_explicit"
        )
        self.assertIsNone(
            data["satoshis"], "Relative pricing order has non-null Satoshis"
        )
        self.assertIsNone(data["taker"], "New order's taker is not null")
        self.assert_order_logs(data["id"])

    def test_make_order_on_blocked_country(self):
        """
        Test the creation of an F2F order on a geoblocked location
        """
        trade = Trade(
            self.client,
            # latitude and longitud in Aruba. One of the countries blocked in the example conf.
            maker_form={
                "type": 0,
                "currency": 1,
                "has_range": True,
                "min_amount": 21,
                "max_amount": 101.7,
                "payment_method": "Advcash Cash F2F",
                "is_explicit": False,
                "premium": 3.34,
                "public_duration": 69360,
                "escrow_duration": 8700,
                "bond_size": 3.5,
                "latitude": -11.8014,  # Angola AGO
                "longitude": 17.3575,
            },
        )  # init of Trade calls make_order() with the default maker form.
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 400)
        self.assertResponse(trade.response)

        self.assertEqual(
            data["bad_request"], "The coordinator does not support orders in AGO"
        )

    def test_get_order_created(self):
        """
        Tests the creation of an order and the first request to see details,
        including, the creation of the maker bond invoice.
        """
        robot_index = 1
        trade = Trade(
            self.client, maker_index=robot_index
        )  # init of Trade calls make_order() with the default maker form.

        # Maker's first order fetch. Should trigger maker bond hold invoice generation.
        trade.get_order()
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["id"], trade.order_id)
        self.assertIsInstance(datetime.fromisoformat(data["created_at"]), datetime)
        self.assertIsInstance(datetime.fromisoformat(data["expires_at"]), datetime)
        self.assertTrue(data["is_maker"])
        self.assertTrue(data["is_participant"])
        self.assertTrue(data["is_buyer"])
        self.assertFalse(data["is_seller"])
        self.assertEqual(data["maker_status"], "Active")
        self.assertEqual(data["status_message"], Order.Status(Order.Status.WFB).label)
        self.assertFalse(data["is_fiat_sent"])
        self.assertFalse(data["is_disputed"])
        self.assertEqual(
            data["ur_nick"], read_file(f"tests/robots/{robot_index}/nickname")
        )
        self.assertEqual(
            data["maker_nick"], read_file(f"tests/robots/{robot_index}/nickname")
        )
        self.assertIsHash(data["maker_hash_id"])
        self.assertIsInstance(data["satoshis_now"], int)
        self.assertFalse(data["maker_locked"])
        self.assertFalse(data["taker_locked"])
        self.assertFalse(data["escrow_locked"])
        self.assertIsInstance(data["bond_satoshis"], int)

        # Cancel order to avoid leaving pending HTLCs after a successful test
        trade.cancel_order()

        self.assert_order_logs(data["id"])

    def test_publish_order(self):
        """
        Tests a trade from order creation to published (maker bond locked).
        """
        trade = Trade(self.client)
        trade.publish_order()
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["id"], data["id"])
        self.assertEqual(data["status_message"], Order.Status(Order.Status.PUB).label)
        self.assertTrue(data["maker_locked"])
        self.assertFalse(data["taker_locked"])
        self.assertFalse(data["escrow_locked"])

        # Test what we can see with newly created robot 2 (only for public status)
        trade.get_order(robot_index=2, first_encounter=True)
        public_data = trade.response.json()

        self.assertFalse(public_data["is_participant"])
        self.assertIsInstance(public_data["price_now"], float)
        self.assertIsInstance(data["satoshis_now"], int)

        # Cancel order to avoid leaving pending HTLCs after a successful test
        trade.cancel_order()

        self.assert_order_logs(data["id"])

    def test_pause_unpause_order(self):
        """
        Tests pausing and unpausing a public order
        """
        trade = Trade(self.client)
        trade.publish_order()
        data = trade.response.json()

        # PAUSE
        trade.pause_order()
        data = trade.response.json()

        self.assertResponse(trade.response)
        self.assertEqual(data["status_message"], Order.Status(Order.Status.PAU).label)

        # UNPAUSE
        trade.pause_order()
        data = trade.response.json()

        self.assertResponse(trade.response)
        self.assertEqual(data["status_message"], Order.Status(Order.Status.PUB).label)

        # Cancel order to avoid leaving pending HTLCs after a successful test
        trade.cancel_order()

        self.assert_order_logs(data["id"])

    def test_make_and_take_order(self):
        """
        Tests a trade from order creation to taken.
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()

        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["status_message"], Order.Status(Order.Status.TAK).label)
        self.assertEqual(
            data["ur_nick"], read_file(f"tests/robots/{trade.taker_index}/nickname")
        )
        self.assertEqual(
            data["taker_nick"], read_file(f"tests/robots/{trade.taker_index}/nickname")
        )
        self.assertEqual(
            data["maker_nick"], read_file(f"tests/robots/{trade.maker_index}/nickname")
        )
        self.assertIsHash(data["maker_hash_id"])
        self.assertIsHash(data["taker_hash_id"])
        self.assertEqual(data["maker_status"], "Active")
        self.assertEqual(data["taker_status"], "Active")
        self.assertFalse(data["is_maker"])
        self.assertFalse(data["is_buyer"])
        self.assertTrue(data["is_seller"])
        self.assertTrue(data["is_taker"])
        self.assertTrue(data["is_participant"])
        self.assertTrue(data["maker_locked"])
        self.assertFalse(data["taker_locked"])
        self.assertFalse(data["escrow_locked"])

        # Cancel order to avoid leaving pending HTLCs after a successful test
        trade.cancel_order()

        self.assert_order_logs(data["id"])

    def test_make_and_lock_contract(self):
        """
        Tests a trade from order creation to taker bond locked.
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()

        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["status_message"], Order.Status(Order.Status.WF2).label)
        self.assertEqual(data["maker_status"], "Active")
        self.assertEqual(data["taker_status"], "Active")
        self.assertTrue(data["is_participant"])
        self.assertTrue(data["maker_locked"])
        self.assertTrue(data["taker_locked"])
        self.assertFalse(data["escrow_locked"])

        # Maker GET
        trade.get_order(trade.maker_index)
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["status_message"], Order.Status(Order.Status.WF2).label)
        self.assertTrue(data["swap_allowed"])
        self.assertIsInstance(data["suggested_mining_fee_rate"], float)
        self.assertIsInstance(data["swap_fee_rate"], float)
        self.assertTrue(data["suggested_mining_fee_rate"] > 0)
        self.assertTrue(data["swap_fee_rate"] > 0)
        self.assertEqual(data["maker_status"], "Active")
        self.assertEqual(data["taker_status"], "Active")
        self.assertTrue(data["is_participant"])
        self.assertTrue(data["maker_locked"])
        self.assertTrue(data["taker_locked"])
        self.assertFalse(data["escrow_locked"])

        # Maker cancels order to avoid leaving pending HTLCs after a successful test
        trade.cancel_order()

        self.assert_order_logs(data["id"])

    def test_trade_to_locked_escrow(self):
        """
        Tests a trade from order creation until escrow locked, before
        invoice/address is submitted by buyer.
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)

        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["status_message"], Order.Status(Order.Status.WFI).label)
        self.assertTrue(data["maker_locked"])
        self.assertTrue(data["taker_locked"])
        self.assertTrue(data["escrow_locked"])

        # Cancel order to avoid leaving pending HTLCs after a successful test
        trade.cancel_order(trade.taker_index)

    def test_trade_to_submitted_address(self):
        """
        Tests a trade from order creation until escrow locked, before
        invoice/address is submitted by buyer.
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_address(trade.maker_index)

        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["status_message"], Order.Status(Order.Status.CHA).label)
        self.assertFalse(data["is_fiat_sent"])

        # Cancel order to avoid leaving pending HTLCs after a successful test
        trade.cancel_order(trade.maker_index)
        trade.cancel_order(trade.taker_index)

        self.assert_order_logs(data["id"])

    def test_trade_to_submitted_invoice(self):
        """
        Tests a trade from order creation until escrow locked and
        invoice is submitted by buyer.
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_invoice(trade.maker_index)

        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["status_message"], Order.Status(Order.Status.CHA).label)
        self.assertFalse(data["is_fiat_sent"])

        # Cancel order to avoid leaving pending HTLCs after a successful test
        trade.cancel_order(trade.maker_index)
        trade.cancel_order(trade.taker_index)

    def test_trade_to_confirm_fiat_sent_LN(self):
        """
        Tests a trade from order creation until fiat sent confirmed
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_invoice(trade.maker_index)
        trade.confirm_fiat(trade.maker_index)

        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["status_message"], Order.Status(Order.Status.FSE).label)
        self.assertTrue(data["is_fiat_sent"])

        # Cancel order to avoid leaving pending HTLCs after a successful test
        trade.undo_confirm_sent(trade.maker_index)
        data = trade.response.json()
        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)
        self.assertEqual(data["status_message"], Order.Status(Order.Status.CHA).label)

        trade.cancel_order(trade.maker_index)
        trade.cancel_order(trade.taker_index)

        self.assert_order_logs(data["id"])

    def test_trade_to_confirm_fiat_received_LN(self):
        """
        Tests a trade from order creation until fiat received is confirmed by seller/taker
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_invoice(trade.maker_index)
        trade.confirm_fiat(trade.maker_index)
        trade.confirm_fiat(trade.taker_index)

        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["status_message"], Order.Status(Order.Status.PAY).label)
        self.assertTrue(data["is_fiat_sent"])
        self.assertFalse(data["is_disputed"])
        self.assertFalse(data["maker_locked"])
        self.assertFalse(data["taker_locked"])
        self.assertFalse(data["escrow_locked"])

        self.assert_order_logs(data["id"])

    def test_successful_LN(self):
        """
        Tests a trade from order creation until Sats sent to buyer
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_invoice(trade.maker_index)
        trade.confirm_fiat(trade.maker_index)
        trade.confirm_fiat(trade.taker_index)

        trade.process_payouts()
        trade.get_order(trade.maker_index)

        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["status_message"], Order.Status(Order.Status.SUC).label)
        self.assertTrue(data["is_fiat_sent"])
        self.assertFalse(data["is_disputed"])
        self.assertIsHash(data["maker_summary"]["preimage"])
        self.assertIsHash(data["maker_summary"]["payment_hash"])

        self.assert_order_logs(data["id"])

    def test_successful_onchain(self):
        """
        Tests a trade from order creation until Sats sent to buyer
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_address(trade.maker_index)
        trade.confirm_fiat(trade.maker_index)
        trade.confirm_fiat(trade.taker_index)

        trade.process_payouts(mine_a_block=True)
        trade.get_order(trade.maker_index)

        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(data["status_message"], Order.Status(Order.Status.SUC).label)
        self.assertTrue(data["is_fiat_sent"])
        self.assertFalse(data["is_disputed"])
        self.assertIsInstance(data["maker_summary"]["address"], str)
        self.assertIsHash(data["maker_summary"]["txid"])

        self.assert_order_logs(data["id"])

    def test_cancel_public_order(self):
        """
        Tests the cancellation of a public order
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.cancel_order()

        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 400)
        self.assertResponse(trade.response)

        self.assertEqual(
            data["bad_request"], "This order has been cancelled by the maker"
        )

    def test_collaborative_cancel_order_in_chat(self):
        """
        Tests the collaborative cancellation of an order in the chat state
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_invoice(trade.maker_index)

        # Maker asks for cancel
        trade.cancel_order(trade.maker_index)
        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)
        self.assertTrue(trade.response.json()["asked_for_cancel"])

        # Taker checks order
        trade.get_order(trade.taker_index)
        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)
        self.assertTrue(trade.response.json()["pending_cancel"])

        # Taker accepts (ask) the cancellation
        trade.cancel_order(trade.taker_index)
        self.assertEqual(trade.response.status_code, 400)
        self.assertResponse(trade.response)
        self.assertEqual(
            trade.response.json()["bad_request"],
            "This order has been cancelled collaborativelly",
        )

    def test_created_order_expires(self):
        """
        Tests the expiration of a public order
        """
        trade = Trade(self.client)

        # Change order expiry to now
        order = Order.objects.get(id=trade.response.json()["id"])
        order.expires_at = datetime.now()
        order.save()

        # Make orders expire
        trade.clean_orders()

        trade.get_order()
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(
            data["status"],
            Order.Status.EXP,
        )
        self.assertEqual(
            data["expiry_message"],
            Order.ExpiryReasons(Order.ExpiryReasons.NMBOND).label,
        )
        self.assertEqual(data["expiry_reason"], Order.ExpiryReasons.NMBOND)

        self.assert_order_logs(data["id"])

    def test_public_order_expires(self):
        """
        Tests the expiration of a public order
        """
        trade = Trade(self.client)
        trade.publish_order()

        # Change order expiry to now
        order = Order.objects.get(id=trade.response.json()["id"])
        order.expires_at = datetime.now()
        order.save()

        # Make orders expire
        trade.clean_orders()

        trade.get_order()
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(
            data["status"],
            Order.Status.EXP,
        )
        self.assertEqual(
            data["expiry_message"],
            Order.ExpiryReasons(Order.ExpiryReasons.NTAKEN).label,
        )
        self.assertEqual(data["expiry_reason"], Order.ExpiryReasons.NTAKEN)

        self.assert_order_logs(data["id"])

    def test_taken_order_expires(self):
        """
        Tests the expiration of a public order
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()

        # Change order expiry to now
        order = Order.objects.get(id=trade.response.json()["id"])
        order.expires_at = datetime.now()
        order.save()

        # Make orders expire
        trade.clean_orders()

        trade.get_order()
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(
            data["status"],
            Order.Status.EXP,
        )
        self.assertEqual(
            data["expiry_message"],
            Order.ExpiryReasons(Order.ExpiryReasons.NESINV).label,
        )
        self.assertEqual(data["expiry_reason"], Order.ExpiryReasons.NESINV)

        self.assert_order_logs(data["id"])

    def test_escrow_locked_expires(self):
        """
        Tests the expiration of a public order
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)

        # Change order expiry to now
        order = Order.objects.get(id=trade.response.json()["id"])
        order.expires_at = datetime.now()
        order.save()

        # Make orders expire
        trade.clean_orders()

        trade.get_order()
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(
            data["status"],
            Order.Status.EXP,
        )
        self.assertEqual(
            data["expiry_message"],
            Order.ExpiryReasons(Order.ExpiryReasons.NINVOI).label,
        )
        self.assertEqual(data["expiry_reason"], Order.ExpiryReasons.NINVOI)

        self.assert_order_logs(data["id"])

    def test_chat(self):
        """
        Tests the chatting REST functionality
        """
        path = reverse("chat")
        message = (
            "Example message string. Note clients will verify expect only PGP messages."
        )

        # Run a successful trade
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_invoice(trade.maker_index)

        params = f"?order_id={trade.order_id}"
        maker_headers = trade.get_robot_auth(trade.maker_index)
        taker_headers = trade.get_robot_auth(trade.taker_index)
        maker_nick = read_file(f"tests/robots/{trade.maker_index}/nickname")
        taker_nick = read_file(f"tests/robots/{trade.taker_index}/nickname")

        # Get empty chatroom as maker
        response = self.client.get(path + params, **maker_headers)
        self.assertResponse(response)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json()["messages"], [])
        self.assertTrue(response.json()["peer_connected"])

        # Get empty chatroom as taker
        response = self.client.get(path + params, **taker_headers)
        self.assertResponse(response)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json()["messages"], [])
        self.assertTrue(response.json()["peer_connected"])

        # Post new message as maker
        body = {"PGP_message": message, "order_id": trade.order_id, "offset": 0}
        response = self.client.post(path, data=body, **maker_headers)
        self.assertResponse(response)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json()["messages"][0]["message"], message)
        self.assertTrue(response.json()["peer_connected"])

        # Post new message as taker without offset, so response should not have messages.
        body = {"PGP_message": message + " 2", "order_id": trade.order_id}
        response = self.client.post(path, data=body, **taker_headers)
        self.assertResponse(response)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {})  # Nothing in the response

        # Get the two chatroom messages as maker
        response = self.client.get(path + params, **maker_headers)
        self.assertResponse(response)
        self.assertEqual(response.status_code, 200)
        self.assertTrue(response.json()["peer_connected"])
        self.assertEqual(response.json()["messages"][0]["message"], message)
        self.assertEqual(response.json()["messages"][1]["message"], message + " 2")
        self.assertEqual(response.json()["messages"][0]["nick"], maker_nick)
        self.assertEqual(response.json()["messages"][1]["nick"], taker_nick)

        # Cancel order to avoid leaving pending HTLCs after a successful test
        trade.cancel_order(trade.maker_index)
        trade.cancel_order(trade.taker_index)

    def test_order_expires_after_only_taker_messaged(self):
        """
        Tests the expiration of an order in chat where maker never messaged
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_invoice(trade.maker_index)

        path = reverse("chat")
        message = "Unencrypted message from taker"
        params = f"?order_id={trade.order_id}"
        taker_headers = trade.get_robot_auth(trade.taker_index)

        # Post new message as taker
        body = {"PGP_message": message, "order_id": trade.order_id}
        self.client.post(path + params, data=body, **taker_headers)

        # Change order expiry to now
        order = Order.objects.get(id=trade.response.json()["id"])
        order.expires_at = datetime.now()
        order.save()

        # Make orders expire
        trade.clean_orders()

        trade.get_order()
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        # Verify taker lost dispute automatically
        self.assertEqual(
            data["status"],
            Order.Status.MLD,
        )

        self.assert_order_logs(data["id"])

    def test_order_expires_after_only_maker_messaged(self):
        """
        Tests the expiration of an order in chat where taker never messaged
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_invoice(trade.maker_index)

        path = reverse("chat")
        message = "Unencrypted message from taker"
        params = f"?order_id={trade.order_id}"
        maker_headers = trade.get_robot_auth(trade.maker_index)

        # Post new message as taker
        body = {"PGP_message": message, "order_id": trade.order_id}
        self.client.post(path + params, data=body, **maker_headers)

        # Change order expiry to now
        order = Order.objects.get(id=trade.response.json()["id"])
        order.expires_at = datetime.now()
        order.save()

        # Make orders expire
        trade.clean_orders()

        trade.get_order()
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        # Verify taker lost dispute automatically
        self.assertEqual(
            data["status"],
            Order.Status.TLD,
        )

        self.assert_order_logs(data["id"])

    def test_withdraw_reward_after_unilateral_cancel(self):
        """
        Tests withdraw rewards as taker after maker cancels order unilaterally
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.cancel_order(trade.maker_index)

        # Fetch amount of rewards for taker
        path = reverse("robot")
        taker_headers = trade.get_robot_auth(trade.maker_index)
        response = self.client.get(path, **taker_headers)

        self.assertEqual(response.status_code, 200)
        self.assertResponse(response)
        self.assertIsInstance(response.json()["earned_rewards"], int)

        # Submit reward invoice
        path = reverse("reward")
        invoice = add_invoice("robot", response.json()["earned_rewards"])
        signed_payout_invoice = sign_message(
            invoice,
            passphrase_path=f"tests/robots/{trade.taker_index}/token",
            private_key_path=f"tests/robots/{trade.taker_index}/enc_priv_key",
        )
        body = {
            "invoice": signed_payout_invoice,
        }

        response = self.client.post(path, body, **taker_headers)

        self.assertEqual(response.status_code, 200)
        self.assertResponse(response)
        self.assertTrue(response.json()["successful_withdrawal"])

    def test_order_expires_after_fiat_sent(self):
        """
        Tests the expiration of an order after fiat sent is confirmed
        """
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_address(trade.maker_index)
        trade.confirm_fiat(trade.maker_index)

        # Change order expiry to now
        order = Order.objects.get(id=trade.response.json()["id"])
        order.expires_at = datetime.now()
        order.save()

        # Make orders expire
        trade.clean_orders()

        trade.get_order()
        data = trade.response.json()

        self.assertEqual(trade.response.status_code, 200)
        self.assertResponse(trade.response)

        self.assertEqual(
            data["status"],
            Order.Status.DIS,
        )

        self.assert_order_logs(data["id"])

    def test_ticks(self):
        """
        Tests the historical ticks serving endpoint after creating a contract
        """
        path = reverse("ticks")
        params = "?start=01-01-1970&end=01-01-2070"

        # Make a contract and cancel
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.cancel_order()

        response = self.client.get(path + params)
        data = response.json()

        self.assertEqual(response.status_code, 200)
        self.assertResponse(response)

        self.assertIsInstance(datetime.fromisoformat(data[0]["timestamp"]), datetime)
        self.assertIsInstance(data[0]["volume"], str)
        self.assertIsInstance(data[0]["price"], str)
        self.assertIsInstance(data[0]["premium"], str)
        self.assertIsInstance(data[0]["fee"], str)

    def test_daily_historical(self):
        """
        Tests the daily history serving endpoint after creating a contract
        """
        path = reverse("historical")

        # Run a successful trade
        trade = Trade(self.client)
        trade.publish_order()
        trade.take_order()
        trade.lock_taker_bond()
        trade.lock_escrow(trade.taker_index)
        trade.submit_payout_invoice(trade.maker_index)
        trade.confirm_fiat(trade.maker_index)
        trade.confirm_fiat(trade.taker_index)
        trade.process_payouts()

        # Do daily accounting to create the daily summary
        do_accounting()

        response = self.client.get(path)
        data = response.json()

        self.assertEqual(response.status_code, 200)
        # self.assertResponse(response) # Expects an array, but response is an object
        first_date = list(data.keys())[0]
        self.assertIsInstance(datetime.fromisoformat(first_date), datetime)
        self.assertIsInstance(data[first_date]["volume"], float)
        self.assertIsInstance(data[first_date]["num_contracts"], int)

    def test_book(self):
        """
        Tests public book view
        """
        path = reverse("book")

        trade = Trade(self.client)
        trade.publish_order()

        response = self.client.get(path)
        data = response.json()

        self.assertEqual(response.status_code, 200)
        self.assertResponse(response)

        self.assertIsInstance(datetime.fromisoformat(data[0]["created_at"]), datetime)
        self.assertIsInstance(datetime.fromisoformat(data[0]["expires_at"]), datetime)
        self.assertIsHash(data[0]["maker_hash_id"])
        self.assertIsNone(data[0]["amount"])
        self.assertAlmostEqual(
            float(data[0]["min_amount"]), trade.maker_form["min_amount"]
        )
        self.assertAlmostEqual(
            float(data[0]["max_amount"]), trade.maker_form["max_amount"]
        )
        self.assertAlmostEqual(float(data[0]["latitude"]), trade.maker_form["latitude"])
        self.assertAlmostEqual(
            float(data[0]["longitude"]), trade.maker_form["longitude"]
        )
        self.assertEqual(
            data[0]["escrow_duration"], trade.maker_form["escrow_duration"]
        )
        self.assertFalse(data[0]["is_explicit"])

        # Cancel order to avoid leaving pending HTLCs after a successful test
        trade.cancel_order()