WIP. Almost complete adaptation to new splitting/trade management strategy

Author: icook

simplecoin/models.py

@@ -42,24 +42,60 @@ def make_upper_lower(trim=None, span=None, offset=None, clip=None, fmt="dt"):
     return lower, upper
 
 
+class TradeResult(base):
+    """ Represents the results of a single trade update from our trading
+    backend.  When an update to a TradeRequest gets posted a new trade result
+    will get created to record associated trade information. The results of the
+    trade are distributed among it's credits. Creation is handled by
+    TradeRequest.update """
+    id = db.Column(db.Integer, primary_key=True)
+    # Quantity of currency to be traded
+    quantity = db.Column(db.Numeric, nullable=False)
+    exchanged_quantity = db.Column(db.Numeric, default=None)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+    req_id = db.Column(db.Integer, db.ForeignKey('trade_request.id'))
+    req = db.relationship('TradeRequest', foreign_keys=[req_id],
+                          backref='results')
+
+    def distribute(self, payable_amount):
+        # calculate user payouts based on percentage of the total
+        # exchanged value
+        if self.type == "sell":
+            portions = {c.id: c.amount for c in credits}
+        elif self.type == "buy":
+            portions = {c.id: c.sell_amount for c in credits
+                        if c.payable is False}
+
+        amts_copy = portions.copy()
+        amounts = distributor(payable_amount, amts_copy, scale=50)
+
+        for credit in credits:
+            if self.type == "sell":
+                assert credit.sell_amount is None
+                credit.sell_amount = amounts[credit.id]
+            elif self.type == "buy":
+                if credit.payable is False:
+                    credit.buy_amount = amounts[credit.id]
+                    # Mark the credit ready for payout to users
+                    credit.payable = True
+
+
 class TradeRequest(base):
     """
     Used to provide info necessary to external applications for trading currencies
 
     Created rows will be checked + updated externally
     """
     id = db.Column(db.Integer, primary_key=True)
-    # 3-8 letter code for the currency to be traded
+    # 3-8 letter code for the currency to be traded. This is the currency to
+    # buy for a buy, and the currency we're selling for a sale
     currency = db.Column(db.String, nullable=False)
     # Quantity of currency to be traded
     quantity = db.Column(db.Numeric, nullable=False)
+    quantity_traded = db.Column(db.Numeric, nullable=False, default=0)
     created_at = db.Column(db.DateTime, default=datetime.utcnow)
     type = db.Column(db.Enum("sell", "buy", name="req_type"), nullable=False)
-
-    # The quantity of the desired currency received by fulfilling this request
-    exchanged_quantity = db.Column(db.Numeric, default=None)
-    # Fees from fulfilling this tr (represented in Currency, not BTC)
-    fees = db.Column(db.Numeric, default=None)
     _status = db.Column(db.SmallInteger, default=0)
 
     @property
@@ -69,81 +105,81 @@ def avg_price(self):
         elif self.type == "sell":
             return (self.exchanged_quantity + self.fees) / self.quantity
 
-    def distribute(self, stuck_quantity, applied_fees):
-        assert self.type in ["buy", "sell"], "Invalid type!"
-        assert self.exchanged_quantity > 0
-
+    def update(self, quantity, source_quantity, fees):
         credits = self.credits  # Do caching here, avoid multiple lookups
         if not credits:
             current_app.logger.warn("Trade request #{} has no attached credits"
                                     .format(self.id))
             return
 
-        # Check config to see if we're charging exchange fees or not
-        payable_amount = self.exchanged_quantity - stuck_quantity
-
-        # If we're covering the exchange fees we'll need to add them in
-        if current_app.config.get('cover_autoex_fees', False):
-            payable_amount += applied_fees
-
-        # Remove previously paid amounts from the payable amount
-        if self.type == "buy":
-            with decimal.localcontext(decimal.BasicContext) as ctx:
-                ctx.traps[decimal.Inexact] = True
-                ctx.prec = 100
-
-                payable_amount -= sum([credit.buy_amount for credit in credits
-                                       if credit.payable is True])
-
-        # calculate user payouts based on percentage of the total
-        # exchanged value
-        if self.type == "sell":
-            portions = {c.id: c.amount for c in credits}
-        elif self.type == "buy":
-            portions = {c.id: c.sell_amount for c in credits
-                        if c.payable is False}
-
-        amts_copy = portions.copy()
-        amounts = distributor(payable_amount, amts_copy, scale=50)
-
+        # Get the amount of source currency that hasn't been distributed to
+        # credits
+        total_unpaid = 0
+        unpaid_credits = []
         for credit in credits:
-            if self.type == "sell":
-                assert credit.sell_amount is None
-                credit.sell_amount = amounts[credit.id]
-            elif self.type == "buy":
-                if credit.payable is False:
-                    credit.buy_amount = amounts[credit.id]
-                    # Mark the credit ready for payout to users
-                    credit.payable = True
+            # We need to skip credits that are already attached to a result
+            if credit.trade_result:
+                continue
 
-        # If its an update redistribute + create new credits
-        if self._status == 5:
-            assert stuck_quantity > 0
+            unpaid_credits.append(credit)
 
-            # Build a dict containing each credit id + amount
-            credit_amts = {credit.id: credit.amount for credit in credits}
-
-            # Get the distribution for the stuck amount
-            amts_copy = credit_amts.copy()
-            curr_distrib = distributor(stuck_quantity, amts_copy)
+            if self.type == "sell":
+                total_unpaid += credit.amount
+            else:
+                total_unpaid += credit.sell_amount
+
+        source_total = 0
+        destination_total = 0
+        fee_total = 0
+        for result in self.trade_results:
+            source_total += result.quantity
+            destination_total += result.exchanged_quantity
+            fee_total += result.fees
+
+        if quantity <= destination_total or source_quantity <= source_total:
+            current_app.logger.warn(
+                "Nothing to update, quantity and source_quantity have not changed")
+            return
 
-            # Calculate the BTC going to the old credits and new credits
-            amts = {'old': payable_amount + self.fees, 'new': stuck_quantity}
-            amts_copy = amts.copy()
-            btc_distrib = distributor(self.quantity, amts_copy)
+        new_tr = TradeResult(quantity=source_quantity - source_total,
+                             exchanged_quantity=quantity - destination_total,
+                             fees=fees - fee_total)
+        db.session.add(new_tr)
+
+        distribute_amount = new_tr.exchanged_quantity
+        # If we're not covering exchange fees, remove them from the amount
+        # we distribute
+        if not current_app.config.get('cover_autoex_fees', False):
+            distribute_amount -= new_tr.fees
+
+        # If the upaid credits sum up to more than the amount of the
+        # TradeResult then we're going to have to split the credit objects so
+        # we can perform a partial credit
+        if total_unpaid > new_tr.exchanged_quantity:
+            credit_amts = {credit.id: credit.amount for credit in unpaid_credits}
+            # Distributing the amount that we'll be paying
+            curr_distrib = distributor(distribute_amount, credit_amts)
+            amount_distrib = distributor(new_tr.quantity, credit_amts)
+
+            # Split a few values evenly based on the ratio between stuck amount
+            # and payable amount
+            amts = {'traded': payable_amount + self.fees,
+                    'remaining': stuck_quantity}
+            if self.type == "sell":
+                btc_distrib = distributor(self.quantity, amts.copy())
 
-            # Calculate the BTC distribution, based on the stuck currency amounts
-            amts_copy = credit_amts.copy()
-            new_btc_distrib = distributor(btc_distrib['new'], amts_copy)
+            # Calculate the BTC distribution, based on the stuck currency
+            # amounts
+            new_btc_distrib = distributor(btc_distrib['new'], amts.copy())
 
             with decimal.localcontext(decimal.BasicContext) as ctx:
-                ctx.traps[decimal.Inexact] = True
+                # A sufficiently large number that we don't cause rounding
+                # error
                 ctx.prec = 50
 
                 i = 0
-                orig_len = len(credits)
                 # Loop + add a new credit for each old credit
-                while i < orig_len:
+                while i < len(credits):
                     credit = credits[i]
 
                     # subtract the credits cut from the old credit's amount
@@ -174,15 +210,17 @@ def distribute(self, stuck_quantity, applied_fees):
                 "amount {:,} payable and {:,} stuck.".
                 format(self.id, payable_amount, stuck_quantity))
 
-        db.session.flush()
+        if source_quantity == self.quantity:
+            self._status = 6
+        else:
+            self._status = 5
 
-        if self._status == 6:
-            assert stuck_quantity == 0
-            current_app.logger.info(
-                "Successfully pushed trade result for request id {:,} and "
-                "amount {:,} to {:,} credits.".
-                format(self.id, self.exchanged_quantity, len(credits)))
+        db.session.flush()
 
+        current_app.logger.info(
+            "Successfully pushed trade result for request id {:,} and "
+            "amount {:,} to {:,} credits.".
+            format(self.id, self.exchanged_quantity, len(credits)))
 
     @property
     def credits(self):
@@ -521,10 +559,16 @@ class CreditExchange(Credit):
     sell_req_id = db.Column(db.Integer, db.ForeignKey('trade_request.id'))
     sell_req = db.relationship('TradeRequest', foreign_keys=[sell_req_id],
                                backref='sell_credits')
+    sell_res_id = db.Column(db.Integer, db.ForeignKey('trade_result.id'))
+    sell_res = db.relationship('TradeResult', foreign_keys=[buy_req_id],
+                              backref='sell_credits')
     sell_amount = db.Column(db.Numeric)
     buy_req_id = db.Column(db.Integer, db.ForeignKey('trade_request.id'))
     buy_req = db.relationship('TradeRequest', foreign_keys=[buy_req_id],
                               backref='buy_credits')
+    buy_res_id = db.Column(db.Integer, db.ForeignKey('trade_result.id'))
+    buy_res = db.relationship('TradeResult', foreign_keys=[buy_req_id],
+                              backref='buy_credits')
     buy_amount = db.Column(db.Numeric)
 
     @property

simplecoin/rpc_views.py

@@ -66,7 +66,7 @@ def update_trade_requests():
             assert 'status' in tr
             g.signed['trs'][tr_id]['status'] = int(tr['status'])
             if tr['status'] == 5 or tr['status'] == 6:
-                tr['stuck_quantity'] = Decimal(tr['stuck_quantity'])
+                tr['source_quantity'] = Decimal(tr['source_quantity'])
                 tr['quantity'] = Decimal(tr['quantity'])
                 tr['fees'] = Decimal(tr['fees'])
     except (AssertionError, TypeError, KeyError):
@@ -84,13 +84,11 @@ def update_trade_requests():
 
             if status == 5 or status == 6:
                 tr.exchanged_quantity = tr_dict['quantity'] + tr_dict['stuck_quantity']
-                if tr.fees:
-                    applied_fees = tr_dict['fees'] - tr.fees
-                else:
-                    applied_fees = tr_dict['fees']
                 tr.fees = tr_dict['fees']
-                stuck_quantity = tr_dict['stuck_quantity']
-                tr.distribute(stuck_quantity, applied_fees)
+                # Get the amount of fees that we incurred during this trade
+                # update
+                applied_fees = tr_dict['fees'] - (tr.fees or 0)
+                tr.distribute(tr_dict['stuck_quantity'], applied_fees)
 
         except Exception:
             db.session.rollback()

simplecoin/tests/test_payout.py

@@ -270,7 +270,7 @@ def test_update_tr_buy(self):
                                      "stuck_quantity": str(posted_stuck_amt)}}}
         db.session.expunge_all()
 
-        with self.app.test_request_context('/?name=Peter'):
+        with self.app.test_request_context():
             flask.g.signer = TimedSerializer(self.app.config['rpc_signature'])
             flask.g.signed = push_data
             update_trade_requests()
@@ -312,15 +312,16 @@ def test_update_tr_buy(self):
             # Check that new credit attrs are the same as old (fees, etc)
             for credit in credits2:
                 if credit.payable is False:
-                    assert credits2[credit.id - 20].fee_perc == credit.fee_perc
-                    assert credits2[credit.id - 20].pd_perc == credit.pd_perc
-                    assert credits2[credit.id - 20].block == credit.block
-                    assert credits2[credit.id - 20].user == credit.user
-                    assert credits2[credit.id - 20].sharechain_id == credit.sharechain_id
-                    assert credits2[credit.id - 20].address == credit.address
-                    assert credits2[credit.id - 20].currency == credit.currency
-                    assert credits2[credit.id - 20].type == credit.type
-                    assert credits2[credit.id - 20].payout == credit.payout
+                    c2 = credits2[credit.id - 20]
+                    assert c2.fee_perc == credit.fee_perc
+                    assert c2.pd_perc == credit.pd_perc
+                    assert c2.block == credit.block
+                    assert c2.user == credit.user
+                    assert c2.sharechain_id == credit.sharechain_id
+                    assert c2.address == credit.address
+                    assert c2.currency == credit.currency
+                    assert c2.type == credit.type
+                    assert c2.payout == credit.payout
 
         # Assert that the status is 5, partially completed
         assert tr2._status == 5