pluto/handler/ux/commands.py

# Other library imports
from json import dumps, loads

import db

# Project imports
from settings import settings


class GenericCommands(object):
    class trades(object):
        @staticmethod
        def got_trades(trades, msg):
            if not trades:
                msg("No open trades.")
                return
            for trade_id in trades:
                msg(trade_id)

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, caller):
            """
            Get details of open trades and post on IRC.
            """

            trades = caller.get_dashboard_irc()
            trades.addCallback(GenericCommands.trades.got_trades, msg)

    class create(object):
        @staticmethod
        def run(
            cmd,
            spl,
            length,
            authed,
            msg,
            agora,
            tx,
            ux,
            asset_list,
            provider_list,
            caller,
        ):
            """
            Post an ad on AgoraDesk/LBTC with the given country and currency code.
            """
            if length == 4:
                asset = spl[1]
                country = spl[2]
                currency = spl[3]
                if asset not in loads(asset_list):
                    msg(f"Not a valid asset: {asset}")
                    return
                _, account_info = tx.markets.get_valid_account_details(caller.platform)
                posted = caller.create_ad(
                    asset,
                    country,
                    currency,
                    "NATIONAL_BANK",
                    payment_details=account_info[currency],
                )
                if posted["success"]:
                    msg(
                        f"{posted['response']['data']['message']}: {posted['response']['data']['ad_id']}"
                    )
                else:
                    msg(dumps(posted["response"]))
            elif length == 5:
                asset = spl[1]
                country = spl[2]
                currency = spl[3]
                provider = spl[4]
                if asset not in loads(asset_list):
                    msg(f"Not a valid asset: {asset}")
                    return
                if provider not in loads(provider_list):
                    msg(f"Not a valid provider: {provider}")
                    return
                _, account_info = tx.markets.get_valid_account_details(caller.platform)
                posted = caller.create_ad(
                    asset,
                    country,
                    currency,
                    provider,
                    payment_details=account_info[currency],
                )
                if posted["success"]:
                    msg(
                        f"{posted['response']['data']['message']}: {posted['response']['data']['ad_id']}"
                    )
                else:
                    msg(dumps(posted["response"]))

    class messages(object):
        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, caller):
            """
            Get all messages for all open trades or a given trade.
            """
            if length == 1:
                m = caller.api.recent_messages()
                m.addCallback(caller.got_recent_messages)

            elif length == 2:
                tx = tx.ref_to_tx(spl[1])
                if not tx:
                    msg(f"No such reference: {spl[1]}")
                    return
                messages = caller.get_messages(spl[1], send_irc=False)
                if not messages:
                    msg("No messages.")
                for message in messages:
                    msg(f"{spl[1]}: {message}")

    class dist(object):
        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, asset_list, caller):
            # Distribute out our ad to all countries in the config
            if length == 2:
                asset = spl[1]
                if asset not in loads(asset_list):
                    msg(f"Not a valid asset: {spl[1]}")
                    return
                for x in caller.dist_countries(filter_asset=asset):
                    if x["success"]:
                        msg(
                            f"{x['response']['data']['message']}: {x['response']['data']['ad_id']}"
                        )
                    else:
                        msg(dumps(x["response"]))
            elif length == 1:
                for x in caller.dist_countries():
                    if x["success"]:
                        msg(
                            f"{x['response']['data']['message']}: {x['response']['data']['ad_id']}"
                        )
                    else:
                        msg(dumps(x["response"]))

    class redist(object):
        @staticmethod
        def got_redist(redist_output, msg):
            for x in redist_output:
                if x[0]["success"]:
                    msg(f"{x[0]['response']['data']['message']}: {x[1]}")
                else:
                    msg(dumps(x))

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, caller):
            c = caller.redist_countries()
            c.addCallback(GenericCommands.redist.got_redist, msg)

    class stripdupes(object):
        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, caller):
            rtrn = caller.strip_duplicate_ads()
            msg(dumps(rtrn))

    class message(object):
        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, caller):
            if length > 2:
                full_msg = " ".join(spl[2:])
                reference = tx.ref_to_tx(spl[1])
                if not reference:
                    msg(f"No such reference: {spl[1]}")
                    return
                rtrn = caller.contact_message_post(reference, full_msg)
                msg(f"Sent {full_msg} to {reference}: {rtrn}")

    class release(object):
        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, caller):
            if length == 2:
                tx = tx.ref_to_tx(spl[1])
                if not tx:
                    msg(f"No such reference: {spl[1]}")
                    return
                rtrn = caller.release_funds(tx)
                message = rtrn["message"]
                message_long = rtrn["response"]["data"]["message"]
                msg(f"{message} - {message_long}")

    class pubads(object):
        @staticmethod
        def got_pubads(pubads_output, currency, msg):
            if not pubads_output:
                msg("No results.")
                return
            for ad in pubads_output[currency]:
                msg(f"({ad[0]}) {ad[1]} {ad[2]} {ad[3]} {ad[4]} {ad[5]} {ad[6]}")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, asset_list, caller):
            if length == 3:
                asset = spl[1]
                if asset not in loads(asset_list):
                    msg(f"Not a valid asset: {spl[1]}")
                    return
                currency = spl[2]
                c = caller.get_all_public_ads(assets=[asset], currencies=[currency])
                c.addCallback(GenericCommands.pubads.got_pubads, currency, msg)

            elif length == 4:
                asset = spl[1]
                if asset not in loads(asset_list):
                    msg(f"Not a valid asset: {spl[1]}")
                    return
                providers = spl[3].split(",")
                currency = spl[2]
                c = caller.get_all_public_ads(
                    assets=[asset], currencies=[currency], providers=providers
                )
                c.addCallback(GenericCommands.pubads.got_pubads, currency, msg)

    class cheat(object):
        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, asset_list, caller):
            if length == 1:
                caller.run_cheat_in_thread()
                msg("Running cheat in thread.")
            elif length == 2:
                asset = spl[1]
                if asset not in loads(asset_list):
                    msg(f"Not a valid asset: {spl[1]}")
                    return
                caller.run_cheat_in_thread([asset])
                msg(f"Running cheat in thread for {asset}.")

    class cheatnext(object):
        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, caller):
            if length == 1:
                asset = caller.run_cheat_in_thread()
                msg(f"Running next asset for cheat in thread: {asset}")

    class ads(object):
        @staticmethod
        def got_ads(ads_output, msg):
            if not ads_output:
                msg("Could not get ads.")
                return
            for ad in ads_output:
                msg(f"({ad[0]}) {ad[1]} {ad[2]} {ad[3]} {ad[4]}")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, caller):
            c = caller.enum_ads()
            c.addCallback(GenericCommands.ads.got_ads, msg)

    class withdraw(object):
        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, caller):
            caller.withdraw_funds()

    class nuke(object):
        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, caller):
            rtrn = caller.nuke_ads()
            msg(dumps(rtrn))

    class wallet(object):
        @staticmethod
        def got_wallet(wallet_output, msg, asset):
            if not wallet_output["success"]:
                msg(f"Error getting {asset} wallet details.")
                return
            if not wallet_output["response"]:
                msg(f"Error getting {asset} wallet details.")
                return
            balance = wallet_output["response"]["data"]["total"]["balance"]
            msg(f"{asset} wallet balance: {balance}")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux, xmr, caller):
            if xmr:
                rtrn_xmr = caller.wallet_balance_xmr()
                rtrn_xmr.addCallback(GenericCommands.wallet.got_wallet, msg, "XMR")

            else:
                rtrn_btc = caller.wallet_balance()
                rtrn_btc.addCallback(GenericCommands.wallet.got_wallet, msg, "BTC")


class IRCCommands(object):
    class atrades(object):
        authed = True
        name = "atrades"
        helptext = "Get all open trades for Agora."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.trades.run(
                cmd, spl, length, authed, msg, agora, tx, ux, agora
            )

    class ltrades(object):
        authed = True
        name = "ltrades"
        helptext = "Get all open trades for LBTC."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.trades.run(
                cmd, spl, length, authed, msg, agora, tx, ux, tx.lbtc
            )

    class acreate(object):
        name = "acreate"
        authed = True
        helptext = "Create an ad on Agora. Usage: acreate <XMR/BTC> <country> <currency> [<provider>]"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.create.run(
                cmd,
                spl,
                length,
                authed,
                msg,
                agora,
                tx,
                ux,
                settings.Agora.AssetList,
                settings.Agora.ProviderList,
                agora,
            )

    class lcreate(object):
        name = "lcreate"
        authed = True
        helptext = "Create an ad on LBTC. Usage: lcreate <XMR/BTC> <country> <currency> [<provider>]"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.create.run(
                cmd,
                spl,
                length,
                authed,
                msg,
                agora,
                tx,
                ux,
                settings.LocalBitcoins.AssetList,
                settings.LocalBitcoins.ProviderList,
                tx.lbtc,
            )

    class amessages(object):
        authed = True
        name = "amessages"
        helptext = "Get messages for Agora. Usage: amessages [<reference>]"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.messages.run(
                cmd, spl, length, authed, msg, agora, tx, ux, agora
            )

    class lmessages(object):
        authed = True
        name = "lmessages"
        helptext = "Get messages for LBTC. Usage: lmessages [<reference>]"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.messages.run(
                cmd, spl, length, authed, msg, agora, tx, ux, tx.lbtc
            )

    class adist(object):
        authed = True
        name = "adist"
        helptext = "Distribute all our chosen currency and country ad pairs for Agora. Usage: adist [<XMR/BTC>]"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.dist.run(
                cmd,
                spl,
                length,
                authed,
                msg,
                agora,
                tx,
                ux,
                settings.Agora.AssetList,
                agora,
            )

    class ldist(object):
        authed = True
        name = "ldist"
        helptext = "Distribute all our chosen currency and country ad pairs for LBTC. Usage: ldist [<XMR/BTC>]"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.dist.run(
                cmd,
                spl,
                length,
                authed,
                msg,
                agora,
                tx,
                ux,
                settings.LocalBitcoins.AssetList,
                tx.lbtc,
            )

    class aredist(object):
        authed = True
        name = "aredist"
        helptext = "Update all ads with details for Agora."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.redist.run(
                cmd, spl, length, authed, msg, agora, tx, ux, agora
            )

    class lredist(object):
        authed = True
        name = "lredist"
        helptext = "Update all ads with details for LBTC."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.redist.run(
                cmd, spl, length, authed, msg, agora, tx, ux, tx.lbtc
            )

    class astripdupes(object):
        authed = True
        name = "astripdupes"
        helptext = "Remove all duplicate adverts for Agora."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.stripdupes.run(
                cmd, spl, length, authed, msg, agora, tx, ux, agora
            )

    class lstripdupes(object):
        authed = True
        name = "lstripdupes"
        helptext = "Remove all duplicate adverts for LBTC."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.stripdupes.run(
                cmd, spl, length, authed, msg, agora, tx, ux, tx.lbtc
            )

    class total(object):
        name = "total"
        authed = True
        helptext = "Get total account balance from Sinks and Agora."

        @staticmethod
        def got_total(total_output, msg):
            if not total_output:
                msg("Error getting total output")
                return
            totals = total_output[0]
            wallets = total_output[1]
            msg(f"Totals: SEK: {totals[0]} | USD: {totals[1]} | GBP: {totals[2]}")
            msg(f"Wallets: XMR USD: {wallets[0]} | BTC USD: {wallets[1]}")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            totals_all = tx.money.get_total()
            totals_all.addCallback(IRCCommands.total.got_total, msg)

    class ping(object):
        name = "ping"
        authed = False
        helptext = "Pong!"

        @staticmethod
        def run(cmd, spl, length, authed, msg):
            msg("Pong!")

    class summon(object):
        name = "summon"
        authed = True
        helptext = "Summon all operators."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            ux.notify.sendmsg("You have been summoned!")

    class amessage(object):
        authed = True
        name = "amsg"
        helptext = "Send a message on a trade. Usage: amsg <reference> <message...>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.message.run(
                cmd, spl, length, authed, msg, agora, tx, ux, agora.agora
            )

    class lmessage(object):
        authed = True
        name = "lmsg"
        helptext = "Send a message on a trade. Usage: lmsg <reference> <message...>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.message.run(
                cmd, spl, length, authed, msg, agora, tx, ux, tx.lbtc.lbtc
            )

    class refs(object):
        name = "refs"
        authed = True
        helptext = "List all references"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            msg(f"References: {', '.join(db.get_refs())}")

    class ref(object):
        name = "ref"
        authed = True
        helptext = "Get more information about a reference. Usage: ref <reference>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                ref_data = db.get_ref(spl[1])
                if not ref_data:
                    msg(f"No such reference: {spl[1]}")
                    return
                msg(f"{spl[1]}: {dumps(ref_data)}")

    class delete(object):
        name = "del"
        authed = True
        helptext = "Delete a reference. Usage: del <reference>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                ref_data = db.get_ref(spl[1])
                if not ref_data:
                    msg(f"No such reference: {spl[1]}")
                    return
                db.del_ref(spl[1])
                msg(f"Deleted reference: {spl[1]}")

    class arelease(object):
        authed = True
        name = "arelease"
        helptext = "Release funds for a trade. Usage: arelease <reference>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.release.run(
                cmd, spl, length, authed, msg, agora, tx, ux, agora
            )

    class lrelease(object):
        authed = True
        name = "lrelease"
        helptext = "Release funds for a trade. Usage: lrelease <reference>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.release.run(
                cmd, spl, length, authed, msg, agora, tx, ux, tx.lbtc
            )

    class map(object):
        name = "map"
        authed = True
        helptext = "Release funds for a trade. Usage: map <reference> <txid>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 3:
                reference = spl[1]
                txid = spl[2]
                is_released = tx.release_map_trade(reference, txid)
                if is_released is None:
                    msg("Trade or TX invalid")
                    return
                elif is_released is True:
                    msg("Trade released")
                    return
                elif is_released is False:
                    msg("Could not release trade")
                    return

    class anuke(object):
        authed = True
        name = "anuke"
        helptext = "Delete all our adverts for Agora."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.nuke.run(
                cmd, spl, length, authed, msg, agora, tx, ux, agora
            )

    class lnuke(object):
        authed = True
        name = "lnuke"
        helptext = "Delete all our adverts for Agora."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.nuke.run(
                cmd, spl, length, authed, msg, agora, tx, ux, tx.lbtc
            )

    class awallet(object):
        authed = True
        name = "awallet"
        helptext = "Get Agora wallet balances."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.wallet.run(
                cmd, spl, length, authed, msg, agora, tx, ux, True, agora.api
            )

    class lwallet(object):
        authed = True
        name = "lwallet"
        helptext = "Get LBTC wallet balances."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.wallet.run(
                cmd, spl, length, authed, msg, agora, tx, ux, False, tx.lbtc.api
            )

    class apubads(object):
        authed = True
        name = "apubads"
        helptext = "View public adverts for Agora. Usage: apubads <XMR/BTC> <currency> [<provider,...>]"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.pubads.run(
                cmd,
                spl,
                length,
                authed,
                msg,
                agora,
                tx,
                ux,
                settings.Agora.AssetList,
                agora,
            )

    class lpubads(object):
        authed = True
        name = "lpubads"
        helptext = "View public adverts for LBTC. Usage: lpubads <XMR/BTC> <currency> [<provider,...>]"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.pubads.run(
                cmd,
                spl,
                length,
                authed,
                msg,
                agora,
                tx,
                ux,
                settings.LocalBitcoins.AssetList,
                tx.lbtc,
            )

    class acheat(object):
        authed = True
        name = "acheat"
        helptext = "Cheat the markets by manipulating our prices to exploit people on Agora. Usage: acheat [<XMR/BTC>]"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.cheat.run(
                cmd,
                spl,
                length,
                authed,
                msg,
                agora,
                tx,
                ux,
                settings.Agora.AssetList,
                agora,
            )

    class lcheat(object):
        authed = True
        name = "lcheat"
        helptext = "Cheat the markets by manipulating our prices to exploit people on LBTC. Usage: lcheat [<XMR/BTC>]"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.cheat.run(
                cmd,
                spl,
                length,
                authed,
                msg,
                agora,
                tx,
                ux,
                settings.LocalBitcoins.AssetList,
                tx.lbtc,
            )

    class acheatnext(object):
        authed = True
        name = "acheatnext"
        helptext = "Run the next currency for cheat on Agora."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.cheatnext.run(
                cmd, spl, length, authed, msg, agora, tx, ux, agora
            )

    class lcheatnext(object):
        authed = True
        name = "lcheatnext"
        helptext = "Run the next currency for cheat on LBTC."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.cheatnext.run(
                cmd, spl, length, authed, msg, agora, tx, ux, tx.lbtc
            )

    class aads(object):
        authed = True
        name = "aads"
        helptext = "Get all our ad regions for Agora."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.ads.run(cmd, spl, length, authed, msg, agora, tx, ux, agora)

    class lads(object):
        authed = True
        name = "lads"
        helptext = "Get all our ad regions for LBTC."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.ads.run(
                cmd, spl, length, authed, msg, agora, tx, ux, tx.lbtc
            )

    class xmr(object):
        name = "xmr"
        authed = True
        helptext = "Get current XMR price."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            xmr_prices = agora.money.cg.get_price(
                ids="monero", vs_currencies=["sek", "usd", "gbp"]
            )
            price_sek = xmr_prices["monero"]["sek"]
            price_usd = xmr_prices["monero"]["usd"]
            price_gbp = xmr_prices["monero"]["gbp"]
            msg(f"SEK: {price_sek} | USD: {price_usd} | GBP: {price_gbp}")

    class btc(object):
        name = "btc"
        authed = True
        helptext = "Get current BTC price."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            xmr_prices = agora.money.cg.get_price(
                ids="bitcoin", vs_currencies=["sek", "usd", "gbp"]
            )
            price_sek = xmr_prices["bitcoin"]["sek"]
            price_usd = xmr_prices["bitcoin"]["usd"]
            price_gbp = xmr_prices["bitcoin"]["gbp"]
            msg(f"SEK: {price_sek} | USD: {price_usd} | GBP: {price_gbp}")

    class awithdraw(object):
        authed = True
        name = "awithdraw"
        helptext = "Take profit for Agora."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.withdraw.run(
                cmd, spl, length, authed, msg, agora, tx, ux, agora
            )

    class lwithdraw(object):
        authed = True
        name = "lwithdraw"
        helptext = "Take profit for LBTC."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            GenericCommands.withdraw.run(
                cmd, spl, length, authed, msg, agora, tx, ux, tx.lbtc
            )

    class remaining(object):
        name = "r"
        authed = True
        helptext = "Show how much is left before we are able to withdraw funds."

        @staticmethod
        def got_remaining(data_remaining, msg):
            msg(f"Remaining: {data_remaining}USD")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            remaining = tx.money.get_remaining()
            remaining.addCallback(IRCCommands.remaining.got_remaining, msg)

    class total_remaining(object):
        name = "tr"
        authed = True
        helptext = "Show how much is left before we are able to withdraw funds (including open trades)."

        @staticmethod
        def got_total_remaining(data_remaining, msg):
            msg(f"Total remaining: {data_remaining}USD")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            remaining = tx.money.get_total_remaining()
            remaining.addCallback(IRCCommands.total_remaining.got_total_remaining, msg)

    class tradetotal(object):
        name = "tradetotal"
        authed = True
        helptext = "Get total value of all open trades in USD."

        @staticmethod
        def got_tradetotal(data_tradetotal, msg):
            msg(f"Total trades: {data_tradetotal}USD")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            total = tx.money.get_open_trades_usd()
            total.addCallback(IRCCommands.tradetotal.got_tradetotal, msg)

    class dollar(object):
        name = "$"
        authed = True
        helptext = "Get total value of everything, including open trades."

        @staticmethod
        def got_dollar(data_dollar, msg):
            msg(f"${data_dollar}")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            total = tx.money.get_total_with_trades()
            total.addCallback(IRCCommands.dollar.got_dollar, msg)

    class profit(object):
        name = "profit"
        authed = True
        helptext = "Get total profit."

        @staticmethod
        def got_profit(data_profit, msg):
            msg(f"Profit: {data_profit}USD")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            total = tx.money.get_profit()
            total.addCallback(IRCCommands.profit.got_profit, msg)

    class tprofit(object):
        name = "tprofit"
        authed = True
        helptext = "Get total profit with open trades."

        @staticmethod
        def got_tprofit(data_tprofit, msg):
            msg(f"Total profit: {data_tprofit}USD")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            total = tx.money.get_profit(True)
            total.addCallback(IRCCommands.tprofit.got_tprofit, msg)

    class signin(object):
        name = "signin"
        authed = True
        helptext = "Generate a TrueLayer signin URL. Usage: signin <account>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                account = spl[1]
                auth_url = tx.sinks.truelayer.create_auth_url(account)
                msg(f"Auth URL for {account}: {auth_url}")

    class nsignin(object):
        name = "nsignin"
        authed = True
        helptext = "Generate a Nordigen signin URL. Usage: nsignin <country> <bank>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length >= 3:
                country = spl[1]
                bank_name = " ".join(spl[2:])
                auth_url = tx.sinks.nordigen.create_auth_url(country, bank_name)
                if not auth_url:
                    msg("Could not find bank.")
                    return
                msg(f"Auth URL for {bank_name}: {auth_url}")

    class accounts(object):
        name = "accounts"
        authed = True
        helptext = "Get a list of acccounts from TrueLayer. Usage: accounts <account>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                account = spl[1]
                accounts = tx.sinks.truelayer.get_accounts(account)
                for account in accounts["results"]:
                    msg(
                        f"{account['account_id']} {account['display_name']} {account['currency']}"
                    )

    class naccounts(object):
        name = "naccounts"
        authed = True
        helptext = "Get a list of acccounts from Nordigen. Usage: naccounts"

        @staticmethod
        def got_accounts(accounts, msg):
            for name, accounts in accounts.items():
                for account in accounts:
                    msg(dumps(account))

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 1:
                accounts = tx.sinks.nordigen.get_all_account_info()
                accounts.addCallback(IRCCommands.naccounts.got_accounts, msg)

    class transactions(object):
        name = "transactions"
        authed = True
        helptext = "Get a list of transactions from TrueLayer. Usage: transactions <account> <account_id>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 3:
                account = spl[1]
                account_id = spl[2]
                transactions = tx.sinks.truelayer.get_transactions(account, account_id)
                for transaction in transactions:
                    txid = transaction["transaction_id"]
                    # ptxid = transaction["meta"]["provider_transaction_id"]
                    txtype = transaction["transaction_type"]
                    timestamp = transaction["timestamp"]
                    amount = transaction["amount"]
                    currency = transaction["currency"]
                    description = transaction["description"]
                    msg(f"{timestamp} {txid} {txtype} {amount}{currency} {description}")

    class ntransactions(object):
        name = "ntransactions"
        authed = True
        helptext = "Get a list of transactions from Nordigen. Usage: ntransactions <account_id>"

        @staticmethod
        def got_transactions(transactions, msg):
            for transaction in transactions:
                if "transaction_id" in transaction:
                    txid = transaction["transaction_id"]
                else:
                    txid = "not_set"
                timestamp = transaction["timestamp"]
                amount = transaction["amount"]
                currency = transaction["currency"]
                reference = transaction["reference"]
                msg(f"{timestamp} {txid} {amount}{currency} {reference}")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                account_id = spl[1]
                transactions = tx.sinks.nordigen.get_transactions(account_id)
                transactions.addCallback(
                    IRCCommands.ntransactions.got_transactions, msg
                )

    class nreqs(object):
        name = "nreqs"
        authed = True
        helptext = "Get a list of requisitions from Nordigen."

        @staticmethod
        def got_requisitions(reqs, msg):
            for req in reqs:
                id = req["id"]
                institution_id = req["institution_id"]
                redirect = req["link"]
                msg(f"{id} {institution_id} {redirect}")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            reqs = tx.sinks.nordigen.get_requisitions()
            reqs.addCallback(IRCCommands.nreqs.got_requisitions, msg)

    class ndelreq(object):
        name = "ndelreq"
        authed = True
        helptext = "Delete a requisition from Nordigen."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                requisition_id = spl[1]
                rtrn = tx.sinks.nordigen.delete_requisition(requisition_id)
                msg(f"{rtrn['summary']}")

    class mapaccount(object):
        name = "mapaccount"
        authed = True
        helptext = "Enable an account_id at a bank for use in TrueLayer. Usage: mapaccount <bank> <account_id>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 3:
                bank = spl[1]
                account_id = spl[2]
                account_name = tx.sinks.truelayer.map_account(bank, account_id)
                if not account_name:
                    msg("Failed to map the account")
                    return
                msg(f"Mapped account ID {account_id} at bank {bank} to {account_name}")

    class nmapaccount(object):
        name = "nmapaccount"
        authed = True
        helptext = "Enable an account_id at a bank for use in Nordigen. Usage: nmapaccount <account_id>"

        @staticmethod
        def got_map_account(account_name, account_id, msg):
            if not account_name:
                msg("Failed to map the account")
                return
            msg(f"Mapped account ID {account_id} to {account_name}")

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                account_id = spl[1]
                c = tx.sinks.nordigen.map_account(account_id)
                c.addCallback(IRCCommands.nmapaccount.got_map_account, account_id, msg)

    class nunmapaccount(object):
        name = "nunmapaccount"
        authed = True
        helptext = "Disable an account_id at a bank for use in Nordigen. Usage: nunmapaccount <account_id>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                account_id = spl[1]
                tx.sinks.nordigen.unmap_account(account_id)
                msg(f"Unmapped account ID {account_id}")

    class unmapped(object):
        name = "unmapped"
        authed = True
        helptext = "Get unmapped accounts for a bank. Usage: unmapped <bank>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                bank = spl[1]
                accounts_active = []
                for bank, accounts in tx.sinks.truelayer.banks.items():
                    for account in accounts:
                        accounts_active.append(account)
                accounts_all = tx.sinks.truelayer.get_accounts(bank)
                accounts_unmapped = [
                    x["account_id"]
                    for x in accounts_all["results"]
                    if x["account_id"] not in accounts_active
                ]
                msg(f"Unmapped accounts: {', '.join(accounts_unmapped)}")

    class distdetails(object):
        name = "distdetails"
        authed = True
        helptext = "Distribute account details among all ads."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            currencies = tx.sinks.currencies
            tx.markets.distribute_account_details()
            msg(f"Distributing account details for currencies: {', '.join(currencies)}")

    class authlink(object):
        name = "authlink"
        authed = True
        helptext = (
            "Create a URL for identity verification. Usage: authlink <identifier>"
        )

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                identifier = spl[1]
                auth_url = ux.verify.create_applicant_and_get_link(identifier)
                msg(f"Verification URL: {auth_url}")

    class checkauth(object):
        name = "checkauth"
        authed = True
        helptext = (
            "Check the authentication for an identifier. Usage: checkauth <identifier>"
        )

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 2:
                identifier = spl[1]
                verified = ux.verify.get_external_user_id_status(identifier)
                msg(f"Verification status: {verified}")

    class bankdetails(object):
        name = "bankdetails"
        authed = True
        helptext = "Get the bank details for a platform. Usage: bankdetails <platform> <currency>"

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 3:
                platform = spl[1]
                currency = spl[2]
                account_info = tx.markets.get_matching_account_details(
                    platform, currency
                )
                bank_details = tx.markets.format_payment_details(
                    currency, account_info, real=True
                )
                if not bank_details:
                    msg("Could not get bank details.")
                    return
                msg(bank_details)

    class id(object):
        name = "id"
        authed = True
        helptext = (
            "Get the identity information of a user. Usage: id <platform> <username>"
        )

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            if length == 3:
                platform = spl[1]
                username = spl[2]
                uid = tx.ux.verify.create_uid(platform, username)
                first, last = tx.ux.verify.get_external_user_id_details(uid)
                msg(f"Name: {first} {last}")

    class balance(object):
        name = "balance"
        authed = True
        helptext = "Get the total balance of all fiat accounts."

        @staticmethod
        def run(cmd, spl, length, authed, msg, agora, tx, ux):
            total = ux.sinks.get_total_usd()
            msg(f"Fiat balance (USD): {total}")