527 lines
22 KiB
Python
527 lines
22 KiB
Python
# Twisted/Klein imports
|
|
from twisted.logger import Logger
|
|
|
|
# Other library imports
|
|
from json import dumps
|
|
from random import choices
|
|
from string import ascii_uppercase
|
|
|
|
# Project imports
|
|
from settings import settings
|
|
from db import r
|
|
from util import convert
|
|
|
|
|
|
class Transactions(object):
|
|
"""
|
|
Handler class for incoming Revolut transactions.
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
Initialise the Transaction object.
|
|
Set the logger.
|
|
"""
|
|
self.log = Logger("transactions")
|
|
|
|
# TODO: write tests then refactor, this is terribly complicated!
|
|
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
|
|
"""
|
|
event = data["event"]
|
|
ts = data["timestamp"]
|
|
|
|
inside = data["data"]
|
|
|
|
txid = inside["id"]
|
|
|
|
if "type" not in inside:
|
|
# stored_trade here is actually TX
|
|
stored_trade = r.hgetall(f"tx.{txid}")
|
|
if not stored_trade:
|
|
self.log.error("Could not find entry in DB for typeless transaction: {id}", id=txid)
|
|
return
|
|
stored_trade = convert(stored_trade)
|
|
if "old_state" in inside:
|
|
if "new_state" in inside:
|
|
# We don't care unless we're being told a transaction is now completed
|
|
if not inside["new_state"] == "completed":
|
|
return
|
|
# We don't care unless the existing trade is pending
|
|
if not stored_trade["state"] == "pending":
|
|
return
|
|
# Check the old state is what we also think it is
|
|
if inside["old_state"] == stored_trade["state"]:
|
|
# Set the state to the new state
|
|
stored_trade["state"] = inside["new_state"]
|
|
# Store the updated state
|
|
r.hmset(f"tx.{txid}", stored_trade)
|
|
# Check it's all been previously validated
|
|
if "valid" not in stored_trade:
|
|
self.log.error("Valid not in stored trade for {txid}, aborting.", txid=txid)
|
|
return
|
|
if stored_trade["valid"] == "1":
|
|
# Make it invalid immediately, as we're going to release now
|
|
stored_trade["valid"] = "0"
|
|
r.hmset(f"tx.{txid}", stored_trade)
|
|
reference = self.tx_to_ref(stored_trade["trade_id"])
|
|
self.release_funds(stored_trade["trade_id"], reference)
|
|
self.notify.notify_complete_trade(stored_trade["amount"], stored_trade["currency"])
|
|
return
|
|
# If type not in inside and we haven't hit any more returns
|
|
return
|
|
else:
|
|
txtype = inside["type"]
|
|
if txtype == "card_payment":
|
|
self.log.info("Ignoring card payment: {id}", id=txid)
|
|
return
|
|
|
|
state = inside["state"]
|
|
if "reference" in inside:
|
|
reference = inside["reference"]
|
|
else:
|
|
reference = "not_given"
|
|
|
|
leg = inside["legs"][0]
|
|
|
|
if "counterparty" in leg:
|
|
account_type = leg["counterparty"]["account_type"]
|
|
else:
|
|
account_type = "not_given"
|
|
|
|
amount = leg["amount"]
|
|
if amount <= 0:
|
|
self.log.info("Ignoring transaction with negative/zero amount: {id}", id=txid)
|
|
return
|
|
currency = leg["currency"]
|
|
description = leg["description"]
|
|
|
|
to_store = {
|
|
"event": event,
|
|
"trade_id": "",
|
|
"ts": ts,
|
|
"txid": txid,
|
|
"txtype": txtype,
|
|
"state": state,
|
|
"reference": reference,
|
|
"account_type": account_type,
|
|
"amount": amount,
|
|
"currency": currency,
|
|
"description": description,
|
|
"valid": 0, # All checks passed and we can release escrow?
|
|
}
|
|
|
|
self.log.info("Transaction processed: {formatted}", formatted=dumps(to_store, indent=2))
|
|
self.irc.sendmsg(f"AUTO Incoming transaction: {amount}{currency} ({reference}) - {state} - {description}")
|
|
|
|
# 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 = self.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:
|
|
self.log.error("Multiple references valid for TXID {txid}: {reference}", txid=txid, reference=reference)
|
|
self.irc.sendmsg(f"Multiple references valid for TXID {txid}: {reference}")
|
|
return
|
|
|
|
stored_trade = False
|
|
looked_up_without_reference = False
|
|
|
|
# Amount/currency lookup implementation
|
|
if not stored_trade_reference:
|
|
self.log.info(f"No reference in DB refs for {reference}", reference=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.
|
|
|
|
self.log.info("Checking against amount and currency for TXID {txid}", txid=txid)
|
|
self.irc.sendmsg(f"Checking against amount and currency for TXID {txid}")
|
|
stored_trade = self.find_trade(txid, currency, amount)
|
|
if not stored_trade:
|
|
self.log.info(
|
|
"Failed to get reference by amount and currency: {txid} {currency} {amount}",
|
|
txid=txid,
|
|
currency=currency,
|
|
amount=amount,
|
|
)
|
|
self.irc.sendmsg(f"Failed to get reference by amount and currency: {txid} {currency} {amount}")
|
|
return
|
|
if currency == "USD":
|
|
amount_usd = amount
|
|
else:
|
|
rates = self.agora.get_rates_all()
|
|
amount_usd = amount / rates[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):
|
|
self.log.info("Not checking against amount and currency as amount exceeds MAX")
|
|
self.irc.sendmsg(f"Not checking against amount and currency as amount exceeds MAX")
|
|
# Close here if the amount exceeds the allowable limit for no reference
|
|
return
|
|
# 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
|
|
if not stored_trade:
|
|
stored_trade = self.get_ref(stored_trade_reference.pop())
|
|
if not stored_trade:
|
|
self.log.info("No reference in DB for {reference}", reference=reference)
|
|
self.irc.sendmsg(f"No reference in DB for {reference}")
|
|
return
|
|
|
|
amount = float(amount)
|
|
stored_trade["amount"] = float(stored_trade["amount"])
|
|
|
|
# Make sure it was sent in the expected currency
|
|
if not stored_trade["currency"] == currency:
|
|
self.log.info(
|
|
"Currency mismatch, Agora: {currency_agora} / Revolut: {currency}",
|
|
currency_agora=stored_trade["currency"],
|
|
currency=currency,
|
|
)
|
|
self.irc.sendmsg(f"Currency mismatch, Agora: {stored_trade['currency']} / Revolut: {currency}")
|
|
return
|
|
|
|
# Make sure the expected amount was sent
|
|
if not stored_trade["amount"] == amount:
|
|
if looked_up_without_reference:
|
|
return
|
|
# If the amount does not match exactly, get the min and max values for our given acceptable margins for trades
|
|
min_amount, max_amount = self.agora.get_acceptable_margins(currency, amount)
|
|
self.log.info(
|
|
"Amount does not match exactly, trying with margins: min: {min_amount} / max: {max_amount}",
|
|
min_amount=min_amount,
|
|
max_amount=max_amount,
|
|
)
|
|
self.irc.sendmsg(f"Amount does not match exactly, trying with margins: min: {min_amount} / max: {max_amount}")
|
|
if not min_amount < stored_trade["amount"] < max_amount:
|
|
self.log.info(
|
|
"Amount mismatch - not in margins: {amount} (min: {min_amount} / max: {max_amount}",
|
|
amount=stored_trade["amount"],
|
|
min_amount=min_amount,
|
|
max_amount=max_amount,
|
|
)
|
|
self.irc.sendmsg(f"Amount mismatch - not in margins: {stored_trade['amount']} (min: {min_amount} / max: {max_amount}")
|
|
return
|
|
# Make sure the account type was Revolut, as these are completed instantly
|
|
# if not account_type == "revolut":
|
|
# self.log.info("Account type is not Revolut: {account_type}", account_type=account_type)
|
|
# self.irc.sendmsg(f"Account type is not Revolut: {account_type}")
|
|
# return
|
|
|
|
# We have made it this far without hitting any of the returns, so let's set valid = True
|
|
# This will let us instantly release if the type is pending, and it is subsequently updated to completed with a callback.
|
|
to_store["valid"] = 1
|
|
# Store the trade ID so we can release it easily
|
|
to_store["trade_id"] = stored_trade["id"]
|
|
if not state == "completed":
|
|
self.log.info("Storing incomplete trade: {id}", id=txid)
|
|
r.hmset(f"tx.{txid}", to_store)
|
|
# Don't procees further if state is not "completed"
|
|
return
|
|
|
|
r.hmset(f"tx.{txid}", to_store)
|
|
self.release_funds(stored_trade["id"], stored_trade["reference"])
|
|
self.notify.notify_complete_trade(amount, currency)
|
|
|
|
def release_funds(self, trade_id, reference):
|
|
self.log.info("All checks passed, releasing funds for {trade_id} {reference}", trade_id=trade_id, reference=reference)
|
|
self.irc.sendmsg(f"All checks passed, releasing funds for {trade_id} / {reference}")
|
|
rtrn = self.agora.release_funds(trade_id)
|
|
self.agora.agora.contact_message_post(trade_id, "Thanks! Releasing now :)")
|
|
|
|
# Parse the escrow release response
|
|
message = rtrn["message"]
|
|
message_long = rtrn["response"]["data"]["message"]
|
|
self.irc.sendmsg(f"{message} - {message_long}")
|
|
|
|
def new_trade(self, asset, trade_id, buyer, currency, amount, amount_crypto):
|
|
"""
|
|
Called when we have a new trade in Agora.
|
|
Store details in Redis, generate a reference and optionally let the customer know the reference.
|
|
"""
|
|
reference = "".join(choices(ascii_uppercase, k=5))
|
|
reference = f"{asset}-{reference}"
|
|
existing_ref = r.get(f"trade.{trade_id}.reference")
|
|
if not existing_ref:
|
|
r.set(f"trade.{trade_id}.reference", reference)
|
|
to_store = {
|
|
"id": trade_id,
|
|
"asset": asset,
|
|
"buyer": buyer,
|
|
"currency": currency,
|
|
"amount": amount,
|
|
"amount_crypto": amount_crypto,
|
|
"reference": reference,
|
|
}
|
|
self.log.info("Storing trade information: {info}", info=str(to_store))
|
|
r.hmset(f"trade.{reference}", to_store)
|
|
self.irc.sendmsg(f"Generated reference for {trade_id}: {reference}")
|
|
self.notify.notify_new_trade(amount, currency)
|
|
if settings.Agora.Send == "1":
|
|
self.agora.agora.contact_message_post(trade_id, f"Hi! When sending the payment please use reference code: {reference}")
|
|
if existing_ref:
|
|
return convert(existing_ref)
|
|
else:
|
|
return reference
|
|
|
|
def find_trade(self, txid, currency, amount):
|
|
"""
|
|
Get a trade reference that matches the given currency and amount.
|
|
Only works if there is one result.
|
|
:param txid: Revolut transaction ID
|
|
:param currency: currency
|
|
:param amount: amount
|
|
:type txid: string
|
|
:type currency: string
|
|
:type amount: int
|
|
:return: matching trade object or False
|
|
:rtype: dict or bool
|
|
"""
|
|
refs = self.get_refs()
|
|
matching_refs = []
|
|
# TODO: use get_ref_map in this function instead of calling get_ref multiple times
|
|
for ref in refs:
|
|
stored_trade = self.get_ref(ref)
|
|
if stored_trade["currency"] == currency and float(stored_trade["amount"]) == float(amount):
|
|
matching_refs.append(stored_trade)
|
|
if len(matching_refs) != 1:
|
|
self.log.error("Find trade returned multiple results for TXID {txid}: {matching_refs}", txid=txid, matching_refs=matching_refs)
|
|
return False
|
|
return matching_refs[0]
|
|
|
|
def get_refs(self):
|
|
"""
|
|
Get all reference IDs for trades.
|
|
:return: list of trade IDs
|
|
:rtype: list
|
|
"""
|
|
references = []
|
|
ref_keys = r.keys("trade.*.reference")
|
|
for key in ref_keys:
|
|
references.append(r.get(key))
|
|
return convert(references)
|
|
|
|
def get_ref_map(self):
|
|
"""
|
|
Get all reference IDs for trades.
|
|
:return: dict of references keyed by TXID
|
|
:rtype: dict
|
|
"""
|
|
references = {}
|
|
ref_keys = r.keys("trade.*.reference")
|
|
for key in ref_keys:
|
|
tx = convert(key).split(".")[1]
|
|
references[tx] = r.get(key)
|
|
return convert(references)
|
|
|
|
def get_ref(self, reference):
|
|
"""
|
|
Get the trade information for a reference.
|
|
:param reference: trade reference
|
|
:type reference: string
|
|
:return: dict of trade information
|
|
:rtype: dict
|
|
"""
|
|
ref_data = r.hgetall(f"trade.{reference}")
|
|
ref_data = convert(ref_data)
|
|
if not ref_data:
|
|
return False
|
|
return ref_data
|
|
|
|
def del_ref(self, reference):
|
|
"""
|
|
Delete a given reference from the Redis database.
|
|
:param reference: trade reference to delete
|
|
:type reference: string
|
|
"""
|
|
tx = self.ref_to_tx(reference)
|
|
r.delete(f"trade.{reference}")
|
|
r.delete(f"trade.{tx}.reference")
|
|
|
|
def cleanup(self, references):
|
|
"""
|
|
Reconcile the internal reference database with a given list of references.
|
|
Delete all internal references not present in the list and clean up artifacts.
|
|
:param references: list of references to reconcile against
|
|
:type references: list
|
|
"""
|
|
for tx, reference in self.get_ref_map().items():
|
|
if reference not in references:
|
|
self.log.info("Archiving trade reference: {reference} / TX: {tx}", reference=reference, tx=tx)
|
|
r.rename(f"trade.{tx}.reference", f"archive.trade.{tx}.reference")
|
|
r.rename(f"trade.{reference}", f"archive.trade.{reference}")
|
|
|
|
def tx_to_ref(self, tx):
|
|
"""
|
|
Convert a trade ID to a reference.
|
|
:param tx: trade ID
|
|
:type tx: string
|
|
:return: reference
|
|
:rtype: string
|
|
"""
|
|
refs = self.get_refs()
|
|
for reference in refs:
|
|
ref_data = convert(r.hgetall(f"trade.{reference}"))
|
|
if not ref_data:
|
|
continue
|
|
if ref_data["id"] == tx:
|
|
return reference
|
|
|
|
def ref_to_tx(self, reference):
|
|
"""
|
|
Convert a reference to a trade ID.
|
|
:param reference: trade reference
|
|
:type reference: string
|
|
:return: trade ID
|
|
:rtype: string
|
|
"""
|
|
ref_data = convert(r.hgetall(f"trade.{reference}"))
|
|
if not ref_data:
|
|
return False
|
|
return ref_data["id"]
|
|
|
|
def get_total_usd(self):
|
|
"""
|
|
Get total USD in all our accounts, bank and trading.
|
|
:return: value in USD
|
|
:rtype float:
|
|
"""
|
|
total_usd_revolut = self.revolut.get_total_usd()
|
|
if total_usd_revolut is False:
|
|
return False
|
|
agora_wallet_xmr = self.agora.agora.wallet_balance_xmr()
|
|
if not agora_wallet_xmr["success"]:
|
|
return False
|
|
agora_wallet_btc = self.agora.agora.wallet_balance()
|
|
if not agora_wallet_btc["success"]:
|
|
return False
|
|
total_xmr_agora = agora_wallet_xmr["response"]["data"]["total"]["balance"]
|
|
total_btc_agora = agora_wallet_btc["response"]["data"]["total"]["balance"]
|
|
# Get the XMR -> USD exchange rate
|
|
xmr_usd = self.agora.cg.get_price(ids="monero", vs_currencies=["USD"])
|
|
|
|
# Get the BTC -> USD exchange rate
|
|
btc_usd = self.agora.cg.get_price(ids="bitcoin", vs_currencies=["USD"])
|
|
|
|
# Convert the Agora XMR total to USD
|
|
total_usd_agora_xmr = float(total_xmr_agora) * xmr_usd["monero"]["usd"]
|
|
|
|
# Convert the Agora BTC total to USD
|
|
total_usd_agora_btc = float(total_btc_agora) * btc_usd["bitcoin"]["usd"]
|
|
|
|
# Add it all up
|
|
total_usd_agora = total_usd_agora_xmr + total_usd_agora_btc
|
|
total_usd = total_usd_agora + total_usd_revolut
|
|
return total_usd
|
|
|
|
# TODO: possibly refactor this into smaller functions which don't return as much stuff
|
|
# check if this is all really needed in the corresponding withdraw function
|
|
def get_total(self):
|
|
"""
|
|
Get all the values corresponding to the amount of money we hold.
|
|
:return: ((total SEK, total USD, total GBP), (total XMR USD, total BTC USD), (total XMR, total BTC))
|
|
:rtype: tuple(tuple(float, float, float), tuple(float, float), tuple(float, float))
|
|
"""
|
|
total_usd_revolut = self.revolut.get_total_usd()
|
|
if total_usd_revolut is False:
|
|
self.log.error("Could not get USD total.")
|
|
return False
|
|
agora_wallet_xmr = self.agora.agora.wallet_balance_xmr()
|
|
if not agora_wallet_xmr["success"]:
|
|
self.log.error("Could not get Agora XMR wallet total.")
|
|
return False
|
|
agora_wallet_btc = self.agora.agora.wallet_balance()
|
|
if not agora_wallet_btc["success"]:
|
|
self.log.error("Could not get Agora BTC wallet total.")
|
|
return False
|
|
total_xmr_agora = agora_wallet_xmr["response"]["data"]["total"]["balance"]
|
|
total_btc_agora = agora_wallet_btc["response"]["data"]["total"]["balance"]
|
|
# Get the XMR -> USD exchange rate
|
|
xmr_usd = self.agora.cg.get_price(ids="monero", vs_currencies=["USD"])
|
|
|
|
# Get the BTC -> USD exchange rate
|
|
btc_usd = self.agora.cg.get_price(ids="bitcoin", vs_currencies=["USD"])
|
|
|
|
# Convert the Agora XMR total to USD
|
|
total_usd_agora_xmr = float(total_xmr_agora) * xmr_usd["monero"]["usd"]
|
|
|
|
# Convert the Agora BTC total to USD
|
|
total_usd_agora_btc = float(total_btc_agora) * btc_usd["bitcoin"]["usd"]
|
|
|
|
# Add it all up
|
|
total_usd_agora = total_usd_agora_xmr + total_usd_agora_btc
|
|
total_usd = total_usd_agora + total_usd_revolut
|
|
|
|
# Convert the total USD price to GBP and SEK
|
|
rates = self.agora.get_rates_all()
|
|
price_sek = rates["SEK"] * total_usd
|
|
price_usd = total_usd
|
|
price_gbp = rates["GBP"] * total_usd
|
|
|
|
return (
|
|
(price_sek, price_usd, price_gbp), # Total prices in our 3 favourite currencies
|
|
(total_usd_agora_xmr, total_usd_agora_btc), # Total USD balance in only Agora
|
|
(total_xmr_agora, total_btc_agora),
|
|
) # Total XMR and BTC balance in Agora
|
|
|
|
def get_remaining(self):
|
|
"""
|
|
Check how much profit we need to make in order to withdraw.
|
|
:return: profit remaining in USD
|
|
:rtype: float
|
|
"""
|
|
total_usd = self.get_total_usd()
|
|
if not total_usd:
|
|
return False
|
|
|
|
withdraw_threshold = float(settings.Money.BaseUSD) + float(settings.Money.WithdrawLimit)
|
|
remaining = withdraw_threshold - total_usd
|
|
|
|
return remaining
|
|
|
|
def get_open_trades_usd(self):
|
|
"""
|
|
Get total value of open trades in USD.
|
|
:return: total trade value
|
|
:rtype: float
|
|
"""
|
|
dash = self.agora.wrap_dashboard()
|
|
if dash is False:
|
|
return False
|
|
|
|
rates = self.agora.get_rates_all()
|
|
cumul_usd = 0
|
|
for contact_id, contact in dash.items():
|
|
amount = contact["data"]["amount"]
|
|
currency = contact["data"]["currency"]
|
|
if not contact["data"]["is_selling"]:
|
|
continue
|
|
if currency == "USD":
|
|
cumul_usd += amount
|
|
else:
|
|
rate = rates[currency]
|
|
amount_usd = float(amount) / rate
|
|
cumul_usd += amount_usd
|
|
return cumul_usd
|
|
|
|
def get_total_remaining(self):
|
|
"""
|
|
Check how much profit we need to make in order to withdraw, taking into account open trade value.
|
|
:return: profit remaining in USD
|
|
:rtype: float
|
|
"""
|
|
total_usd = self.get_total_usd()
|
|
total_trades_usd = self.get_open_trades_usd()
|
|
if not total_usd:
|
|
return False
|
|
total_usd += total_trades_usd
|
|
withdraw_threshold = float(settings.Money.BaseUSD) + float(settings.Money.WithdrawLimit)
|
|
remaining = withdraw_threshold - total_usd
|
|
return remaining
|