From 05ffd9e542095c49fe8e914c9e8197f29876ed74 Mon Sep 17 00:00:00 2001
From: Eric Cook <eric@simpload.com>
Date: Tue, 23 Sep 2014 23:06:26 -0500
Subject: [PATCH 1/9] Refactors update_tr rpcview and distribution logic to
 handle a partial Credit update

---
 simplecoin/models.py      | 85 +++++++++++++++++++++++++++------------
 simplecoin/rpc_views.py   | 12 ++++--
 templates/user_stats.html |  6 +--
 3 files changed, 70 insertions(+), 33 deletions(-)

diff --git a/simplecoin/models.py b/simplecoin/models.py
index e96ef2e7..c77337a3 100755
--- a/simplecoin/models.py
+++ b/simplecoin/models.py
@@ -55,50 +55,83 @@ class TradeRequest(base):
     created_at = db.Column(db.DateTime, default=datetime.utcnow)
     type = db.Column(db.Enum("sell", "buy", name="req_type"), nullable=False)
 
-    # These values should only be updated by sctrader
+    # The quantity of the desired currency received by fulfilling this request
     exchanged_quantity = db.Column(db.Numeric, default=None)
     # Fees from fulfilling this tr
     fees = db.Column(db.Numeric, default=None)
     _status = db.Column(db.SmallInteger, default=0)
 
-    def distribute(self):
+    @property
+    def currency_fees(self):
+        return self.fees * self.avg_price
+
+    @property
+    def avg_price(self):
+        return self.exchanged_quantity / self.quantity
+
+    def distribute(self, stuck_quantity):
         assert self.type in ["buy", "sell"], "Invalid type!"
         assert self.exchanged_quantity > 0
 
-        # Check config to see if we're charging exchange fees or not
-        payable_amount = self.exchanged_quantity
-        if current_app.config.get('charge_autoex_fees', False):
-            payable_amount -= self.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))
-        else:
-            # 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}
-            amounts = distributor(payable_amount, portions)
+            return
 
+        # Check config to see if we're charging exchange fees or not
+        payable_amount = self.exchanged_quantity - stuck_quantity
+
+        # Check config to see if we're charging exchange fees or not
+        if current_app.config.get('charge_autoex_fees', False):
+            payable_amount -= self.fees
+
+        if self.type == "buy":
+            # Remove previously paid amounts from the payable amount
             for credit in credits:
-                if self.type == "sell":
-                    assert credit.sell_amount is None
-                    credit.sell_amount = amounts[credit.id]
-                elif self.type == "buy":
-                    assert credit.buy_amount is None
+                if credit.buy_amount is not None:
+                    payable_amount -= credit.buy_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}
+        amounts = distributor(payable_amount, portions)
+
+        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.buy_amount is None:
                     credit.buy_amount = amounts[credit.id]
                     # Mark the credit ready for payout to users
                     credit.payable = True
 
-            current_app.logger.info(
-                "Successfully pushed trade result for request id {:,} and "
-                "amount {:,} to {:,} credits.".
-                format(self.id, self.exchanged_quantity, len(credits)))
-
-        self._status = 6
+                    if self._status == 5:
+                        assert stuck_quantity > 0
+                        old_credit_amt = credit.buy_amount / self.avg_price
+                        new_credit_amt = credit.amount - old_credit_amt
+                        credit.amount = old_credit_amt
+
+                        # create new credit
+                        cr = Credit.make_credit(
+                            user=credit.user,
+                            block=credit.block,
+                            currency=credit.currency,
+                            source=credit.source,
+                            address=credit.address,
+                            amount=new_credit_amt)
+                        db.session.add(cr)
+                        self.credits.append(cr)
+
+
+        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):
diff --git a/simplecoin/rpc_views.py b/simplecoin/rpc_views.py
index 910cf074..40c4ea64 100644
--- a/simplecoin/rpc_views.py
+++ b/simplecoin/rpc_views.py
@@ -65,7 +65,8 @@ def update_trade_requests():
             assert isinstance(tr, dict)
             assert 'status' in tr
             g.signed['trs'][tr_id]['status'] = int(tr['status'])
-            if tr['status'] == 6:
+            if tr['status'] == 5 or tr['status'] == 6:
+                assert 'stuck_quantity' in tr
                 assert 'quantity' in tr
                 assert 'fees' in tr
     except (AssertionError, TypeError):
@@ -76,14 +77,17 @@ def update_trade_requests():
     updated = []
     for tr_id, tr_dict in g.signed['trs'].iteritems():
         try:
+            status = tr_dict['status']
             tr = (TradeRequest.query.filter_by(id=int(tr_id)).
                   with_lockmode('update').one())
-            tr._status = tr_dict['status']
+            tr._status = status
 
-            if tr_dict['status'] == 6:
+            if status == 5 or status == 6:
                 tr.exchanged_quantity = Decimal(tr_dict['quantity'])
                 tr.fees = Decimal(tr_dict['fees'])
-                tr.distribute()
+                stuck_quantity = Decimal(tr_dict['stuck_quantity'])
+                tr.distribute(stuck_quantity)
+
         except Exception:
             db.session.rollback()
             current_app.logger.error("Unable to update trade request {}"
diff --git a/templates/user_stats.html b/templates/user_stats.html
index 56c2aea5..6da03abc 100755
--- a/templates/user_stats.html
+++ b/templates/user_stats.html
@@ -58,11 +58,11 @@ <h2>Worker Hashrates
         <li class="tab day"><a>Day</a></li>
         <li class="tab month"><a>Month</a></li>
       </ul>
-    <div style="height:400px;">
-      <img src="{{ config['assets_address'] | safe }}/img/712.GIF" style="position:absolute;padding-top:150px;padding-left:400px;"><svg></svg>
+      <div style="height:400px;">
+        <img src="{{ config['assets_address'] | safe }}/img/712.GIF" style="position:absolute;padding-top:150px;padding-left:400px;"><svg></svg>
+      </div>
     </div>
   </div>
-  </div>
 
   {% if workers %}
   <div class="row page-header">

From 9e608ebf7f6ac5378b9d067c47e3ae1184e234d9 Mon Sep 17 00:00:00 2001
From: Eric Cook <eric@simpload.com>
Date: Mon, 29 Sep 2014 21:05:41 -0500
Subject: [PATCH 2/9] WIP - test added for update_tr, logic reworked

---
 simplecoin/models.py            | 75 ++++++++++++++++++++++++---------
 simplecoin/rpc_views.py         |  2 +-
 simplecoin/tests/test_payout.py | 75 +++++++++++++++++++++++++++++++--
 3 files changed, 126 insertions(+), 26 deletions(-)

diff --git a/simplecoin/models.py b/simplecoin/models.py
index c77337a3..0b0234e9 100755
--- a/simplecoin/models.py
+++ b/simplecoin/models.py
@@ -67,7 +67,10 @@ def currency_fees(self):
 
     @property
     def avg_price(self):
-        return self.exchanged_quantity / self.quantity
+        if self.type == "buy":
+            return self.quantity / self.exchanged_quantity
+        elif self.type == "sell":
+            return self.exchanged_quantity / self.quantity
 
     def distribute(self, stuck_quantity):
         assert self.type in ["buy", "sell"], "Invalid type!"
@@ -98,8 +101,19 @@ def distribute(self, stuck_quantity):
             portions = {c.id: c.amount for c in credits}
         elif self.type == "buy":
             portions = {c.id: c.sell_amount for c in credits}
+
+        from pprint import pformat
+        print pformat(portions)
+
         amounts = distributor(payable_amount, portions)
 
+        # print "{}, {}".format(type(payable_amount), payable_amount)
+        # for amount in amounts.itervalues():
+        #     print "{}, {}".format(type(amount), amount)
+        # print pformat(sum([amount for amount in amounts.itervalues()]))
+        # assert 1 == 0
+
+        credit_amts = {}
         for credit in credits:
             if self.type == "sell":
                 assert credit.sell_amount is None
@@ -112,26 +126,45 @@ def distribute(self, stuck_quantity):
 
                     if self._status == 5:
                         assert stuck_quantity > 0
-                        old_credit_amt = credit.buy_amount / self.avg_price
-                        new_credit_amt = credit.amount - old_credit_amt
-                        credit.amount = old_credit_amt
-
-                        # create new credit
-                        cr = Credit.make_credit(
-                            user=credit.user,
-                            block=credit.block,
-                            currency=credit.currency,
-                            source=credit.source,
-                            address=credit.address,
-                            amount=new_credit_amt)
-                        db.session.add(cr)
-                        self.credits.append(cr)
-
-
-        current_app.logger.info(
-            "Successfully pushed trade result for request id {:,} and "
-            "amount {:,} to {:,} credits.".
-            format(self.id, self.exchanged_quantity, len(credits)))
+                        credit_amts[credit.id] = credit.amount
+
+        distrib = distributor(self.quantity, credit_amts)
+
+        i = 0
+        orig_len = len(credits)
+        while i < orig_len:
+            credit = credits[i]
+
+            # subtract the credits cut from the old credit's amount
+            credit.amount -= distrib[credit.id]
+            # Create a new credit for the remaining cut
+            new_credit_amt = distrib[credit.id]
+
+            cr = CreditExchange(
+                user=credit.user,
+                amount=new_credit_amt,
+                sell_amount=new_credit_amt,
+                sell_req=None,
+                buy_req=self,
+                currency=credit.currency,
+                address=credit.address,
+                block=credit.block)
+
+            db.session.add(cr)
+            i += 1
+
+        db.session.flush()
+
+        if self._status == 6:
+            current_app.logger.info(
+                "Successfully pushed trade result for request id {:,} and "
+                "amount {:,} to {:,} credits.".
+                format(self.id, self.exchanged_quantity, len(credits)))
+        elif self._status == 5:
+            current_app.logger.info(
+                "Successfully updated trade request {:,} making "
+                "amount {:,} payable and {:,} stuck.".
+                format(self.id, payable_amount, stuck_quantity))
 
     @property
     def credits(self):
diff --git a/simplecoin/rpc_views.py b/simplecoin/rpc_views.py
index 40c4ea64..05b4ff69 100644
--- a/simplecoin/rpc_views.py
+++ b/simplecoin/rpc_views.py
@@ -83,7 +83,7 @@ def update_trade_requests():
             tr._status = status
 
             if status == 5 or status == 6:
-                tr.exchanged_quantity = Decimal(tr_dict['quantity'])
+                tr.exchanged_quantity = Decimal(tr_dict['quantity']) + Decimal(tr_dict['stuck_quantity'])
                 tr.fees = Decimal(tr_dict['fees'])
                 stuck_quantity = Decimal(tr_dict['stuck_quantity'])
                 tr.distribute(stuck_quantity)
diff --git a/simplecoin/tests/test_payout.py b/simplecoin/tests/test_payout.py
index 028cce37..0ebe08bc 100644
--- a/simplecoin/tests/test_payout.py
+++ b/simplecoin/tests/test_payout.py
@@ -156,7 +156,7 @@ def test_payout_generation(self):
 
 
 class TestTradeRequest(UnitTest):
-    def test_push_tr_buy(self):
+    def test_complete_tr_buy(self):
         credits = []
         tr = m.TradeRequest(
             quantity=sum(xrange(1, 20)),
@@ -176,7 +176,8 @@ def test_push_tr_buy(self):
             db.session.add(c)
 
         db.session.commit()
-        push_data = {'trs': {tr.id: {"status": 6, "quantity": "1000", "fees": "1"}}}
+        push_data = {'trs': {tr.id: {"status": 6, "quantity": "1000",
+                                     "fees": "1", "stuck_quantity": "0"}}}
         db.session.expunge_all()
 
         with self.app.test_request_context('/?name=Peter'):
@@ -195,7 +196,7 @@ def test_push_tr_buy(self):
 
         assert m.TradeRequest.query.first()._status == 6
 
-    def test_push_tr(self):
+    def test_complete_tr_sell(self):
         credits = []
         tr = m.TradeRequest(
             quantity=sum(xrange(1, 20)),
@@ -213,7 +214,8 @@ def test_push_tr(self):
             db.session.add(c)
 
         db.session.commit()
-        push_data = {'trs': {tr.id: {"status": 6, "quantity": "1000", "fees": "1"}}}
+        push_data = {'trs': {tr.id: {"status": 6, "quantity": "1000",
+                                     "fees": "1", "stuck_quantity": "0"}}}
         db.session.expunge_all()
 
         with self.app.test_request_context('/?name=Peter'):
@@ -232,6 +234,71 @@ def test_push_tr(self):
 
         assert m.TradeRequest.query.first()._status == 6
 
+    def test_update_tr_buy(self):
+        blk1 = self.make_block(mature=True)
+
+        credits = []
+        tr = m.TradeRequest(
+            quantity=sum(xrange(1, 20)) / 2,
+            type="buy",
+            currency="TEST"
+        )
+        db.session.add(tr)
+        for i in xrange(1, 20):
+            amount = float(i) / 2
+            c = m.CreditExchange(
+                amount=amount,
+                sell_amount=i,
+                sell_req=None,
+                buy_req=tr,
+                currency="TEST",
+                address="test{}".format(i),
+                block=blk1)
+            credits.append(c)
+            db.session.add(c)
+
+        # raise TypeError([credit.__dict__ for credit in credits])
+
+        db.session.commit()
+        push_data = {'trs': {tr.id: {"status": 5, "quantity": "150",
+                                     "fees": "1", "stuck_quantity": "40"}}}
+        db.session.expunge_all()
+
+        with self.app.test_request_context('/?name=Peter'):
+            flask.g.signer = TimedSerializer(self.app.config['rpc_signature'])
+            flask.g.signed = push_data
+            update_trade_requests()
+
+        db.session.rollback()
+        db.session.expunge_all()
+
+        tr2 = m.TradeRequest.query.first()
+        credits2 = m.CreditExchange.query.all()
+
+        # Assert that the total hasn't changed
+        credit_amt = sum([credit.amount for credit in credits2])
+        # print credit_amt
+        # print tr.quantity
+        # assert credit_amt == 0
+        assert credit_amt == tr.quantity
+
+        # Assert that the payable amount is 150
+        payable_amt = sum([credit.buy_amount for credit in credits2 if credit.payable is True])
+        print payable_amt
+        # assert payable_amt == 0
+        assert payable_amt == 150
+
+        # Assert that the stuck amount is 40
+        stuck_amt = sum([credit.buy_amount for credit in credits2 if credit.payable is False])
+        # for credit in credits2:
+        #     print "{}, {}".format(credit.id, credit.amount)
+        print stuck_amt
+        # assert stuck_amt == 0
+        assert stuck_amt == 40
+
+        # Assert that the status is 5, partially completed
+        assert tr2._status == 5
+
 
 class TestPayouts(RedisUnitTest):
     test_block_data = {

From 4954d058fc4cb8a0ab61f95b498909d4118d7132 Mon Sep 17 00:00:00 2001
From: Eric Cook <eric@simpload.com>
Date: Wed, 1 Oct 2014 09:09:50 -0500
Subject: [PATCH 3/9] WIP. Big cleanup - basic tests are now passing

---
 simplecoin/models.py            | 93 ++++++++++++++++++---------------
 simplecoin/scheduler.py         |  5 +-
 simplecoin/tests/test_payout.py | 59 +++++++++++++--------
 3 files changed, 89 insertions(+), 68 deletions(-)

diff --git a/simplecoin/models.py b/simplecoin/models.py
index 0b0234e9..a4cf2109 100755
--- a/simplecoin/models.py
+++ b/simplecoin/models.py
@@ -1,4 +1,5 @@
 import calendar
+import decimal
 from decimal import Decimal
 import logging
 
@@ -89,8 +90,8 @@ def distribute(self, stuck_quantity):
         if current_app.config.get('charge_autoex_fees', False):
             payable_amount -= self.fees
 
+        # Remove previously paid amounts from the payable amount
         if self.type == "buy":
-            # Remove previously paid amounts from the payable amount
             for credit in credits:
                 if credit.buy_amount is not None:
                     payable_amount -= credit.buy_amount
@@ -102,18 +103,8 @@ def distribute(self, stuck_quantity):
         elif self.type == "buy":
             portions = {c.id: c.sell_amount for c in credits}
 
-        from pprint import pformat
-        print pformat(portions)
-
         amounts = distributor(payable_amount, portions)
 
-        # print "{}, {}".format(type(payable_amount), payable_amount)
-        # for amount in amounts.itervalues():
-        #     print "{}, {}".format(type(amount), amount)
-        # print pformat(sum([amount for amount in amounts.itervalues()]))
-        # assert 1 == 0
-
-        credit_amts = {}
         for credit in credits:
             if self.type == "sell":
                 assert credit.sell_amount is None
@@ -124,34 +115,54 @@ def distribute(self, stuck_quantity):
                     # Mark the credit ready for payout to users
                     credit.payable = True
 
-                    if self._status == 5:
-                        assert stuck_quantity > 0
-                        credit_amts[credit.id] = credit.amount
-
-        distrib = distributor(self.quantity, credit_amts)
-
-        i = 0
-        orig_len = len(credits)
-        while i < orig_len:
-            credit = credits[i]
+        # If its an update redistribute + create new credits
+        if self._status == 5:
+            assert stuck_quantity > 0
+
+            # 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
+            curr_distrib = distributor(stuck_quantity, credit_amts)
+
+            with decimal.localcontext(decimal.BasicContext) as ctx:
+                ctx.traps[decimal.Inexact] = True
+                ctx.prec = 100
+
+                # Calculate the BTC distribution, based on the stuck currency amounts
+                btc_distrib = {k: v * self.avg_price for k, v in curr_distrib.iteritems()}
+
+                i = 0
+                orig_len = len(credits)
+                # Loop + add a new credit for each old credit
+                while i < orig_len:
+                    credit = credits[i]
+
+                    # subtract the credits cut from the old credit's amount
+                    credit.amount -= btc_distrib[credit.id]
+                    # Create a new credit for the remaining cut
+                    new_credit_amt = btc_distrib[credit.id]
+
+                    cr = CreditExchange(
+                        user=credit.user,
+                        amount=new_credit_amt,
+                        sell_amount=new_credit_amt,
+                        buy_amount=curr_distrib[credit.id],
+                        sell_req=None,
+                        buy_req=self,
+                        currency=credit.currency,
+                        address=credit.address,
+                        fee_perc=credit.fee_perc,
+                        pd_perc=credit.pd_perc,
+                        block=credit.block)
+
+                    db.session.add(cr)
+                    i += 1
 
-            # subtract the credits cut from the old credit's amount
-            credit.amount -= distrib[credit.id]
-            # Create a new credit for the remaining cut
-            new_credit_amt = distrib[credit.id]
-
-            cr = CreditExchange(
-                user=credit.user,
-                amount=new_credit_amt,
-                sell_amount=new_credit_amt,
-                sell_req=None,
-                buy_req=self,
-                currency=credit.currency,
-                address=credit.address,
-                block=credit.block)
-
-            db.session.add(cr)
-            i += 1
+            current_app.logger.info(
+                "Successfully updated trade request {:,} making "
+                "amount {:,} payable and {:,} stuck.".
+                format(self.id, payable_amount, stuck_quantity))
 
         db.session.flush()
 
@@ -160,11 +171,7 @@ def distribute(self, stuck_quantity):
                 "Successfully pushed trade result for request id {:,} and "
                 "amount {:,} to {:,} credits.".
                 format(self.id, self.exchanged_quantity, len(credits)))
-        elif self._status == 5:
-            current_app.logger.info(
-                "Successfully updated trade request {:,} making "
-                "amount {:,} payable and {:,} stuck.".
-                format(self.id, payable_amount, stuck_quantity))
+
 
     @property
     def credits(self):
diff --git a/simplecoin/scheduler.py b/simplecoin/scheduler.py
index 9760e23a..6a438bc8 100644
--- a/simplecoin/scheduler.py
+++ b/simplecoin/scheduler.py
@@ -1,7 +1,7 @@
 import logging
 import itertools
 import datetime
-from pprint import pprint
+from pprint import pformat
 import time
 import simplejson as json
 import urllib3
@@ -169,7 +169,7 @@ def create_payouts():
         payout_summary[currency] += payout.amount
 
     current_app.logger.info("############### SUMMARY OF PAYOUTS GENERATED #####################")
-    current_app.logger.info(pprint(payout_summary))
+    current_app.logger.info(pformat(payout_summary))
 
     db.session.commit()
 
@@ -441,6 +441,7 @@ def _distributor(amount, splits, scale=None, addtl_prec=0):
     fashion. `addtl_prec` allows you to specify additional precision for
     computing share remainders, allowing a higher likelyhood of fair
     distribution of amount remainders among keys. Usually not needed.  """
+
     scale = int(scale or 28) * -1
     amount = Decimal(amount)
 
diff --git a/simplecoin/tests/test_payout.py b/simplecoin/tests/test_payout.py
index 0ebe08bc..38d34da6 100644
--- a/simplecoin/tests/test_payout.py
+++ b/simplecoin/tests/test_payout.py
@@ -2,6 +2,7 @@
 import flask
 import unittest
 import random
+import decimal
 
 from simplecoin import db, currencies
 from simplecoin.scheduler import _distributor
@@ -257,11 +258,15 @@ def test_update_tr_buy(self):
             credits.append(c)
             db.session.add(c)
 
-        # raise TypeError([credit.__dict__ for credit in credits])
-
         db.session.commit()
-        push_data = {'trs': {tr.id: {"status": 5, "quantity": "150",
-                                     "fees": "1", "stuck_quantity": "40"}}}
+
+        posted_payable_amt = 150
+        posted_stuck_amt = 40
+        posted_fees = 1
+        push_data = {'trs': {tr.id: {"status": 5,
+                                     "quantity": str(posted_payable_amt),
+                                     "fees": str(posted_fees),
+                                     "stuck_quantity": str(posted_stuck_amt)}}}
         db.session.expunge_all()
 
         with self.app.test_request_context('/?name=Peter'):
@@ -275,26 +280,34 @@ def test_update_tr_buy(self):
         tr2 = m.TradeRequest.query.first()
         credits2 = m.CreditExchange.query.all()
 
-        # Assert that the total hasn't changed
-        credit_amt = sum([credit.amount for credit in credits2])
-        # print credit_amt
-        # print tr.quantity
-        # assert credit_amt == 0
-        assert credit_amt == tr.quantity
-
         # Assert that the payable amount is 150
-        payable_amt = sum([credit.buy_amount for credit in credits2 if credit.payable is True])
-        print payable_amt
-        # assert payable_amt == 0
-        assert payable_amt == 150
-
-        # Assert that the stuck amount is 40
-        stuck_amt = sum([credit.buy_amount for credit in credits2 if credit.payable is False])
-        # for credit in credits2:
-        #     print "{}, {}".format(credit.id, credit.amount)
-        print stuck_amt
-        # assert stuck_amt == 0
-        assert stuck_amt == 40
+        with decimal.localcontext(decimal.BasicContext) as ctx:
+            ctx.traps[decimal.Inexact] = True
+            ctx.prec = 100
+
+            # Assert that the the new payable amount is 150
+            payable_amt = sum([credit.buy_amount for credit in credits2 if credit.payable is True])
+            assert payable_amt == posted_payable_amt
+
+            # Assert that the stuck amount is 40
+            stuck_amt = sum([credit.buy_amount for credit in credits2 if credit.payable is False])
+            assert stuck_amt == posted_stuck_amt
+
+            # Check that the total BTC quantity represented hasn't changed
+            btc_quant = sum([credit.amount for credit in credits2])
+            assert btc_quant == tr2.quantity
+
+            # Check that the old credits BTC amounts look sane
+            old_btc_quant = sum([credit.amount for credit in credits2 if credit.payable is True])
+            assert old_btc_quant / tr2.avg_price == posted_payable_amt
+
+            # Check that the new credits BTC amounts look sane
+            new_btc_quant = sum([credit.amount for credit in credits2 if credit.payable is False])
+            assert new_btc_quant / tr2.avg_price == posted_stuck_amt
+
+            # Check that fee calculations
+
+            # Check that new credit attrs are the same as old (fees, etc)
 
         # Assert that the status is 5, partially completed
         assert tr2._status == 5

From 65b0a71a783119931ced15cc58fead4c72d128d0 Mon Sep 17 00:00:00 2001
From: Eric Cook <eric@simpload.com>
Date: Wed, 1 Oct 2014 11:32:07 -0500
Subject: [PATCH 4/9] Fixes a few more bugs + adds more tests

---
 simplecoin/models.py            | 32 ++++++++++++++++++++------------
 simplecoin/tests/test_payout.py | 23 ++++++++++++++++++-----
 2 files changed, 38 insertions(+), 17 deletions(-)

diff --git a/simplecoin/models.py b/simplecoin/models.py
index a4cf2109..e54df6aa 100755
--- a/simplecoin/models.py
+++ b/simplecoin/models.py
@@ -58,7 +58,7 @@ class TradeRequest(base):
 
     # The quantity of the desired currency received by fulfilling this request
     exchanged_quantity = db.Column(db.Numeric, default=None)
-    # Fees from fulfilling this tr
+    # Fees from fulfilling this tr (represented in Currency, not BTC)
     fees = db.Column(db.Numeric, default=None)
     _status = db.Column(db.SmallInteger, default=0)
 
@@ -69,9 +69,9 @@ def currency_fees(self):
     @property
     def avg_price(self):
         if self.type == "buy":
-            return self.quantity / self.exchanged_quantity
+            return self.quantity / (self.exchanged_quantity + self.fees)
         elif self.type == "sell":
-            return self.exchanged_quantity / self.quantity
+            return (self.exchanged_quantity + self.fees) / self.quantity
 
     def distribute(self, stuck_quantity):
         assert self.type in ["buy", "sell"], "Invalid type!"
@@ -86,9 +86,9 @@ def distribute(self, stuck_quantity):
         # Check config to see if we're charging exchange fees or not
         payable_amount = self.exchanged_quantity - stuck_quantity
 
-        # Check config to see if we're charging exchange fees or not
-        if current_app.config.get('charge_autoex_fees', False):
-            payable_amount -= self.fees
+        # 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 += self.fees
 
         # Remove previously paid amounts from the payable amount
         if self.type == "buy":
@@ -123,15 +123,22 @@ def distribute(self, stuck_quantity):
             credit_amts = {credit.id: credit.amount for credit in credits}
 
             # Get the distribution for the stuck amount
-            curr_distrib = distributor(stuck_quantity, credit_amts)
+            amts_copy = credit_amts.copy()
+            curr_distrib = distributor(stuck_quantity, amts_copy)
+
+            # 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)
+
+            # Calculate the BTC distribution, based on the stuck currency amounts
+            amts_copy = credit_amts.copy()
+            new_btc_distrib = distributor(btc_distrib['new'], amts_copy)
 
             with decimal.localcontext(decimal.BasicContext) as ctx:
                 ctx.traps[decimal.Inexact] = True
                 ctx.prec = 100
 
-                # Calculate the BTC distribution, based on the stuck currency amounts
-                btc_distrib = {k: v * self.avg_price for k, v in curr_distrib.iteritems()}
-
                 i = 0
                 orig_len = len(credits)
                 # Loop + add a new credit for each old credit
@@ -139,12 +146,13 @@ def distribute(self, stuck_quantity):
                     credit = credits[i]
 
                     # subtract the credits cut from the old credit's amount
-                    credit.amount -= btc_distrib[credit.id]
+                    credit.amount -= new_btc_distrib[credit.id]
                     # Create a new credit for the remaining cut
-                    new_credit_amt = btc_distrib[credit.id]
+                    new_credit_amt = new_btc_distrib[credit.id]
 
                     cr = CreditExchange(
                         user=credit.user,
+                        sharechain_id=credit.sharechain_id,
                         amount=new_credit_amt,
                         sell_amount=new_credit_amt,
                         buy_amount=curr_distrib[credit.id],
diff --git a/simplecoin/tests/test_payout.py b/simplecoin/tests/test_payout.py
index 38d34da6..daf31ef9 100644
--- a/simplecoin/tests/test_payout.py
+++ b/simplecoin/tests/test_payout.py
@@ -260,7 +260,7 @@ def test_update_tr_buy(self):
 
         db.session.commit()
 
-        posted_payable_amt = 150
+        posted_payable_amt = 149
         posted_stuck_amt = 40
         posted_fees = 1
         push_data = {'trs': {tr.id: {"status": 5,
@@ -282,9 +282,13 @@ def test_update_tr_buy(self):
 
         # Assert that the payable amount is 150
         with decimal.localcontext(decimal.BasicContext) as ctx:
-            ctx.traps[decimal.Inexact] = True
+            # ctx.traps[decimal.Inexact] = True
             ctx.prec = 100
 
+            # Check config to see if we're charging exchange fees or not
+            if self.app.config.get('cover_autoex_fees', False):
+                posted_payable_amt += posted_fees
+
             # Assert that the the new payable amount is 150
             payable_amt = sum([credit.buy_amount for credit in credits2 if credit.payable is True])
             assert payable_amt == posted_payable_amt
@@ -299,15 +303,24 @@ def test_update_tr_buy(self):
 
             # Check that the old credits BTC amounts look sane
             old_btc_quant = sum([credit.amount for credit in credits2 if credit.payable is True])
-            assert old_btc_quant / tr2.avg_price == posted_payable_amt
+            assert (old_btc_quant / tr2.avg_price) - posted_fees == posted_payable_amt
 
             # Check that the new credits BTC amounts look sane
             new_btc_quant = sum([credit.amount for credit in credits2 if credit.payable is False])
             assert new_btc_quant / tr2.avg_price == posted_stuck_amt
 
-            # Check that fee calculations
-
             # 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
 
         # Assert that the status is 5, partially completed
         assert tr2._status == 5

From 4a090d9d81ca6125060e4aedbb292fa7c8a94cd4 Mon Sep 17 00:00:00 2001
From: Eric Cook <eric@simpload.com>
Date: Wed, 1 Oct 2014 13:34:35 -0500
Subject: [PATCH 5/9] Adds another test section to ensure a follow up update_tr
 with status 6 will function as expected

---
 simplecoin/models.py            | 24 +++++++++------
 simplecoin/rpc_views.py         | 20 +++++++-----
 simplecoin/tests/test_payout.py | 54 +++++++++++++++++++++++++++++++++
 3 files changed, 81 insertions(+), 17 deletions(-)

diff --git a/simplecoin/models.py b/simplecoin/models.py
index e54df6aa..360e7395 100755
--- a/simplecoin/models.py
+++ b/simplecoin/models.py
@@ -73,7 +73,7 @@ def avg_price(self):
         elif self.type == "sell":
             return (self.exchanged_quantity + self.fees) / self.quantity
 
-    def distribute(self, stuck_quantity):
+    def distribute(self, stuck_quantity, applied_fees):
         assert self.type in ["buy", "sell"], "Invalid type!"
         assert self.exchanged_quantity > 0
 
@@ -88,29 +88,32 @@ def distribute(self, 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 += self.fees
+            payable_amount += applied_fees
 
         # Remove previously paid amounts from the payable amount
         if self.type == "buy":
-            for credit in credits:
-                if credit.buy_amount is not None:
-                    payable_amount -= credit.buy_amount
+            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}
+            portions = {c.id: c.sell_amount for c in credits if c.payable is False}
 
-        amounts = distributor(payable_amount, portions)
+        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.buy_amount is None:
+                if credit.payable is False:
                     credit.buy_amount = amounts[credit.id]
                     # Mark the credit ready for payout to users
                     credit.payable = True
@@ -137,7 +140,7 @@ def distribute(self, stuck_quantity):
 
             with decimal.localcontext(decimal.BasicContext) as ctx:
                 ctx.traps[decimal.Inexact] = True
-                ctx.prec = 100
+                ctx.prec = 50
 
                 i = 0
                 orig_len = len(credits)
@@ -147,6 +150,7 @@ def distribute(self, stuck_quantity):
 
                     # subtract the credits cut from the old credit's amount
                     credit.amount -= new_btc_distrib[credit.id]
+                    credit.sell_amount -= new_btc_distrib[credit.id]
                     # Create a new credit for the remaining cut
                     new_credit_amt = new_btc_distrib[credit.id]
 
@@ -156,6 +160,7 @@ def distribute(self, stuck_quantity):
                         amount=new_credit_amt,
                         sell_amount=new_credit_amt,
                         buy_amount=curr_distrib[credit.id],
+                        # buy_amount=None,
                         sell_req=None,
                         buy_req=self,
                         currency=credit.currency,
@@ -175,6 +180,7 @@ def distribute(self, stuck_quantity):
         db.session.flush()
 
         if self._status == 6:
+            assert stuck_quantity == 0
             current_app.logger.info(
                 "Successfully pushed trade result for request id {:,} and "
                 "amount {:,} to {:,} credits.".
diff --git a/simplecoin/rpc_views.py b/simplecoin/rpc_views.py
index 05b4ff69..673e63a4 100644
--- a/simplecoin/rpc_views.py
+++ b/simplecoin/rpc_views.py
@@ -66,10 +66,10 @@ 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:
-                assert 'stuck_quantity' in tr
-                assert 'quantity' in tr
-                assert 'fees' in tr
-    except (AssertionError, TypeError):
+                tr['stuck_quantity'] = Decimal(tr['stuck_quantity'])
+                tr['quantity'] = Decimal(tr['quantity'])
+                tr['fees'] = Decimal(tr['fees'])
+    except (AssertionError, TypeError, KeyError):
         current_app.logger.warn("Invalid data passed to update_sell_requests",
                                 exc_info=True)
         abort(400)
@@ -83,10 +83,14 @@ def update_trade_requests():
             tr._status = status
 
             if status == 5 or status == 6:
-                tr.exchanged_quantity = Decimal(tr_dict['quantity']) + Decimal(tr_dict['stuck_quantity'])
-                tr.fees = Decimal(tr_dict['fees'])
-                stuck_quantity = Decimal(tr_dict['stuck_quantity'])
-                tr.distribute(stuck_quantity)
+                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)
 
         except Exception:
             db.session.rollback()
diff --git a/simplecoin/tests/test_payout.py b/simplecoin/tests/test_payout.py
index daf31ef9..048c7b00 100644
--- a/simplecoin/tests/test_payout.py
+++ b/simplecoin/tests/test_payout.py
@@ -325,6 +325,60 @@ def test_update_tr_buy(self):
         # Assert that the status is 5, partially completed
         assert tr2._status == 5
 
+    def test_close_after_update_tr_buy(self):
+
+        self.test_update_tr_buy()
+
+        tr = m.TradeRequest.query.first()
+
+        # Check that another update can be pushed.
+        posted_payable_amt = 188.5
+        posted_stuck_amt = 0
+        posted_fees = 1.5
+        push_data = {'trs': {tr.id: {"status": 6,
+                                     "quantity": str(posted_payable_amt),
+                                     "fees": str(posted_fees),
+                                     "stuck_quantity": str(posted_stuck_amt)}}}
+        db.session.expunge_all()
+
+        with self.app.test_request_context('/?name=Peter'):
+            flask.g.signer = TimedSerializer(self.app.config['rpc_signature'])
+            flask.g.signed = push_data
+            update_trade_requests()
+
+        db.session.rollback()
+        db.session.expunge_all()
+
+        tr2 = m.TradeRequest.query.first()
+        credits2 = m.CreditExchange.query.all()
+
+        # Assert that the payable amount is 150
+        with decimal.localcontext(decimal.BasicContext) as ctx:
+            # ctx.traps[decimal.Inexact] = True
+            ctx.prec = 100
+
+            # Check config to see if we're charging exchange fees or not
+            if self.app.config.get('cover_autoex_fees', False):
+                posted_payable_amt += posted_fees
+
+            # Assert that the the total payable amount is what we posted
+            payable_amt = sum([credit.buy_amount for credit in credits2 if credit.payable is True])
+            assert payable_amt == posted_payable_amt
+            total_curr_quant = sum([credit.buy_amount for credit in credits2])
+            assert total_curr_quant + Decimal(posted_fees) == 190
+
+            # Check that the total BTC quantity equals out
+            btc_quant = sum([credit.amount for credit in credits2])
+            assert btc_quant == tr2.quantity
+
+            # Check that the BTC amounts look sane
+            btc_quant = sum([credit.amount for credit in credits2 if credit.payable is True])
+            assert (btc_quant / tr2.avg_price) - Decimal(posted_fees) == posted_payable_amt
+
+            # Check that there is nothing marked unpayable
+            not_payable = sum([credit.amount for credit in credits2 if credit.payable is False])
+            assert not not_payable
+
 
 class TestPayouts(RedisUnitTest):
     test_block_data = {

From 3468d2e160fc62be3fc497fc009c6c127bb6cb5c Mon Sep 17 00:00:00 2001
From: Eric Cook <eric@simpload.com>
Date: Wed, 1 Oct 2014 13:43:23 -0500
Subject: [PATCH 6/9] Minor cleanup

---
 simplecoin/models.py            | 4 ----
 simplecoin/tests/test_payout.py | 3 +--
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/simplecoin/models.py b/simplecoin/models.py
index 360e7395..d2c19fb4 100755
--- a/simplecoin/models.py
+++ b/simplecoin/models.py
@@ -62,10 +62,6 @@ class TradeRequest(base):
     fees = db.Column(db.Numeric, default=None)
     _status = db.Column(db.SmallInteger, default=0)
 
-    @property
-    def currency_fees(self):
-        return self.fees * self.avg_price
-
     @property
     def avg_price(self):
         if self.type == "buy":
diff --git a/simplecoin/tests/test_payout.py b/simplecoin/tests/test_payout.py
index 048c7b00..09b775e0 100644
--- a/simplecoin/tests/test_payout.py
+++ b/simplecoin/tests/test_payout.py
@@ -280,9 +280,8 @@ def test_update_tr_buy(self):
         tr2 = m.TradeRequest.query.first()
         credits2 = m.CreditExchange.query.all()
 
-        # Assert that the payable amount is 150
         with decimal.localcontext(decimal.BasicContext) as ctx:
-            # ctx.traps[decimal.Inexact] = True
+            ctx.traps[decimal.Inexact] = True
             ctx.prec = 100
 
             # Check config to see if we're charging exchange fees or not

From 2d823d827a484e7adf09ccb1a5e3b7346842c53d Mon Sep 17 00:00:00 2001
From: Eric Cook <eric@simpload.com>
Date: Fri, 3 Oct 2014 14:12:54 -0500
Subject: [PATCH 7/9] minor cleanups to new code

---
 simplecoin/models.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/simplecoin/models.py b/simplecoin/models.py
index d2c19fb4..5a8b8e8f 100755
--- a/simplecoin/models.py
+++ b/simplecoin/models.py
@@ -92,14 +92,16 @@ def distribute(self, stuck_quantity, applied_fees):
                 ctx.traps[decimal.Inexact] = True
                 ctx.prec = 100
 
-                payable_amount -= sum([credit.buy_amount for credit in credits if credit.payable is True])
+                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}
+            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)
@@ -156,7 +158,6 @@ def distribute(self, stuck_quantity, applied_fees):
                         amount=new_credit_amt,
                         sell_amount=new_credit_amt,
                         buy_amount=curr_distrib[credit.id],
-                        # buy_amount=None,
                         sell_req=None,
                         buy_req=self,
                         currency=credit.currency,

From e3c1ffb07176c18dcc5d7c6a1a71dcb8bd1f93d8 Mon Sep 17 00:00:00 2001
From: Isaac Cook <isaac@simpload.com>
Date: Sat, 11 Oct 2014 20:23:26 -0500
Subject: [PATCH 8/9] WIP. Almost complete adaptation to new splitting/trade
 management strategy

---
 simplecoin/models.py            | 186 ++++++++++++++++++++------------
 simplecoin/rpc_views.py         |  12 +--
 simplecoin/tests/test_payout.py |  21 ++--
 3 files changed, 131 insertions(+), 88 deletions(-)

diff --git a/simplecoin/models.py b/simplecoin/models.py
index 5a8b8e8f..c5c19111 100755
--- a/simplecoin/models.py
+++ b/simplecoin/models.py
@@ -42,6 +42,45 @@ 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
@@ -49,17 +88,14 @@ class TradeRequest(base):
     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
diff --git a/simplecoin/rpc_views.py b/simplecoin/rpc_views.py
index 673e63a4..fa2aaa8f 100644
--- a/simplecoin/rpc_views.py
+++ b/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()
diff --git a/simplecoin/tests/test_payout.py b/simplecoin/tests/test_payout.py
index 09b775e0..40814517 100644
--- a/simplecoin/tests/test_payout.py
+++ b/simplecoin/tests/test_payout.py
@@ -269,7 +269,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()
@@ -311,15 +311,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

From c4bb46571ce8745b7d729943cf9caef58f379420 Mon Sep 17 00:00:00 2001
From: Isaac Cook <isaac@simpload.com>
Date: Sat, 11 Oct 2014 23:10:14 -0500
Subject: [PATCH 9/9] Should be a bit closer now...

---
 simplecoin/models.py | 168 ++++++++++++++++++++-----------------------
 1 file changed, 76 insertions(+), 92 deletions(-)

diff --git a/simplecoin/models.py b/simplecoin/models.py
index c5c19111..48bb72e9 100755
--- a/simplecoin/models.py
+++ b/simplecoin/models.py
@@ -58,28 +58,6 @@ class TradeResult(base):
     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):
     """
@@ -141,81 +119,87 @@ def update(self, quantity, source_quantity, fees):
                 "Nothing to update, quantity and source_quantity have not changed")
             return
 
-        new_tr = TradeResult(quantity=source_quantity - source_total,
-                             exchanged_quantity=quantity - destination_total,
-                             fees=fees - fee_total)
-        db.session.add(new_tr)
+        new_result = TradeResult(quantity=source_quantity - source_total,
+                                 exchanged_quantity=quantity - destination_total,
+                                 fees=fees - fee_total)
+        db.session.add(new_result)
 
-        distribute_amount = new_tr.exchanged_quantity
+        distribute_amount = new_result.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
+            distribute_amount -= new_result.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
-            new_btc_distrib = distributor(btc_distrib['new'], amts.copy())
-
-            with decimal.localcontext(decimal.BasicContext) as ctx:
-                # A sufficiently large number that we don't cause rounding
-                # error
-                ctx.prec = 50
-
-                i = 0
-                # Loop + add a new credit for each old credit
-                while i < len(credits):
-                    credit = credits[i]
-
-                    # subtract the credits cut from the old credit's amount
-                    credit.amount -= new_btc_distrib[credit.id]
-                    credit.sell_amount -= new_btc_distrib[credit.id]
-                    # Create a new credit for the remaining cut
-                    new_credit_amt = new_btc_distrib[credit.id]
-
-                    cr = CreditExchange(
-                        user=credit.user,
-                        sharechain_id=credit.sharechain_id,
-                        amount=new_credit_amt,
-                        sell_amount=new_credit_amt,
-                        buy_amount=curr_distrib[credit.id],
-                        sell_req=None,
-                        buy_req=self,
-                        currency=credit.currency,
-                        address=credit.address,
-                        fee_perc=credit.fee_perc,
-                        pd_perc=credit.pd_perc,
-                        block=credit.block)
-
-                    db.session.add(cr)
-                    i += 1
-
-            current_app.logger.info(
-                "Successfully updated trade request {:,} making "
-                "amount {:,} payable and {:,} stuck.".
-                format(self.id, payable_amount, stuck_quantity))
-
-        if source_quantity == self.quantity:
+        if total_unpaid > distribute_amount:
+            ratio = {'traded': total_unpaid - distribute_amount, 'remaining': distribute_amount}
+
+            payable_credits = []
+            for credit in unpaid_credits:
+                # Copy the original credit's metadata
+                split_credit = CreditExchange(
+                    user=credit.user,
+                    sharechain_id=credit.sharechain_id,
+                    sell_req=credit.sell_req,
+                    buy_req=credit.sell_req,
+                    currency=credit.currency,
+                    address=credit.address,
+                    fee_perc=credit.fee_perc,
+                    pd_perc=credit.pd_perc,
+                    block=credit.block)
+
+                # Calculate the new CreditExchange's amount, and sell amount if
+                # this is a buy trade request
+                new_amounts = distributor(credit.amount, ratio)
+                if self.type == "buy":
+                    new_sell_amounts = distributor(credit.sell_amount, ratio)
+                split_credit.amount = new_amounts['traded']
+                split_credit.sell_amount = new_sell_amounts['traded']
+                credit.amount = new_amounts['remaining']
+                credit.sell_amount = new_sell_amounts['remaining']
+
+                db.session.add(split_credit)
+                payable_credits.append(split_credit)
+
+            # Populate the id values of the new credits
+            db.session.flush()
+            current_app.logger.info("Successfully split {:,} credits."
+                                    .format(len(unpaid_credits)))
+            self._status = 5
+        elif total_unpaid == distribute_amount:
             self._status = 6
+            payable_credits = unpaid_credits
         else:
-            self._status = 5
+            raise ValueError("We have been told that more currency was "
+                             "traded then what we requested!")
+
+        # Set the trade result object
+        for credit in payable_credits:
+            if self.type == "buy":
+                credit.buy_result = new_result
+                credit.payable = True
+            else:
+                credit.sell_result = new_result
 
-        db.session.flush()
+        # calculate user payouts based on percentage of the total
+        # exchanged value
+        if self.type == "sell":
+            portions = {c.id: c.amount for c in payable_credits}
+        elif self.type == "buy":
+            portions = {c.id: c.sell_amount for c in payable_credits}
+        amounts = distributor(new_result.exchanged_quantity, portions)
+
+        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
 
         current_app.logger.info(
             "Successfully pushed trade result for request id {:,} and "
@@ -559,16 +543,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_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],
+    #buy_res_id = db.Column(db.Integer, db.ForeignKey('trade_result.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_res = db.relationship('TradeResult', foreign_keys=[buy_req_id],
+    #                          backref='buy_credits')
     buy_amount = db.Column(db.Numeric)
 
     @property