From 76cd9f404857b916435df223ebe8f930ea70026e Mon Sep 17 00:00:00 2001
From: quetzalcoatl <quetzalcoatl.pl@gmail.com>
Date: Wed, 24 Oct 2018 09:20:53 +0200
Subject: [PATCH 1/7] added bunch of tests that show that and64/or64/shift64
 are unsafe for large numbers that may be treated as signed

---
 curation_calculator.html | 171 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 171 insertions(+)

diff --git a/curation_calculator.html b/curation_calculator.html
index 63af62f..bfcf4e1 100644
--- a/curation_calculator.html
+++ b/curation_calculator.html
@@ -507,5 +507,176 @@ <h3>
       return hi*Math.pow(2,32) + lo;
     }   
   </script>
+
+  <script type="text/javascript">
+    // some simple tests for bitwise ops
+    var Tests = {};
+
+    Tests.hi_lo = {
+      low: () => {
+        var hl = hi_lo(1078);
+        if(bin64(hl.hi) != '0000000000000000000000000000000000000000000000000000000000000000') return "failed: hi";
+        if(bin64(hl.lo) != '0000000000000000000000000000000000000000000000000000010000110110') return "failed: lo";
+        return true;
+      },
+      high: () => {
+        var hl = hi_lo(17179869182);
+        if(bin64(hl.hi) != '0000000000000000000000000000000000000000000000000000000000000011') return "failed: hi";
+        if(bin64(hl.lo) != '0000000000000000000000000000000011111111111111111111111111111110') return "failed: lo";
+        return true;
+      },
+    };
+
+    Tests.and64 = {
+      low: () => {
+        // 2nd arg: 32bitmask, all '1', bitvalue shouldn't change
+        var val = and64(1078,4294967295);
+        if(bin64(val) != '0000000000000000000000000000000000000000000000000000010000110110') return "failed";
+        return true;
+      },
+      high: () => {
+        // 2nd arg: 36bitmask, all '1', bitvalue shouldn't change
+        var val = and64(17179869182,4294967295*16+15);
+        if(bin64(val) != '0000000000000000000000000000001111111111111111111111111111111110') return "failed";
+        return true;
+      },
+    };
+
+    Tests.or64 = {
+      low: () => {
+        // 2nd arg: all '0', bitvalue shouldn't change
+        var val = or64(1078,0);
+        if(bin64(val) != '0000000000000000000000000000000000000000000000000000010000110110') return "failed";
+        return true;
+      },
+      high: () => {
+        // 2nd arg: all '0', bitvalue shouldn't change
+        var val = or64(17179869182,0);
+        if(bin64(val) != '0000000000000000000000000000001111111111111111111111111111111110') return "failed";
+        return true;
+      },
+    };
+
+    Tests.shiftleft64 = {
+      low: () => {
+        var val = shiftleft64(1078,16);
+        if(bin64(val) != '0000000000000000000000000000000000000100001101100000000000000000') return "failed";
+        return true;
+      },
+      low_almostlastbit: () => {
+        var val = shiftleft64(1078,52);
+        if(bin64(val) != '0100001101100000000000000000000000000000000000000000000000000000') return "failed";
+        return true;
+      },
+      low_lastbit: () => {
+        var val = shiftleft64(1078,53);
+        if(bin64(val) != '1000011011000000000000000000000000000000000000000000000000000000') return "failed";
+        return true;
+      },
+      low_overflow: () => {
+        var val = shiftleft64(1078,54);
+        if(bin64(val) != '0000110110000000000000000000000000000000000000000000000000000000') return "failed";
+        return true;
+      },
+
+      high: () => {
+        var val = shiftleft64(17179869182,16);
+        if(bin64(val) != '0000000000000011111111111111111111111111111111100000000000000000') return "failed";
+        return true;
+      },
+      high_almostlastbit: () => {
+        var val = shiftleft64(17179869182,29);
+        if(bin64(val) != '0111111111111111111111111111111111000000000000000000000000000000') return "failed";
+        return true;
+      },
+      high_lastbit: () => {
+        var val = shiftleft64(17179869182,30);
+        if(bin64(val) != '1111111111111111111111111111111110000000000000000000000000000000') return "failed";
+        return true;
+      },
+      high_overflow: () => {
+        var val = shiftleft64(17179869182,31);
+        if(bin64(val) != '1111111111111111111111111111111100000000000000000000000000000000') return "failed";
+        return true;
+      },
+    };
+
+    Tests.shiftright64 = {
+      // shiftright64 should be inverse of shiftleft64, except for cases when shiftleft64 overflows
+      low: () => {
+        var val = shiftright64(parseInt('0000000000000000000000000000000000000100001101100000000000000000',2),16);
+        if(val != 1078) return "failed";
+        return true;
+      },
+      low_almostlastbit: () => {
+        var val = shiftright64(parseInt('0100001101100000000000000000000000000000000000000000000000000000',2),52);
+        if(val != 1078) return "failed";
+        return true;
+      },
+      // in our case, shiftright64 should never return negatives,
+      // even if MSB of the input is set and input value could look like a negative
+      low_lastbit: () => {
+        var val = shiftright64(parseInt('1000011011000000000000000000000000000000000000000000000000000000',2),53);
+        if(val != 1078) return "failed";
+        return true;
+      },
+
+      high: () => {
+        var val = shiftright64(parseInt('0000000000000011111111111111111111111111111111100000000000000000',2),16);
+        if(val != 17179869182) return "failed";
+        return true;
+      },
+      high_almostlastbit: () => {
+        var val = shiftright64(parseInt('0111111111111111111111111111111111000000000000000000000000000000',2),29);
+        if(val != 17179869182) return "failed";
+        return true;
+      },
+      // in our case, shiftright64 should never return negatives,
+      // even if MSB of the input is set and input value could look like a negative
+      high_lastbit: () => {
+        var val = shiftright64(parseInt('1111111111111111111111111111111110000000000000000000000000000000',2),30);
+        if(val != 17179869182) return "failed";
+        return true;
+      },
+    };
+
+    /*
+      results before patch, original code gitrev:514d9bb6ed6c9a07c4e595947ab71fe424a49845
+      On: Google Chrome 69.0.3497.100, Windows 10 x64
+        and64: high: failed
+        or64: high: failed
+        shiftleft64: low: failed
+        shiftleft64: low_overflow: failed
+        shiftleft64: high_overflow: failed
+        shiftright64: low: failed
+        Failed 6/20 tests
+    */
+
+    // FYI: doing that this way will have funny effects if 'n' is negative (i.e. -7 = '0000000000-111')
+    // but we don't care - 'n' should be positive and any funny effects will fail the test so it's OK
+    function bin64(n) {
+      return n.toString(2).padStart(64,'0');
+    }
+
+    // right now, I don't want to make fuss and install Jasmine/etc, so here's my quick'n'dirty test runner
+    function runTests(suite) {
+      var testlist = Object.keys(Tests).map(k => Object.keys(Tests[k]).map(k2 => ({outer:k,inner:k2})));
+      testlist = testlist.flat();
+      var results = testlist.map(what => {
+        var result = suite[what.outer][what.inner]();
+        if(result === true) return [true, what.outer, what.inner, null];
+        console.log(what.outer + ": " + what.inner + ": " + result);
+        return [false, what.outer, what.inner, result];
+      });
+      var countfailed = results.filter(arr => !arr[0]).length;
+      if(countfailed > 0) {
+        console.log("Failed " + countfailed + "/" + results.length + " tests");
+        return false;
+      }
+      else
+        return true;
+    }
+
+    </script>
 </body>
 </html>

From 9d31391342b93e0f1e5a9de995db49288a73619d Mon Sep 17 00:00:00 2001
From: quetzalcoatl <quetzalcoatl.pl@gmail.com>
Date: Wed, 24 Oct 2018 09:23:23 +0200
Subject: [PATCH 2/7] forced and64/or64 result to be unsigned

---
 curation_calculator.html | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/curation_calculator.html b/curation_calculator.html
index bfcf4e1..b622ed4 100644
--- a/curation_calculator.html
+++ b/curation_calculator.html
@@ -479,16 +479,16 @@ <h3>
     function and64(x,y){
       x = hi_lo(x);
       y = hi_lo(y);
-      hi = x.hi & y.hi;
-      lo = x.lo & y.lo;
+      hi = (x.hi & y.hi) >>> 0;
+      lo = (x.lo & y.lo) >>> 0;
       return hi*Math.pow(2,32) + lo;
     }
 
     function or64(x,y){
       x = hi_lo(x);
       y = hi_lo(y);
-      hi = x.hi | y.hi;
-      lo = x.lo | y.lo;
+      hi = (x.hi | y.hi) >>> 0;
+      lo = (x.lo | y.lo) >>> 0;
       return hi*Math.pow(2,32) + lo;
     }
 

From d7334df225021e1f6afda585a0ee8f1a853ce847 Mon Sep 17 00:00:00 2001
From: quetzalcoatl <quetzalcoatl.pl@gmail.com>
Date: Wed, 24 Oct 2018 09:25:41 +0200
Subject: [PATCH 3/7] corrected and simplified both shift64, added truncation
 to shiftleft64 to ensure it returns integer not longer than 64bit

---
 curation_calculator.html | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/curation_calculator.html b/curation_calculator.html
index b622ed4..3cd97ef 100644
--- a/curation_calculator.html
+++ b/curation_calculator.html
@@ -493,19 +493,12 @@ <h3>
     }
 
     function shiftleft64(x,y){
-      x = hi_lo(x);  
-      hi = x.hi * Math.pow(2,y);
-      lo = x.lo * Math.pow(2,y);
-      return hi*Math.pow(2,32) + lo;
+      return (x * Math.pow(2,y)) % Math.pow(2,64); // mod64 as a safeguard against 'val' exceeding 64bit integer range
     }
 
     function shiftright64(x,y){
-      x = hi_lo(x);
-      hi = Math.floor(x.hi / Math.pow(2,y));
-      aux = x.hi % Math.pow(2,y);
-      lo = Math.floor(x.lo / Math.pow(2,y)) + aux * Math.pow(2,32-y);
-      return hi*Math.pow(2,32) + lo;
-    }   
+      return Math.floor(x / Math.pow(2,y));
+    }
   </script>
 
   <script type="text/javascript">

From d025b2a4f84486fd5f2c3510c68c185d79ce649f Mon Sep 17 00:00:00 2001
From: quetzalcoatl <quetzalcoatl.pl@gmail.com>
Date: Wed, 24 Oct 2018 09:27:11 +0200
Subject: [PATCH 4/7] refactor/cleanup: no need to recalculate true constants

---
 curation_calculator.html | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/curation_calculator.html b/curation_calculator.html
index 3cd97ef..03d8a0c 100644
--- a/curation_calculator.html
+++ b/curation_calculator.html
@@ -469,10 +469,13 @@ <h3>
       return Math.floor(Math.log(x)/Math.log(2));
     }
 
+    const BIT32_LIMIT = Math.pow(2,32);
+    const BIT64_LIMIT = Math.pow(2,64);
+
     function hi_lo(x){
       r = {};
-      r.hi = Math.floor(x / Math.pow(2,32));
-      r.lo = x % Math.pow(2,32);
+      r.hi = Math.floor(x / BIT32_LIMIT);
+      r.lo = x % BIT32_LIMIT;
       return r;  
     }
 
@@ -481,7 +484,7 @@ <h3>
       y = hi_lo(y);
       hi = (x.hi & y.hi) >>> 0;
       lo = (x.lo & y.lo) >>> 0;
-      return hi*Math.pow(2,32) + lo;
+      return hi*BIT32_LIMIT + lo;
     }
 
     function or64(x,y){
@@ -489,11 +492,11 @@ <h3>
       y = hi_lo(y);
       hi = (x.hi | y.hi) >>> 0;
       lo = (x.lo | y.lo) >>> 0;
-      return hi*Math.pow(2,32) + lo;
+      return hi*BIT32_LIMIT + lo;
     }
 
     function shiftleft64(x,y){
-      return (x * Math.pow(2,y)) % Math.pow(2,64); // mod64 as a safeguard against 'val' exceeding 64bit integer range
+      return (x * Math.pow(2,y)) % BIT64_LIMIT; // mod64 as a safeguard against 'val' exceeding 64bit integer range
     }
 
     function shiftright64(x,y){

From 00d0452bea9a74cb09991c02f908f136a8af7fba Mon Sep 17 00:00:00 2001
From: quetzalcoatl <quetzalcoatl.pl@gmail.com>
Date: Wed, 24 Oct 2018 09:49:34 +0200
Subject: [PATCH 5/7] refactor/cleanup: added 'var' to limit scope of some
 variables, just in case

---
 curation_calculator.html | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/curation_calculator.html b/curation_calculator.html
index 03d8a0c..cbdc87b 100644
--- a/curation_calculator.html
+++ b/curation_calculator.html
@@ -449,18 +449,18 @@ <h3>
     //Functions for Approx SQRT (see https://github.com/steemit/steem/blob/5c787c5baa651858658caa2bd47473846b099c0a/doc/sqrt.md)
     function approx_sqrt(x){
       if(x == 0) return 0;
-      msb_x = find_msb(x);
-      msb_z = msb_x >> 1;
+      var msb_x = find_msb(x);
+      var msb_z = msb_x >> 1;
   
-      msb_x_bit = shiftleft64(1,msb_x);
-      msb_z_bit = shiftleft64(1,msb_z);
+      var msb_x_bit = shiftleft64(1,msb_x);
+      var msb_z_bit = shiftleft64(1,msb_z);
   
-      mantissa_mask = msb_x_bit - 1;
-      mantissa_x = and64(x,mantissa_mask);
-      mantissa_z_hi = and64(msb_x,1) ? msb_z_bit : 0;
-      mantissa_z_lo = shiftright64(mantissa_x , msb_x - msb_z);
-      mantissa_z = shiftright64(or64(mantissa_z_hi , mantissa_z_lo) , 1);
-      result = or64(msb_z_bit , mantissa_z);
+      var mantissa_mask = msb_x_bit - 1;
+      var mantissa_x = and64(x,mantissa_mask);
+      var mantissa_z_hi = and64(msb_x,1) ? msb_z_bit : 0;
+      var mantissa_z_lo = shiftright64(mantissa_x , msb_x - msb_z);
+      var mantissa_z = shiftright64(or64(mantissa_z_hi , mantissa_z_lo) , 1);
+      var result = or64(msb_z_bit , mantissa_z);
       
       return result;
     }
@@ -473,7 +473,7 @@ <h3>
     const BIT64_LIMIT = Math.pow(2,64);
 
     function hi_lo(x){
-      r = {};
+      var r = {};
       r.hi = Math.floor(x / BIT32_LIMIT);
       r.lo = x % BIT32_LIMIT;
       return r;  
@@ -482,16 +482,16 @@ <h3>
     function and64(x,y){
       x = hi_lo(x);
       y = hi_lo(y);
-      hi = (x.hi & y.hi) >>> 0;
-      lo = (x.lo & y.lo) >>> 0;
+      var hi = (x.hi & y.hi) >>> 0;
+      var lo = (x.lo & y.lo) >>> 0;
       return hi*BIT32_LIMIT + lo;
     }
 
     function or64(x,y){
       x = hi_lo(x);
       y = hi_lo(y);
-      hi = (x.hi | y.hi) >>> 0;
-      lo = (x.lo | y.lo) >>> 0;
+      var hi = (x.hi | y.hi) >>> 0;
+      var lo = (x.lo | y.lo) >>> 0;
       return hi*BIT32_LIMIT + lo;
     }
 

From 1a16452a784223a8af6f9b45414a3f0b50024d9f Mon Sep 17 00:00:00 2001
From: quetzalcoatl <quetzalcoatl.pl@gmail.com>
Date: Wed, 24 Oct 2018 09:49:56 +0200
Subject: [PATCH 6/7] improved sqrt's sanity check, our approx algo is NOT safe
 for negatives

---
 curation_calculator.html | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/curation_calculator.html b/curation_calculator.html
index cbdc87b..eafad78 100644
--- a/curation_calculator.html
+++ b/curation_calculator.html
@@ -448,7 +448,9 @@ <h3>
     
     //Functions for Approx SQRT (see https://github.com/steemit/steem/blob/5c787c5baa651858658caa2bd47473846b099c0a/doc/sqrt.md)
     function approx_sqrt(x){
-      if(x == 0) return 0;
+      // we don't want to let the code aproximate sqrts from negative inputs..
+      if(x <= 0) return 0;
+
       var msb_x = find_msb(x);
       var msb_z = msb_x >> 1;
   

From ac72109379c713419bbaa1af30222e8c9bbe7aaa Mon Sep 17 00:00:00 2001
From: quetzalcoatl <quetzalcoatl.pl@gmail.com>
Date: Wed, 24 Oct 2018 09:52:19 +0200
Subject: [PATCH 7/7] added note how to run these tests

---
 curation_calculator.html | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/curation_calculator.html b/curation_calculator.html
index eafad78..61b9526 100644
--- a/curation_calculator.html
+++ b/curation_calculator.html
@@ -508,6 +508,9 @@ <h3>
 
   <script type="text/javascript">
     // some simple tests for bitwise ops
+    // run it in the browser console for example by:
+    //   runTests(Tests);
+
     var Tests = {};
 
     Tests.hi_lo = {