You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
412 lines
16 KiB
Python
412 lines
16 KiB
Python
# Other library imports
|
|
from json import loads
|
|
|
|
import db
|
|
import util
|
|
|
|
# Project imports
|
|
from settings import settings
|
|
|
|
|
|
class Markets(util.Base):
|
|
""" "
|
|
Markets handler for generic market functions.
|
|
"""
|
|
|
|
def find_trades_by_uid(self, uid):
|
|
"""
|
|
Find a list of trade IDs and references by a customer UID.
|
|
:return: tuple of (platform, trade_id, reference, currency)
|
|
"""
|
|
platform, username = self.ux.verify.get_uid(uid)
|
|
refs = db.get_refs()
|
|
matching_trades = []
|
|
for reference in refs:
|
|
ref_data = db.get_ref(reference)
|
|
tx_platform = ref_data["subclass"]
|
|
tx_username = ref_data["buyer"]
|
|
trade_id = ref_data["id"]
|
|
currency = ref_data["currency"]
|
|
if tx_platform == platform and tx_username == username:
|
|
to_append = (platform, trade_id, reference, currency)
|
|
matching_trades.append(to_append)
|
|
return matching_trades
|
|
|
|
def get_send_settings(self, platform):
|
|
if platform == "agora":
|
|
send_setting = settings.Agora.Send
|
|
post_message = self.agora.api.contact_message_post
|
|
elif platform == "lbtc":
|
|
send_setting = settings.LocalBitcoins.Send
|
|
post_message = self.lbtc.api.contact_message_post
|
|
|
|
return (send_setting, post_message)
|
|
|
|
def send_reference(self, platform, trade_id, reference):
|
|
"""
|
|
Send the reference to a customer.
|
|
"""
|
|
send_setting, post_message = self.get_send_settings(platform)
|
|
if send_setting == "1":
|
|
post_message(
|
|
trade_id,
|
|
f"When sending the payment please use reference code: {reference}",
|
|
)
|
|
|
|
def send_bank_details(self, platform, currency, trade_id):
|
|
"""
|
|
Send the bank details to a trade.
|
|
"""
|
|
send_setting, post_message = self.get_send_settings(platform)
|
|
self.log.info(f"Sending bank details/reference for {platform}/{trade_id}")
|
|
if send_setting == "1":
|
|
account_info = self.get_matching_account_details(platform, currency)
|
|
formatted_account_info = self.format_payment_details(
|
|
currency, account_info, real=True
|
|
)
|
|
if not formatted_account_info:
|
|
self.log.error(f"Payment info invalid: {formatted_account_info}")
|
|
return
|
|
post_message(
|
|
trade_id,
|
|
f"Payment details: \n{formatted_account_info}",
|
|
)
|
|
|
|
def get_all_assets(self, platform):
|
|
sets = util.get_settings(platform)
|
|
assets = loads(sets.AssetList)
|
|
return assets
|
|
|
|
def get_all_providers(self, platform):
|
|
sets = util.get_settings(platform)
|
|
providers = loads(sets.ProviderList)
|
|
return providers
|
|
|
|
def get_all_currencies(self, platform):
|
|
sets = util.get_settings(platform)
|
|
currencies = list(set([x[0] for x in loads(sets.DistList)]))
|
|
return currencies
|
|
|
|
def get_new_ad_equations(self, platform, public_ads, assets=None):
|
|
"""
|
|
Update all our prices.
|
|
:param public_ads: dictionary of public ads keyed by currency
|
|
:type public_ads: dict
|
|
:return: list of ads to modify
|
|
:rtype: list
|
|
"""
|
|
sets = util.get_settings(platform)
|
|
username = sets.Username
|
|
min_margin = sets.MinMargin
|
|
max_margin = sets.MaxMargin
|
|
|
|
to_update = []
|
|
|
|
# NOTES:
|
|
# Get all ads for each currency, with all the payment methods.
|
|
# Create a function to, in turn, filter these so it contains only one payment method. Run autoprice on this.
|
|
# Append all results to to_update. Repeat for remaining payment methods, then call slow update.
|
|
|
|
# (asset, currency, provider)
|
|
if not assets:
|
|
assets = self.get_all_assets(platform)
|
|
currencies = self.get_all_currencies(platform)
|
|
providers = self.get_all_providers(platform)
|
|
if platform == "lbtc":
|
|
providers = [
|
|
self.sources.lbtc.map_provider(x, reverse=True) for x in providers
|
|
]
|
|
sinks_currencies = self.sinks.currencies
|
|
supported_currencies = [
|
|
currency for currency in currencies if currency in sinks_currencies
|
|
]
|
|
currencies = supported_currencies
|
|
|
|
brute = [
|
|
(asset, currency, provider)
|
|
for asset in assets
|
|
for currency in currencies
|
|
for provider in providers
|
|
]
|
|
for asset, currency, provider in brute:
|
|
# Filter currency
|
|
try:
|
|
public_ads_currency = public_ads[currency]
|
|
except KeyError:
|
|
# self.log.error("Error getting public ads for currency {currency}", currency=currency)
|
|
if currency == "GBP":
|
|
self.log.error(
|
|
"Error getting public ads for currency GBP, aborting"
|
|
)
|
|
break
|
|
continue
|
|
# Filter asset
|
|
public_ads_filtered = [ad for ad in public_ads_currency if ad[4] == asset]
|
|
|
|
# Filter provider
|
|
public_ads_filtered = [
|
|
ad for ad in public_ads_filtered if ad[3] == provider
|
|
]
|
|
our_ads = [ad for ad in public_ads_filtered if ad[1] == username]
|
|
if not our_ads:
|
|
self.log.warning(
|
|
f"No ads found in {platform} public listing for {asset} {currency} {provider}"
|
|
)
|
|
continue
|
|
new_margin = self.autoprice(
|
|
username, min_margin, max_margin, public_ads_filtered, currency
|
|
)
|
|
# self.log.info("New rate for {currency}: {rate}", currency=currency, rate=new_margin)
|
|
if platform == "agora":
|
|
new_formula = (
|
|
f"coingecko{asset.lower()}usd*usd{currency.lower()}*{new_margin}"
|
|
)
|
|
elif platform == "lbtc":
|
|
new_formula = f"btc_in_usd*{new_margin}*USD_in_{currency}"
|
|
for ad in our_ads:
|
|
ad_id = ad[0]
|
|
asset = ad[4]
|
|
our_margin = ad[5]
|
|
if new_margin != our_margin:
|
|
to_update.append([str(ad_id), new_formula, asset, currency, False])
|
|
|
|
return to_update
|
|
|
|
def autoprice(self, username, min_margin, max_margin, ads, currency):
|
|
"""
|
|
Helper function to automatically adjust the price up/down in certain markets
|
|
in order to gain the most profits and sales.
|
|
:param ads: list of ads
|
|
:type ads: list of lists
|
|
:param currency: currency of the ads
|
|
:type currency: string
|
|
:return: the rate we should use for this currency
|
|
:rtype: float
|
|
"""
|
|
# self.log.debug("Autoprice starting for {x}", x=currency)
|
|
# Find cheapest ad
|
|
# Filter by 3rd index on each ad list to find the cheapest
|
|
min_margin_ad = min(ads, key=lambda x: x[6])
|
|
# self.log.debug("Minimum margin ad: {x}", x=min_margin_ad)
|
|
|
|
# Find second cheapest that is not us
|
|
# Remove results from ads that are us
|
|
ads_without_us = [ad for ad in ads if not ad[1] == username]
|
|
# self.log.debug("Ads without us: {x}", x=ads_without_us)
|
|
# Find ads above our min that are not us
|
|
ads_above_our_min_not_us = [
|
|
ad for ad in ads_without_us if ad[6] > float(min_margin)
|
|
]
|
|
# self.log.debug("Ads above our min not us: {x}", x=ads_above_our_min_not_us)
|
|
# Check that this list without us is not empty
|
|
if ads_without_us:
|
|
# Find the cheapest from these
|
|
min_margin_ad_not_us = min(ads_without_us, key=lambda x: x[6])
|
|
# self.log.debug("Min margin ad not us: {x}", x=min_margin_ad_not_us)
|
|
# Lowball the lowest ad that is not ours
|
|
lowball_lowest_not_ours = min_margin_ad_not_us[6] # - 0.005
|
|
# self.log.debug("Lowball lowest not ours: {x}", x=lowball_lowest_not_ours)
|
|
|
|
# Check if the username field of the cheapest ad matches ours
|
|
if min_margin_ad[1] == username:
|
|
# self.log.debug("We are the cheapest for: {x}", x=currency)
|
|
# We are the cheapest!
|
|
# Are all of the ads ours?
|
|
all_ads_ours = all([ad[1] == username for ad in ads])
|
|
if all_ads_ours:
|
|
# self.log.debug("All ads are ours for: {x}", x=currency)
|
|
# Now we know it's safe to return the maximum value
|
|
return float(max_margin)
|
|
else:
|
|
# self.log.debug("All ads are NOT ours for: {x}", x=currency)
|
|
# All the ads are not ours, but we are first...
|
|
# Check if the lowballed, lowest (that is not ours) ad's margin
|
|
# is less than our minimum
|
|
if lowball_lowest_not_ours < float(min_margin):
|
|
# self.log.debug("Lowball lowest not ours less than MinMargin")
|
|
return float(min_margin)
|
|
elif lowball_lowest_not_ours > float(max_margin):
|
|
# self.log.debug("Lowball lowest not ours more than MaxMargin")
|
|
return float(max_margin)
|
|
else:
|
|
# self.log.debug("Returning lowballed figure: {x}", x=lowball_lowest_not_ours)
|
|
return lowball_lowest_not_ours
|
|
else:
|
|
# self.log.debug("We are NOT the cheapest for: {x}", x=currency)
|
|
# We are not the cheapest :(
|
|
# Check if this list is empty
|
|
if not ads_above_our_min_not_us:
|
|
# Return the maximum margin?
|
|
return float(max_margin)
|
|
# Find cheapest ad above our min that is not us
|
|
cheapest_ad = min(ads_above_our_min_not_us, key=lambda x: x[4])
|
|
cheapest_ad_margin = cheapest_ad[6] # - 0.005
|
|
if cheapest_ad_margin > float(max_margin):
|
|
# self.log.debug("Cheapest ad not ours more than MaxMargin")
|
|
return float(max_margin)
|
|
# self.log.debug("Cheapest ad above our min that is not us: {x}", x=cheapest_ad)
|
|
return cheapest_ad_margin
|
|
|
|
def create_distribution_list(self, platform, filter_asset=None):
|
|
"""
|
|
Create a list for distribution of ads.
|
|
:return: generator of asset, countrycode, currency, provider
|
|
:rtype: generator of tuples
|
|
"""
|
|
sets = util.get_settings(platform)
|
|
|
|
# Iterate providers like REVOLUT, NATIONAL_BANK
|
|
for provider in loads(sets.ProviderList):
|
|
# Iterate assets like XMR, BTC
|
|
for asset in loads(sets.AssetList):
|
|
# Iterate pairs of currency and country like EUR, GB
|
|
for currency, countrycode in loads(sets.DistList):
|
|
if filter_asset:
|
|
if asset == filter_asset:
|
|
yield (asset, countrycode, currency, provider)
|
|
else:
|
|
yield (asset, countrycode, currency, provider)
|
|
|
|
def get_valid_account_details(self, platform):
|
|
currencies = self.sinks.currencies
|
|
account_info = self.sinks.account_info
|
|
all_currencies = self.get_all_currencies(platform)
|
|
supported_currencies = [
|
|
currency for currency in currencies if currency in all_currencies
|
|
]
|
|
currency_account_info_map = {}
|
|
for currency in supported_currencies:
|
|
for bank, accounts in account_info.items():
|
|
for account in accounts:
|
|
if account["currency"] == currency:
|
|
currency_account_info_map[currency] = account["account_number"]
|
|
currency_account_info_map[currency]["bank"] = bank.split("_")[0]
|
|
currency_account_info_map[currency]["recipient"] = account[
|
|
"recipient"
|
|
]
|
|
return (supported_currencies, currency_account_info_map)
|
|
|
|
def get_matching_account_details(self, platform, currency):
|
|
(
|
|
supported_currencies,
|
|
currency_account_info_map,
|
|
) = self.get_valid_account_details(platform)
|
|
if currency not in supported_currencies:
|
|
return False
|
|
return currency_account_info_map[currency]
|
|
|
|
def _distribute_account_details(self, platform, currencies=None, account_info=None):
|
|
"""
|
|
Distribute account details for ads.
|
|
We will disable ads we can't support.
|
|
"""
|
|
if platform == "agora":
|
|
caller = self.agora
|
|
elif platform == "lbtc":
|
|
caller = self.lbtc
|
|
|
|
if not currencies:
|
|
currencies = self.sinks.currencies
|
|
if not account_info:
|
|
account_info = self.sinks.account_info
|
|
(
|
|
supported_currencies,
|
|
currency_account_info_map,
|
|
) = self.get_valid_account_details(platform)
|
|
|
|
# not_supported = [currency for currency in all_currencies if currency not in supported_currencies]
|
|
|
|
our_ads = caller.enum_ads()
|
|
|
|
supported_ads = [ad for ad in our_ads if ad[3] in supported_currencies]
|
|
|
|
not_supported_ads = [ad for ad in our_ads if ad[3] not in supported_currencies]
|
|
|
|
for ad in supported_ads:
|
|
asset = ad[0]
|
|
countrycode = ad[2]
|
|
currency = ad[3]
|
|
provider = ad[4]
|
|
payment_details = currency_account_info_map[currency]
|
|
ad_id = ad[1]
|
|
caller.create_ad(
|
|
asset,
|
|
countrycode,
|
|
currency,
|
|
provider,
|
|
payment_details,
|
|
visible=True,
|
|
edit=True,
|
|
ad_id=ad_id,
|
|
)
|
|
|
|
for ad in not_supported_ads:
|
|
asset = ad[0]
|
|
countrycode = ad[2]
|
|
currency = ad[3]
|
|
provider = ad[4]
|
|
ad_id = ad[1]
|
|
caller.create_ad(
|
|
asset,
|
|
countrycode,
|
|
currency,
|
|
provider,
|
|
payment_details=False,
|
|
visible=False,
|
|
edit=True,
|
|
ad_id=ad_id,
|
|
)
|
|
|
|
def distribute_account_details(self, currencies=None, account_info=None):
|
|
"""
|
|
Helper to distribute the account details for all platforms.
|
|
"""
|
|
platforms = ("agora", "lbtc")
|
|
for platform in platforms:
|
|
self._distribute_account_details(
|
|
platform, currencies=currencies, account_info=account_info
|
|
)
|
|
|
|
def format_ad(self, asset, currency, payment_details_text):
|
|
"""
|
|
Format the ad.
|
|
"""
|
|
ad = settings.Platform.Ad
|
|
|
|
# Substitute the currency
|
|
ad = ad.replace("$CURRENCY$", currency)
|
|
|
|
# Substitute the asset
|
|
ad = ad.replace("$ASSET$", asset)
|
|
|
|
# Substitute the payment details
|
|
ad = ad.replace("$PAYMENT$", payment_details_text)
|
|
|
|
# Strip extra tabs
|
|
ad = ad.replace("\\t", "\t")
|
|
return ad
|
|
|
|
def format_payment_details(self, currency, payment_details, real=False):
|
|
"""
|
|
Format the payment details.
|
|
"""
|
|
if not payment_details:
|
|
return False
|
|
if real:
|
|
payment = settings.Platform.PaymentDetailsReal
|
|
else:
|
|
payment = settings.Platform.PaymentDetails
|
|
|
|
payment_text = ""
|
|
for field, value in payment_details.items():
|
|
formatted_name = field.replace("_", " ")
|
|
formatted_name = formatted_name.capitalize()
|
|
payment_text += f"* {formatted_name}: **{value}**"
|
|
if field != list(payment_details.keys())[-1]: # No trailing newline
|
|
payment_text += "\n"
|
|
|
|
payment = payment.replace("$PAYMENT$", payment_text)
|
|
payment = payment.replace("$CURRENCY$", currency)
|
|
|
|
return payment
|