Merge pull request #50 from dscotese/1.2.14Taxes

1.2.14 taxes

Author: dscotese

README.md

@@ -206,7 +206,7 @@ XLTC ...
 ...
 ```
 2. Retrieves the list of open orders, which is immediately processed to:
-   1.  replace conditional closes resulting from partial executions with a single conditional close which, itself, has a conditional close to continue buying and selling between the two prices, but only up to the amount originally specified, and _only_ for orders with a User Reference Number (such as all orders placed through this program).
+   1.  replace conditional closes resulting from partial executions with a single conditional close which, itself, has a conditional close to continue buying and selling between the two prices, but only up to the amount originally specified, and _only_ for orders with a User Reference Number (such as all orders placed through this program). Note: If you place a conditional close order with a price that matches one side of an existing grid point and it executes, creating the conditional close, that new order will be added in with the others, increasing the size of the trade around that grid point.
    2.  fill out the internal record of buy/sell prices using the open orders and their conditional closes (see [set](#set) and [reset](#reset)).
    3.  extend the grid if there are only buys or only sells remaining for the crypto identified in each order.
    4.  identify any orders that are gone or new using Kraken's Order ID and for new orders, it also describes them.

balancer.js

@@ -126,7 +126,8 @@ module.exports = function Balancer (target) {
                 bot.getLev(bot.portfolio,'sell',sP,sAmt,po.base,false),
                 p.type=='buy'?Ordered.uref:0,p.price);
         }
-console.log({high,low,cryptp,qf,atargU,atargD,curVal,curP,toSell,toBuy,sAmt,bAmt,sP,bP,Ordered});
+if(bot.FLAGS.verbose)
+    console.log({high,low,cryptp,qf,atargU,atargD,curVal,curP,toSell,toBuy,sAmt,bAmt,sP,bP,Ordered});
     }
 
     return {setTrades};

bot.js

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 process.TESTING = process.TESTING || !(/init.js$|kraken-grid$/.test(process.argv[1]));
-console.log("filename is ",process.argv[1],"in "+(process.TESTING?'test':'production')+" mode.");
+if(process.argv.length > 2) process.TESTING = process.argv[2];
+console.log("filename is ",process.argv[1],"in "+(process.TESTING
+    ? 'test ('+process.TESTING+")"
+    :'production')+" mode.");
 const Manager = require('./manager.js');
 const Bot = require('./bot.js');
 const Web = require('./web.js');
 let bot = Bot();
 let man = Manager(bot);
 //let web = Web(manager);
-if(!process.TESTING) man.init();
+man.init();
 // else  manager.init();
 // For testing purposes, we provide these two items
 // They will not be ready for use until manager.init is done,

init.js

@@ -40,7 +40,7 @@ function Manager(b) {
         savings = require('./savings.js');
         /*if(!process.TESTING)*/ await bot.report(true);
         savings().setTickers(Bot.tickers);
-        if(!process.TESTING) listen();
+        if(!process.TESTING || process.argv.length > 2) listen();
         else {
             console.log("42:",portfolio);
             this.already = true;
@@ -95,19 +95,19 @@ function Manager(b) {
        Note that handleArgs handles string arguments as collected from process.stdin.
        This means that true and 1, as args, are strings, not a boolean and a number.
      */
-    async function handleArgs(bot, portfolio, args, uref = 0) {
+    async function handleArgs(bot, args, uref = 0, p = portfolio) {
         if(['args',whoami()].includes(process.TESTING))
             console.log(whoami(),"called with ",arguments);
         let buysell,xmrbtc,price,amt,posP;
         if(/^(buy|sell)$/.test(args[0])) {
             let pair;
             [buysell,xmrbtc,price,amt,posP] = args;
-            pair = Bot.findPair(xmrbtc, portfolio.Numeraire, -1);
+            pair = Bot.findPair(xmrbtc, p.Numeraire, -1);
             if(pair) xmrbtc = pair[1].base;
-            if( 'undefined' == typeof(portfolio[xmrbtc]) ) {
+            if( 'undefined' == typeof(p[xmrbtc]) ) {
                 // Try the asset's altname
                 // -----------------------
-                if('undefined' == typeof(portfolio[Bot.alts[xmrbtc]]))
+                if('undefined' == typeof(p[Bot.alts[xmrbtc]]))
                     throw new Error(xmrbtc+" is not a recognized symbol.  Try 'asset' command.");
                 console.log("Using",Bot.alts[xmrbtc],"instead of",xmrbtc);
                 xmrbtc = Bot.alts[xmrbtc];
@@ -119,12 +119,12 @@ function Manager(b) {
 
             // Do we need leverage?
             // --------------------
-            let lev = bot.getLev(portfolio,buysell,price,amt,xmrbtc,posP);
-            let cPrice = !isNaN(portfolio['G'][uref]) 
-                ? portfolio['G'][uref][buysell=='buy'?'sell':'buy'] : 0;
+            let lev = bot.getLev(p,buysell,price,amt,xmrbtc,posP);
+            let cPrice = !isNaN(p['G'][uref]) 
+                ? p['G'][uref][buysell=='buy'?'sell':'buy'] : 0;
             // Without a record of a closing price, use the last one we found.
             // ---------------------------------------------------------------
-            if(!cPrice) cPrice = portfolio[xmrbtc][1];
+            if(!cPrice) cPrice = p[xmrbtc][1];
             // When passing 1 as close, it will mean close at 1 (if Risky) 
             // or at current price (without Risky)
             // -----------------------------------------------------------
@@ -135,16 +135,16 @@ function Manager(b) {
             console.log("New order: "+ret);
             return;
         } else if(args[0] == 'set') {
-            await bot.set(portfolio, args[1], args[2], args[3]);
+            await bot.set(p, args[1], args[2], args[3]);
         } else if(args[0] == 'reset') {
-            portfolio['G'] = [];
-            await bot.listOpens(portfolio);
+            p['G'] = [];
+            await bot.listOpens();
         } else if(args[0] == 'delev') {
-            await bot.deleverage(portfolio['O'],args[1]-1);
+            await bot.deleverage(p['O'],args[1]-1);
         } else if(args[0] == 'addlev') {
-            await bot.deleverage(portfolio['O'],args[1]-1,true);
+            await bot.deleverage(p['O'],args[1]-1,true);
         } else if(args[0] == 'refnum') {
-            await bot.refnum(portfolio['O'],args[1]-1,args[2]);
+            await bot.refnum(p['O'],args[1]-1,args[2]);
         } else if(args[0] == 'list') {
             await bot.list(args);
         } else if(/^(less|more)$/.test(args[0])) {
@@ -159,7 +159,7 @@ function Manager(b) {
             }
             let label = args[3] ? args[3] : "default",
                 tkr = 'REMOVE' == args[1] ? args[2] : args[1],
-                account = portfolio.Savings.find(a => a.label == label);
+                account = p.Savings.find(a => a.label == label);
             if(Bot.alts[tkr]) tkr = Bot.alts[tkr];
             if(!account) {
                 if('REMOVE' == args[1]) {
@@ -175,15 +175,15 @@ function Manager(b) {
                     assets:[{ticker:tkr,amount:Number(args[2])}]
                 });
                 console.log("Created new account, ", label);
-                portfolio.Savings.push(JSON.parse(account.save()));
+                p.Savings.push(JSON.parse(account.save()));
                if(args[3]) account.labelMe(args[3]);
             } else {
                 account = savings(account);
             }
             if('REMOVE' == args[1]) {
                 if('ACCOUNT' == args[2].toUpperCase()) {
-                    let smaller = portfolio.Savings.filter(x => x.label != args[3]);
-                    portfolio.Savings = smaller;
+                    let smaller = p.Savings.filter(x => x.label != args[3]);
+                    p.Savings = smaller;
                     bot.save();
                     console.log("Account",label,"has been removed.");
                 } else {
@@ -200,10 +200,10 @@ function Manager(b) {
                 bot.save();
             }
         } else if(args[0] == 'assets') {
-            let sav,pnum = portfolio.Numeraire;
-                ret = portfolio.Savings.length + ': ';
-            for(h=0;h < portfolio.Savings.length; ++h) {
-                sav = savings(portfolio.Savings[h]);
+            let sav,pnum = p.Numeraire;
+                ret = p.Savings.length + ': ';
+            for(h=0;h < p.Savings.length; ++h) {
+                sav = savings(p.Savings[h]);
                 if(!(args[1]) || sav.label == args[1])
                     console.log(h, sav.list());
                 else if(args[1]) {
@@ -214,7 +214,7 @@ function Manager(b) {
             // Include the assets on the Exchange
             // ----------------------------------
             sav = savings({ label:'OnExchange', assets:
-                [{ticker:pnum, amount:portfolio[pnum][0]}]});
+                [{ticker:pnum, amount:p[pnum][0]}]});
             return ret;
         } else if(args[0] == 'allocation') {
             let d = await getAllocation(true),c; // Desired
@@ -285,8 +285,8 @@ function Manager(b) {
             if('undefined' == typeof(alloc)
                 || isNaN(p) || isNaN(a)) {
                 console.log(usage);
-            } else if(a<0||p<0||a>100*alloc.target||p>100) {
-                console.log("apct must be between 0 and",100*alloc.target,
+            } else if(a<0||p<0||a>100*(1-alloc.target)||p>100) {
+                console.log("apct must be between 0 and",100-100*alloc.target,
                     "and ppct must be between zero and 100.");
             } else {
                 t = alloc.ticker;
@@ -297,14 +297,14 @@ function Manager(b) {
             if(args.length < 3 || isNaN(args[1]) || isNaN(args[2])) {
                 console.log("Usage: limits AtLeast AtMost\n" +
                     "The allocation command will make trades only if the\n" +
-                    "amount in "+portfolio.Numeraire+" is at least the \n" +
+                    "amount in "+p.Numeraire+" is at least the \n" +
                     "AtLeast amount and no more than the AtMost amount.\n" +
                     "If AtMost is -1, there is no upper limit (dangerous!).");
             } else if(Number(args[1]) > Number(args[2]) && -1 != Number(args[2])) {
                 console.log("Doing nothing becuase you seem to have\n" +
                     "switched the arguments.");
             } else {
-                portfolio.limits = [Number(args[1]),Number(args[2])];
+                p.limits = [Number(args[1]),Number(args[2])];
                 bot.save();
             }
         } else if(args[0] == 'test') {
@@ -336,7 +336,7 @@ function Manager(b) {
             let args = cmds[cdx++].split(' ').map((x) => { return x.trim(); });
             console.log("...("+cdx+")> "+args.join(' '));
             //try {
-            if(args[0] == 'kill') await bot.kill(args[1],bot.portfolio['O']);
+            if(args[0] == 'kill') await bot.kill(args[1],portfolio['O']);
 	    	else if(args[0] == "keys") { await bot.keys(); }
 		    else if(args[0] == "ws") {
                 if(kwsCheck) console.log("Kraken WebSocket heartbeat at "+kwsCheck);
@@ -379,9 +379,9 @@ function Manager(b) {
             } else if(args[0] == 'margin') {
                 await bot.marginReport();
             } else if(args[0] == 'show') {
-                if(args[2]) console.log(args[2],{value:bot.portfolio[args[1]][args[2]]});
-                if(args[1]) console.log(args[1],{value:bot.portfolio[args[1]]});
-                else console.log({Portfolio:bot.portfolio,Bot});
+                if(args[2]) console.log(args[2],{value:portfolio[args[1]][args[2]]});
+                else if(args[1]) console.log(args[1],{value:portfolio[args[1]]});
+                else console.log({Portfolio:portfolio,Bot});
             } else if(args[0] == 'web') {
                 if(args[1]) {
                     if(args[1].toUpperCase() == 'ON') 
@@ -392,7 +392,7 @@ function Manager(b) {
                         + "This starts the web interface or stops it.");
                 }
             } else {
-                ret = await handleArgs(bot, bot.portfolio, args, 0);
+                ret = await handleArgs(bot, args, 0);
                 if(bot.FLAGS.verbose) console.log(ret);
             }
             //}

manager.js

@@ -1,6 +1,6 @@
 {
   "name": "kraken-grid",
-  "version": "1.2.13",
+  "version": "1.2.14",
   "description": "Bot repeatedly buys & sells on kraken from a conditional close order.",
   "main": "init.js",
   "bin": "./init.js",

package.json

@@ -0,0 +1,120 @@
+function Reports(bot) {
+    let offset = 0,
+        closed = {offset:0, forward:false, orders:{}};
+    const TxIDPattern = /[0-9A-Z]{6}-[0-9A-Z]{5}-[0-9A-Z]{6}/; 
+
+    // This function will collect count executed orders in reverse chronological order,
+	// first the most recent (ofs=0) and then earlier history (ofs from known).
+    async function getExecuted(count, known = {}) {
+        if(!known.hasOwnProperty('orders')) { // Is old format or not collected yet
+            known = {orders:{}};
+            console.log("known passed has no 'orders' property.");
+        }
+        console.log("Known:",Object.keys(known.orders).length,
+            "Closed:",Object.keys(closed.orders).length, [known.offset,closed.offset]);
+	if(Object.keys(known.orders).length > Object.keys(closed.orders).length)
+            Object.assign(closed,known);
+        while(count > 0 && offset > -1) {
+            let mixed = await bot.kapi(['ClosedOrders',{ofs:offset, closetime:'close'}]),
+		total = mixed.result.count;
+            if(mixed.error.length > 0) {
+                console.log("Errors:\n",mixed.error.join("\n"));
+            }
+            console.log("At",offset,"of",total,"results.");
+            // If more orders closed since our previous call, they will
+            //  push everything further down the list and cause some old
+            //  orders to be reported again.  These duplicates do not
+            //  cause a problem when the list of closed orders is an object
+            //  because the later assignments to the TxID (key) overwrite
+            //  the earlier ones.
+            // ClosedOrders might return pending, open canceled, and expired
+            //  orders too.  Remove them.
+            // ------------------------------------------------------
+            let executed = Object.entries(mixed.result.closed).filter((e) =>
+                (e[1].status == 'closed')),
+                rCount = Object.keys(mixed.result.closed).length,
+		elen = executed.length;
+	    offset += rCount;
+	    // If offset >= total, we have collected the earliest order
+		// so we can collect only new ones (returned first) from now
+		// on. This is what it means when offset on disk is -1.
+            // If known.offset is -1 then the only orders left to collect
+            // are the newest ones, and if the first one we get is already
+            // in known.orders, then there are no new ones and we have everything.
+            // -------------------------------------------------------------------
+	    closed.offset = ((offset >= total 
+                || (known.orders.hasOwnProperty(executed[0][0]) && known.offset == -1))
+                ? -1 : offset);
+            count -= elen;
+	    console.log("Retrieved",elen,"executed orders.");
+            const KRAKEN_GCO_MAX = 50;
+            Object.assign(closed.orders, Object.fromEntries(executed));
+	    if(rCount < KRAKEN_GCO_MAX) {  // We must have reached the earliest order.
+		if(closed.offset > -1) // Should be impossible, so...
+		    throw(offset+" still < "+total+" API returns < 50");
+		console.log("Total Executed orders collected: "
+                    +(Object.keys(closed.orders).length));
+		count = 0;
+            } else if(Object.keys(known.orders || {}).includes(executed[executed.length-1][0])) {
+                // Last order retrieved already on disk
+                console.log("Jumping to the end... ("+known.offset+")");
+		offset = known.offset;	// so jump to the end.
+                closed.offset = offset;
+            }
+        }
+	closed = keyOrder(closed);
+        // We set offset to 0 when done because we must ask for more
+        // orders since some may have executed since the previous call.
+        offset = offset == -1 ? 0 : offset;
+        return closed;
+    }
+
+    // This function adds an iterator and the "forward" key to iterate
+    //  through the orders property backwards or forwards.
+    // ---------------------------------------------------------------
+    function keyOrder(keyed, pattern = TxIDPattern) {
+        keyed['forward'] = true;
+        let keys = Object.keys(keyed.orders),
+            K = keys.filter((x) => (pattern.test(x)));
+        if( keys.length > K.length ) { // Keys that don't match.
+            console.log("Ignoring",(keys.length - K.length,"non-matching keys:"));
+            console.log(keys.filter((x) => (!pattern.test(x))));
+        }
+
+        K.sort((a,b) => (keyed.orders[a].closetm - keyed.orders[b].closetm));
+        let Kr = K.toReversed();
+
+        keyed.orders[Symbol.iterator] = function* () {
+            for( const key of (keyed.forward ? K : Kr) ) yield key;
+        }
+        return keyed;
+    }
+
+    function yearStart() {
+        const now = new Date();
+        const yearStart = new Date(now.getFullYear(), 0, 1);
+        return yearStart.getTime();
+    }
+
+    // This ensures all orders have been retrieved
+    //  and provides whatever information it can about the process.
+    async function capGains() {
+        let started = Date.now();
+        let notBefore = yearStart();
+        // Let's not go back before the beginning of the year
+        while(closed[closed.length].opentm > notBefore/1000) {
+            await getExecuted();
+            if( Date.now() - started > 5 ) {
+                console.log("I'm stopping after five seconds.");
+                return;
+            }
+        }
+        console.log("I've collected",closed.length,
+            " orders, and that goes back to ",
+            Date(closed[closed.length].opentm));
+    }
+
+    return {getExecuted, capGains};
+}
+
+module.exports = Reports;