369 lines
14 KiB
Python
369 lines
14 KiB
Python
from abc import ABC
|
|
|
|
from core.lib import db, notify
|
|
|
|
# from core.lib.money import money
|
|
from core.util import logs
|
|
|
|
log = logs.get_logger("aggregator")
|
|
|
|
|
|
class AggregatorClient(ABC):
|
|
def store_account_info(self, account_infos):
|
|
# account_infos = {
|
|
# bank: accounts
|
|
# for bank, accounts in account_info.items()
|
|
# for account in accounts
|
|
# #if account["account_id"] in self.banks
|
|
# }
|
|
# For each bank
|
|
for bank, accounts in account_infos.items():
|
|
# Iterate the accounts
|
|
for index, account in enumerate(list(accounts)):
|
|
if "account_number" not in account:
|
|
account_infos[bank][index]["account_number"] = {}
|
|
fields = ["sort_code", "number", "iban"]
|
|
for field in fields:
|
|
if field in account:
|
|
account_infos[bank][index]["account_number"][
|
|
field
|
|
] = account[field]
|
|
del account_infos[bank][index][field]
|
|
# if len(account["account_number"]) == 1:
|
|
# account_infos[bank].remove(account)
|
|
currencies = [
|
|
account["currency"]
|
|
for bank, accounts in account_infos.items()
|
|
for account in accounts
|
|
]
|
|
for bank, accounts in account_infos.items():
|
|
if not self.instance.account_info:
|
|
self.instance.account_info = {}
|
|
self.instance.account_info[bank] = []
|
|
for account in accounts:
|
|
self.instance.account_info[bank].append(account)
|
|
# self.account_info = account_infos
|
|
self.currencies = currencies
|
|
|
|
self.instance.currencies = currencies
|
|
self.instance.save()
|
|
|
|
async def process_transactions(self, account_id, transactions):
|
|
if not transactions:
|
|
return False
|
|
transaction_ids = [x["transaction_id"] for x in transactions]
|
|
new_key_name = f"new.transactions.{self.instance.id}.{self.name}.{account_id}"
|
|
old_key_name = f"transactions.{self.instance.id}.{self.name}.{account_id}"
|
|
# for transaction_id in transaction_ids:
|
|
if not transaction_ids:
|
|
return
|
|
db.r.sadd(new_key_name, *transaction_ids)
|
|
|
|
difference = list(db.r.sdiff(new_key_name, old_key_name))
|
|
|
|
difference = db.convert(difference)
|
|
|
|
new_transactions = [
|
|
x for x in transactions if x["transaction_id"] in difference
|
|
]
|
|
|
|
# Rename the new key to the old key so we can run the diff again
|
|
db.r.rename(new_key_name, old_key_name)
|
|
for transaction in new_transactions:
|
|
transaction["subclass"] = self.name
|
|
# self.tx.transaction(transaction)
|
|
|
|
def valid_transaction(self, data):
|
|
"""
|
|
Determine if a given transaction object is valid.
|
|
:param data: a transaction cast
|
|
:type data: dict
|
|
:return: whether the transaction is valid
|
|
:rtype: bool
|
|
"""
|
|
txid = data["transaction_id"]
|
|
if "amount" not in data:
|
|
return False
|
|
if "currency" not in data:
|
|
return False
|
|
amount = data["amount"]
|
|
if amount <= 0:
|
|
log.info(f"Ignoring transaction with negative/zero amount: {txid}")
|
|
return False
|
|
return True
|
|
|
|
def extract_reference(self, data):
|
|
"""
|
|
Extract a reference from the transaction cast.
|
|
:param data: a transaction cast
|
|
:type data: dict
|
|
:return: the extracted reference or not_set
|
|
:rtype: str
|
|
"""
|
|
if "reference" in data:
|
|
return data["reference"]
|
|
elif "meta" in data:
|
|
if "provider_reference" in data["meta"]:
|
|
return data["meta"]["provider_reference"]
|
|
return "not_set"
|
|
|
|
def extract_sender(self, data):
|
|
"""
|
|
Extract a sender name from the transaction cast.
|
|
:param data: a transaction cast
|
|
:type data: dict
|
|
:return: the sender name or not_set
|
|
:rtype: str
|
|
"""
|
|
if "debtorName" in data:
|
|
return data["debtorName"]
|
|
elif "meta" in data:
|
|
if "debtor_account_name" in data["meta"]:
|
|
return data["meta"]["debtor_account_name"]
|
|
elif " " in data["reference"]:
|
|
refsplit = data["reference"].split(" ")
|
|
if not len(refsplit) == 2:
|
|
log.error(f"Sender cannot be extracted: {data}")
|
|
return "not_set"
|
|
realname, part2 = data["reference"].split(" ")
|
|
return realname
|
|
|
|
return "not_set"
|
|
|
|
async def reference_partial_check(self, reference, txid, currency, amount):
|
|
"""
|
|
Perform a partial check by intersecting all parts of the split of the
|
|
reference against the existing references, and returning a set of the matches.
|
|
:param reference: the reference to check
|
|
:type reference: str
|
|
:return: matching trade ID string
|
|
:rtype: str
|
|
"""
|
|
# Partial reference implementation
|
|
# Account for silly people not removing the default string
|
|
# Split the reference into parts
|
|
ref_split = reference.split(" ")
|
|
# Get all existing references
|
|
existing_refs = await db.get_refs()
|
|
# Get all parts of the given reference split that match the existing references
|
|
stored_trade_reference = set(existing_refs).intersection(set(ref_split))
|
|
if len(stored_trade_reference) > 1:
|
|
message = (
|
|
f"Multiple references valid for TXID {txid}: {reference}"
|
|
f"Currency: {currency} | Amount: {amount}"
|
|
)
|
|
title = "Error: multiple references valid"
|
|
await notify.sendmsg(self.instance.user, message, title=title)
|
|
return False
|
|
if len(stored_trade_reference) == 0:
|
|
return None
|
|
return stored_trade_reference.pop()
|
|
|
|
async def can_alt_lookup(self, amount, currency, reference):
|
|
amount_usd = self.money.to_usd(amount, currency)
|
|
# Amount is reliable here as it is checked by find_trade,
|
|
# so no need for stored_trade["amount"]
|
|
if float(amount_usd) > float(settings.Agora.AcceptableAltLookupUSD):
|
|
message = (
|
|
f"Amount exceeds max for {reference}"
|
|
f"Currency: {currency} | Amount: {amount}"
|
|
)
|
|
title = "Amount exceeds max for {reference}"
|
|
await notify.sendmsg(self.instance.user, message, title=title)
|
|
return False
|
|
return True
|
|
|
|
async def amount_currency_lookup(self, amount, currency, txid, reference):
|
|
log.info(f"No reference in DB refs for {reference}")
|
|
self.irc.sendmsg(f"No reference in DB refs for {reference}")
|
|
# Try checking just amount and currency, as some people
|
|
# (usually people buying small amounts)
|
|
# are unable to put in a reference properly.
|
|
|
|
log.info(f"Checking against amount and currency for TXID {txid}")
|
|
self.irc.sendmsg(f"Checking against amount and currency for TXID {txid}")
|
|
title = f"Checking against amount and currency for TXID {txid}"
|
|
message = (
|
|
f"Checking against amount and currency for TXID {txid}"
|
|
f"Currency: {currency} | Amount: {amount}"
|
|
)
|
|
await notify.sendmsg(self.instance.user, message, title=title)
|
|
if not await self.can_alt_lookup(amount, currency, reference):
|
|
return False
|
|
stored_trade = await self.find_trade(txid, currency, amount)
|
|
if not stored_trade:
|
|
title = f"Failed to get reference by amount and currency: {txid}"
|
|
message = (
|
|
f"Failed to get reference by amount and currency: {txid}"
|
|
f"Currency: {currency} | Amount: {amount}"
|
|
)
|
|
await notify.sendmsg(self.instance.user, message, title=title)
|
|
return None
|
|
stored_trade["amount"] = float(stored_trade["amount"]) # convert to float
|
|
return stored_trade
|
|
|
|
async def normal_lookup(self, stored_trade_reference, reference, currency, amount):
|
|
stored_trade = await db.get_ref(stored_trade_reference)
|
|
if not stored_trade:
|
|
title = f"No reference in DB for {reference}"
|
|
message = (
|
|
f"No reference in DB for {reference}"
|
|
f"Currency: {currency} | Amount: {amount}"
|
|
)
|
|
await notify.sendmsg(self.instance.user, message, title=title)
|
|
return False
|
|
stored_trade["amount"] = float(stored_trade["amount"]) # convert to float
|
|
return stored_trade
|
|
|
|
async def currency_check(self, currency, amount, reference, stored_trade):
|
|
if not stored_trade["currency"] == currency:
|
|
title = "Currency mismatch"
|
|
message = (
|
|
f"Currency mismatch, Agora: {stored_trade['currency']} "
|
|
f"/ Sink: {currency}"
|
|
)
|
|
await notify.sendmsg(self.instance.user, message, title=title)
|
|
return False
|
|
return True
|
|
|
|
async def alt_amount_check(
|
|
self, platform, amount, currency, reference, stored_trade
|
|
):
|
|
# If the amount does not match exactly, get the min and max values for our
|
|
# given acceptable margins for trades
|
|
min_amount, max_amount = await self.money.get_acceptable_margins(
|
|
platform, currency, stored_trade["amount"]
|
|
)
|
|
log.info(
|
|
(
|
|
f"Amount does not match exactly, trying with margins: min: {min_amount}"
|
|
f" / max: {max_amount}"
|
|
)
|
|
)
|
|
self.irc.sendmsg()
|
|
title = "Amount does not match exactly"
|
|
message = (
|
|
f"Amount does not match exactly, trying with margins: min: "
|
|
f"{min_amount} / max: {max_amount}"
|
|
)
|
|
await notify.sendmsg(self.instance.user, message, title=title)
|
|
if not min_amount < amount < max_amount:
|
|
title = "Amount mismatch - not in margins"
|
|
message = (
|
|
f"Amount mismatch - not in margins: {stored_trade['amount']} "
|
|
f"(min: {min_amount} / max: {max_amount}"
|
|
)
|
|
await notify.sendmsg(self.instance.user, message, title=title)
|
|
return False
|
|
return True
|
|
|
|
async def transaction(self, data):
|
|
"""
|
|
Store details of transaction and post notifications to IRC.
|
|
Matches it up with data stored in Redis to attempt to reconcile with an Agora
|
|
trade.
|
|
:param data: details of transaction
|
|
:type data: dict
|
|
"""
|
|
valid = self.valid_transaction(data)
|
|
if not valid:
|
|
return False
|
|
ts = data["timestamp"]
|
|
txid = data["transaction_id"]
|
|
amount = float(data["amount"])
|
|
currency = data["currency"]
|
|
|
|
reference = self.extract_reference(data)
|
|
sender = self.extract_sender(data)
|
|
|
|
subclass = data["subclass"]
|
|
to_store = {
|
|
"subclass": subclass,
|
|
"ts": ts,
|
|
"txid": txid,
|
|
"reference": reference,
|
|
"amount": amount,
|
|
"currency": currency,
|
|
"sender": sender,
|
|
}
|
|
db.r.hmset(f"tx.{txid}", to_store)
|
|
|
|
log.info(f"Transaction processed: {dumps(to_store, indent=2)}")
|
|
self.irc.sendmsg(
|
|
(
|
|
f"AUTO Incoming transaction on {subclass}: {txid} {amount}{currency} "
|
|
f"({reference})"
|
|
)
|
|
)
|
|
|
|
stored_trade_reference = self.reference_partial_check(
|
|
reference, txid, currency, amount
|
|
)
|
|
if stored_trade_reference is False: # can be None though
|
|
return
|
|
|
|
stored_trade = False
|
|
looked_up_without_reference = False
|
|
|
|
# Normal implementation for when we have a reference
|
|
if stored_trade_reference:
|
|
stored_trade = self.normal_lookup(
|
|
stored_trade_reference, reference, currency, amount
|
|
)
|
|
# if not stored_trade:
|
|
# return
|
|
|
|
# Amount/currency lookup implementation for when we have no reference
|
|
else:
|
|
if not stored_trade: # check we don't overwrite the lookup above
|
|
stored_trade = self.amount_currency_lookup(
|
|
amount, currency, txid, reference
|
|
)
|
|
if stored_trade is False:
|
|
return
|
|
if stored_trade:
|
|
# Note that we have looked it up without reference so we don't use
|
|
# +- below
|
|
# This might be redundant given the amount checks in find_trade,
|
|
# but better safe than sorry!
|
|
looked_up_without_reference = True
|
|
else:
|
|
return
|
|
else:
|
|
# Stored trade reference is none, the checks below will do nothing
|
|
return
|
|
|
|
# Make sure it was sent in the expected currency
|
|
if not self.currency_check(currency, amount, reference, stored_trade):
|
|
return
|
|
|
|
# Make sure the expected amount was sent
|
|
if not stored_trade["amount"] == amount:
|
|
if looked_up_without_reference:
|
|
return
|
|
platform = stored_trade["subclass"]
|
|
if not self.alt_amount_check(
|
|
platform, amount, currency, reference, stored_trade
|
|
):
|
|
return
|
|
platform = stored_trade["subclass"]
|
|
platform_buyer = stored_trade["buyer"]
|
|
|
|
# Check sender - we don't do anything with this yet
|
|
# sender_valid = self.antifraud.check_valid_sender(
|
|
# reference, platform, sender, platform_buyer
|
|
# )
|
|
# log.info(f"Trade {reference} buyer {platform_buyer} valid: {sender_valid}")
|
|
# trade_released = self.release_map_trade(reference, txid)
|
|
# if trade_released:
|
|
# self.ux.notify.notify_complete_trade(amount, currency)
|
|
# else:
|
|
# log.error(f"Cannot release trade {reference}.")
|
|
# return
|
|
|
|
rtrn = await self.release_funds(stored_trade["id"], stored_trade["reference"])
|
|
if rtrn:
|
|
title = "Trade complete"
|
|
message = f"Trade complete: {amount}{currency}"
|
|
await notify.sendmsg(self.instance.user, message, title=title)
|