bin/crowdnode.js

   1 #!/usr/bin/env node
   2 "use strict";
   3 /*jshint maxcomplexity:25 */
   4
   5 require("dotenv").config({ path: ".env" });
   6 require("dotenv").config({ path: ".env.secret" });
   7
   8 let pkg = require("../package.json");
   9
  10 let Fs = require("fs").promises;
  11
  12 let CrowdNode = require("../lib/crowdnode.js");
  13 let Dash = require("../lib/dash.js");
  14 let Insight = require("../lib/insight.js");
  15 let Qr = require("../lib/qr.js");
  16 let Ws = require("../lib/ws.js");
  17
  18 let Dashcore = require("@dashevo/dashcore-lib");
  19
  20 const DUFFS = 100000000;
  21 let qrWidth = 2 + 67 + 2;
  22 // Sign Up Fees:
  23 //   0.00236608 // required for signup
  24 //   0.00002000 // TX fee estimate
  25 //   0.00238608 // minimum recommended amount
  26 // Target:
  27 //   0.01000000
  28 let signupOnly = CrowdNode.requests.signupForApi + CrowdNode.requests.offset;
  29 let acceptOnly = CrowdNode.requests.acceptTerms + CrowdNode.requests.offset;
  30 let signupFees = signupOnly + acceptOnly;
  31 let feeEstimate = 500;
  32 let signupTotal = signupFees + 2 * feeEstimate;
  33
  34 function showQr(signupAddr, duffs = 0) {
  35   let signupUri = `dash://${signupAddr}`;
  36   if (duffs) {
  37     signupUri += `?amount=${duffs}`;
  38   }
  39
  40   let signupQr = Qr.ascii(signupUri, { indent: 4 });
  41   let addrPad = Math.ceil((qrWidth - signupUri.length) / 2);
  42
  43   console.info(signupQr);
  44   console.info();
  45   console.info(" ".repeat(addrPad) + signupUri);
  46 }
  47
  48 function showVersion() {
  49   console.info(`${pkg.name} v${pkg.version} - ${pkg.description}`);
  50   console.info();
  51 }
  52
  53 function showHelp() {
  54   showVersion();
  55
  56   console.info("Usage:");
  57   console.info("    crowdnode help");
  58   console.info("    crowdnode status ./privkey.wif");
  59   console.info("    crowdnode signup ./privkey.wif");
  60   console.info("    crowdnode accept ./privkey.wif");
  61   console.info(
  62     "    crowdnode deposit ./privkey.wif [dash-amount] [--no-reserve]",
  63   );
  64   console.info(
  65     "    crowdnode withdrawal ./privkey.wif <percent> # 1.0-100.0 (steps by 0.1)",
  66   );
  67   console.info("");
  68
  69   console.info("Helpful Extras:");
  70   console.info("    crowdnode generate [./privkey.wif]");
  71   console.info("    crowdnode balance ./privkey.wif");
  72   console.info(
  73     "    crowdnode transfer ./source.wif <key-file-or-pub-addr> [dash-amount]",
  74   );
  75   console.info("");
  76
  77   console.info("CrowdNode HTTP RPC:");
  78   console.info("    crowdnode http FundsOpen <addr>");
  79   console.info("    crowdnode http VotingOpen <addr>");
  80   console.info("    crowdnode http GetFunds <addr>");
  81   console.info("    crowdnode http GetFundsFrom <addr> <seconds-since-epoch>");
  82   console.info("    crowdnode http GetBalance <addr>");
  83   console.info("    crowdnode http GetMessages <addr>");
  84   console.info("    crowdnode http IsAddressInUse <addr>");
  85   // TODO create signature rather than requiring it
  86   console.info("    crowdnode http SetEmail ./privkey.wif <email> <signature>");
  87   console.info("    crowdnode http Vote ./privkey.wif <gobject-hash> ");
  88   console.info("        <Yes|No|Abstain|Delegate|DoNothing> <signature>");
  89   console.info(
  90     "    crowdnode http SetReferral ./privkey.wif <referral-id> <signature>",
  91   );
  92   console.info("");
  93 }
  94
  95 function removeItem(arr, item) {
  96   let index = arr.indexOf(item);
  97   if (index >= 0) {
  98     return arr.splice(index, 1)[0];
  99   }
 100   return null;
 101 }
 102
 103 async function main() {
 104   // Usage:
 105   //    crowdnode <subcommand> [flags] <privkey> [options]
 106   // Example:
 107   //    crowdnode withdrawal ./Xxxxpubaddr.wif 100.0
 108
 109   let args = process.argv.slice(2);
 110
 111   // flags
 112   let forceConfirm = removeItem(args, "--unconfirmed");
 113   let noReserve = removeItem(args, "--no-reserve");
 114
 115   let subcommand = args.shift();
 116
 117   if (!subcommand || ["--help", "-h", "help"].includes(subcommand)) {
 118     showHelp();
 119     process.exit(0);
 120     return;
 121   }
 122
 123   if (["--version", "-V", "version"].includes(subcommand)) {
 124     showVersion();
 125     process.exit(0);
 126     return;
 127   }
 128
 129   if ("generate" === subcommand) {
 130     await generate(args.shift());
 131     return;
 132   }
 133
 134   let insightBaseUrl =
 135     process.env.INSIGHT_BASE_URL || "https://insight.dash.org";
 136   let insightApi = Insight.create({ baseUrl: insightBaseUrl });
 137   let dashApi = Dash.create({ insightApi: insightApi });
 138
 139   process.stdout.write("Checking CrowdNode API... ");
 140   await CrowdNode.init({
 141     baseUrl: "https://app.crowdnode.io",
 142     insightBaseUrl,
 143     insightApi: insightApi,
 144   });
 145   console.info(`hotwallet is ${CrowdNode.main.hotwallet}`);
 146
 147   let rpc = "";
 148   if ("http" === subcommand) {
 149     rpc = args.shift();
 150     let keyfile = args.shift();
 151     let pub = await wifFileToAddr(keyfile);
 152
 153     // ex: http <rpc>(<pub>, ...)
 154     args.unshift(pub);
 155     let hasRpc = rpc in CrowdNode.http;
 156     if (!hasRpc) {
 157       console.error(`Unrecognized rpc command ${rpc}`);
 158       console.error();
 159       showHelp();
 160       process.exit(1);
 161     }
 162     let result = await CrowdNode.http[rpc].apply(null, args);
 163     if ("string" === typeof result) {
 164       console.info(result);
 165     } else {
 166       console.info(JSON.stringify(result, null, 2));
 167     }
 168     return;
 169   }
 170
 171   let keyfile = args.shift();
 172   let privKey;
 173   if (keyfile) {
 174     privKey = await Fs.readFile(keyfile, "utf8");
 175     privKey = privKey.trim();
 176   } else {
 177     privKey = process.env.PRIVATE_KEY;
 178   }
 179   if (!privKey) {
 180     // TODO generate private key?
 181     console.error();
 182     console.error(
 183       `Error: you must provide either the WIF key file path or PRIVATE_KEY in .env`,
 184     );
 185     console.error();
 186     process.exit(1);
 187   }
 188
 189   let pk = new Dashcore.PrivateKey(privKey);
 190   let pub = pk.toPublicKey().toAddress().toString();
 191
 192   // deposit if balance is over 100,000 (0.00100000)
 193   process.stdout.write("Checking balance... ");
 194   let balanceInfo = await dashApi.getInstantBalance(pub);
 195   console.info(`${balanceInfo.balanceSat} (Đ${balanceInfo.balance})`);
 196   /*
 197   let balanceInfo = await insightApi.getBalance(pub);
 198   if (balanceInfo.unconfirmedBalanceSat || balanceInfo.unconfirmedAppearances) {
 199     if (!forceConfirm) {
 200       console.error(
 201         `Error: This address has pending transactions. Please try again in 1-2 minutes or use --unconfirmed.`,
 202       );
 203       console.error(balanceInfo);
 204       if ("status" !== subcommand) {
 205         process.exit(1);
 206         return;
 207       }
 208     }
 209   }
 210   */
 211
 212   let state = {
 213     balanceInfo: balanceInfo,
 214     dashApi: dashApi,
 215     forceConfirm: forceConfirm,
 216     hotwallet: CrowdNode.main.hotwallet,
 217     insightBaseUrl: insightBaseUrl,
 218     insightApi: insightApi,
 219     noReserve: noReserve,
 220     privKey: privKey,
 221     pub: pub,
 222
 223     // status
 224     status: {
 225       signup: 0,
 226       accept: 0,
 227       deposit: 0,
 228     },
 229     signup: "❌",
 230     accept: "❌",
 231     deposit: "❌",
 232   };
 233
 234   if ("balance" === subcommand) {
 235     await balance(args, state);
 236     process.exit(0);
 237     return;
 238   }
 239
 240   // helper for debugging
 241   if ("transfer" === subcommand) {
 242     await transfer(args, state);
 243     return;
 244   }
 245
 246   state.status = await CrowdNode.status(pub, state.hotwallet);
 247   if (state.status?.signup) {
 248     state.signup = "✅";
 249   }
 250   if (state.status?.accept) {
 251     state.accept = "✅";
 252   }
 253   if (state.status?.deposit) {
 254     state.deposit = "✅";
 255   }
 256
 257   if ("status" === subcommand) {
 258     await status(args, state);
 259     return;
 260   }
 261
 262   if ("signup" === subcommand) {
 263     await signup(args, state);
 264     return;
 265   }
 266
 267   if ("accept" === subcommand) {
 268     await accept(args, state);
 269     return;
 270   }
 271
 272   if ("deposit" === subcommand) {
 273     await deposit(args, state);
 274     return;
 275   }
 276
 277   if ("withdrawal" === subcommand) {
 278     await withdrawal(args, state);
 279     return;
 280   }
 281
 282   console.error(`Unrecognized subcommand ${subcommand}`);
 283   console.error();
 284   showHelp();
 285   process.exit(1);
 286 }
 287
 288 // Subcommands
 289
 290 async function generate(name) {
 291   let pk = new Dashcore.PrivateKey();
 292
 293   let pub = pk.toAddress().toString();
 294   let wif = pk.toWIF();
 295
 296   let filepath = `./${pub}.wif`;
 297   let note = "";
 298   if (name) {
 299     filepath = name;
 300     note = `\n(for pubkey address ${pub})`;
 301   }
 302
 303   let err = await Fs.access(filepath).catch(Object);
 304   if (!err) {
 305     // TODO show QR anyway
 306     //wif = await Fs.readFile(filepath, 'utf8')
 307     //showQr(pub, 0.01);
 308     console.info(`'${filepath}' already exists (will not overwrite)`);
 309     process.exit(0);
 310     return;
 311   }
 312
 313   await Fs.writeFile(filepath, wif, "utf8").then(function () {
 314     console.info(``);
 315     console.info(
 316       `Use the QR Code below to load a test deposit of Đ0.01 onto your staking key.`,
 317     );
 318     console.info(``);
 319     showQr(pub, 0.01);
 320     console.info(``);
 321     console.info(
 322       `Use the QR Code above to load a test deposit of Đ0.01 onto your staking key.`,
 323     );
 324     console.info(``);
 325     console.info(`Generated ${filepath} ${note}`);
 326   });
 327   process.exit(0);
 328 }
 329
 330 async function balance(args, state) {
 331   console.info(state.balanceInfo);
 332   process.exit(0);
 333   return;
 334 }
 335
 336 // ex: node ./bin/crowdnode.js transfer ./priv.wif 'pub' 0.01
 337 async function transfer(args, state) {
 338   let newAddr = await wifFileToAddr(process.argv[4]);
 339   let dashAmount = parseFloat(process.argv[5] || 0);
 340   let duffAmount = Math.round(dashAmount * DUFFS);
 341   let tx;
 342   if (duffAmount) {
 343     tx = await state.dashApi.createPayment(state.privKey, newAddr, duffAmount);
 344   } else {
 345     tx = await state.dashApi.createBalanceTransfer(state.privKey, newAddr);
 346   }
 347   if (duffAmount) {
 348     console.info(
 349       `Transferring ${duffAmount} (Đ${dashAmount}) to ${newAddr}...`,
 350     );
 351   } else {
 352     console.info(`Transferring balance to ${newAddr}...`);
 353   }
 354   await state.insightApi.instantSend(tx);
 355   console.info(`Queued...`);
 356   setTimeout(function () {
 357     // TODO take a cleaner approach
 358     // (waitForVout needs a reasonable timeout)
 359     console.error(`Error: Transfer did not complete.`);
 360     if (state.forceConfirm) {
 361       console.error(`(using --unconfirmed may lead to rejected double spends)`);
 362     }
 363     process.exit(1);
 364   }, 30 * 1000);
 365   await Ws.waitForVout(state.insightBaseUrl, newAddr, 0);
 366   console.info(`Accepted!`);
 367   process.exit(0);
 368   return;
 369 }
 370
 371 async function status(args, state) {
 372   console.info();
 373   console.info(`API Actions Complete for ${state.pub}:`);
 374   console.info(`    ${state.signup} SignUpForApi`);
 375   console.info(`    ${state.accept} AcceptTerms`);
 376   console.info(`    ${state.deposit} DepositReceived`);
 377   console.info();
 378   let pk = new Dashcore.PrivateKey(state.privKey);
 379   let pub = pk.toPublicKey().toAddress().toString();
 380   let crowdNodeBalance = await CrowdNode.http.GetBalance(pub);
 381   let crowdNodeDash = toDash(crowdNodeBalance.TotalBalance);
 382   console.info(
 383     `CrowdNode Stake: ${crowdNodeBalance.TotalBalance} (Đ${crowdNodeDash})`,
 384   );
 385   console.info();
 386   process.exit(0);
 387   return;
 388 }
 389
 390 async function signup(args, state) {
 391   if (state.status?.signup) {
 392     console.info(
 393       `${state.pub} is already signed up. Here's the account status:`,
 394     );
 395     console.info(`    ${state.signup} SignUpForApi`);
 396     console.info(`    ${state.accept} AcceptTerms`);
 397     console.info(`    ${state.deposit} DepositReceived`);
 398     process.exit(0);
 399     return;
 400   }
 401
 402   let hasEnough = state.balanceInfo.balanceSat > signupOnly + feeEstimate;
 403   if (!hasEnough) {
 404     await collectSignupFees(state.insightBaseUrl, state.pub);
 405   }
 406   console.info("Requesting account...");
 407   await CrowdNode.signup(state.privKey, state.hotwallet);
 408   state.signup = "✅";
 409   console.info(`    ${state.signup} SignUpForApi`);
 410   console.info(`    ${state.accept} AcceptTerms`);
 411   process.exit(0);
 412   return;
 413 }
 414
 415 async function accept(args, state) {
 416   if (state.status?.accept) {
 417     console.info(
 418       `${state.pub} is already signed up. Here's the account status:`,
 419     );
 420     console.info(`    ${state.signup} SignUpForApi`);
 421     console.info(`    ${state.accept} AcceptTerms`);
 422     console.info(`    ${state.deposit} DepositReceived`);
 423     process.exit(0);
 424     return;
 425   }
 426   let hasEnough = state.balanceInfo.balanceSat > acceptOnly + feeEstimate;
 427   if (!hasEnough) {
 428     await collectSignupFees(state.insightBaseUrl, state.pub);
 429   }
 430   console.info("Accepting terms...");
 431   await CrowdNode.accept(state.privKey, state.hotwallet);
 432   state.accept = "✅";
 433   console.info(`    ${state.signup} SignUpForApi`);
 434   console.info(`    ${state.accept} AcceptTerms`);
 435   console.info(`    ${state.deposit} DepositReceived`);
 436   process.exit(0);
 437   return;
 438 }
 439
 440 async function deposit(args, state) {
 441   if (!state.status?.accept) {
 442     console.error(`no account for address ${state.pub}`);
 443     process.exit(1);
 444     return;
 445   }
 446
 447   // this would allow for at least 2 withdrawals costing (21000 + 1000)
 448   let reserve = 50000;
 449   let reserveDash = toDash(reserve);
 450   if (!state.noReserve) {
 451     console.info(
 452       `reserving ${reserve} (Đ${reserveDash}) for withdrawals (--no-reserve to disable)`,
 453     );
 454   } else {
 455     reserve = 0;
 456   }
 457
 458   // TODO if unconfirmed, check utxos instead
 459
 460   // deposit what the user asks, or all that we have,
 461   // or all that the user deposits - but at least 2x the reserve
 462   let desiredAmountDash = parseFloat(args.shift() || 0);
 463   let desiredAmountDuff = Math.round(desiredAmountDash * DUFFS);
 464   let effectiveAmount = desiredAmountDuff;
 465   if (!effectiveAmount) {
 466     effectiveAmount = state.balanceInfo.balanceSat - reserve;
 467   }
 468   let needed = Math.max(reserve * 2, effectiveAmount + reserve);
 469
 470   if (state.balanceInfo.balanceSat < needed) {
 471     let ask = 0;
 472     if (desiredAmountDuff) {
 473       ask = desiredAmountDuff + reserve + -state.balanceInfo.balanceSat;
 474     }
 475     await collectDeposit(state.insightBaseUrl, state.pub, ask);
 476     state.balanceInfo = await state.dashApi.getInstantBalance(state.pub);
 477     if (state.balanceInfo.balanceSat < needed) {
 478       let balanceDash = toDash(state.balanceInfo.balanceSat);
 479       console.error(
 480         `Balance is still too small: ${state.balanceInfo.balanceSat} (Đ${balanceDash})`,
 481       );
 482       process.exit(1);
 483       return;
 484     }
 485   }
 486   if (!desiredAmountDuff) {
 487     effectiveAmount = state.balanceInfo.balanceSat - reserve;
 488   }
 489
 490   console.info(
 491     `(holding ${reserve} (Đ${reserveDash}) in reserve for API calls)`,
 492   );
 493   let effectiveDash = toDash(effectiveAmount);
 494   console.info(
 495     `Initiating deposit of ${effectiveAmount} (Đ${effectiveDash})...`,
 496   );
 497   await CrowdNode.deposit(state.privKey, state.hotwallet, effectiveAmount);
 498   state.deposit = "✅";
 499   console.info(`    ${state.deposit} DepositReceived`);
 500   process.exit(0);
 501   return;
 502 }
 503
 504 async function withdrawal(args, state) {
 505   if (!state.status?.accept) {
 506     console.error(`no account for address ${state.pub}`);
 507     process.exit(1);
 508     return;
 509   }
 510
 511   let percentStr = args.shift() || "100.0";
 512   // pass: .1 0.1, 1, 1.0, 10, 10.0, 100, 100.0
 513   // fail: 1000, 10.00
 514   if (!/^1?\d?\d?(\.\d)?$/.test(percentStr)) {
 515     console.error("Error: withdrawal percent must be between 0.1 and 100.0");
 516     process.exit(1);
 517   }
 518   let percent = parseFloat(percentStr);
 519
 520   let permil = Math.round(percent * 10);
 521   if (permil <= 0 || permil > 1000) {
 522     console.error("Error: withdrawal percent must be between 0.1 and 100.0");
 523     process.exit(1);
 524   }
 525
 526   let realPercentStr = (permil / 10).toFixed(1);
 527   console.info(`Initiating withdrawal of ${realPercentStr}...`);
 528
 529   let paid = await CrowdNode.withdrawal(state.privKey, state.hotwallet, permil);
 530   //let paidFloat = (paid.satoshis / DUFFS).toFixed(8);
 531   //let paidInt = paid.satoshis.toString().padStart(9, "0");
 532   console.info(`API Response: ${paid.api}`);
 533   process.exit(0);
 534   return;
 535 }
 536
 537 /*
 538 async function stake(args, state) {
 539   // TODO
 540   return;
 541 }
 542 */
 543
 544 // Helpers
 545
 546 async function wifFileToAddr(keyfile) {
 547   let privKey = keyfile;
 548
 549   let err = await Fs.access(keyfile).catch(Object);
 550   if (!err) {
 551     privKey = await Fs.readFile(keyfile, "utf8");
 552     privKey = privKey.trim();
 553   }
 554
 555   if (34 === privKey.length) {
 556     // actually payment addr
 557     return privKey;
 558   }
 559
 560   if (52 === privKey.length) {
 561     let pk = new Dashcore.PrivateKey(privKey);
 562     let pub = pk.toPublicKey().toAddress().toString();
 563     return pub;
 564   }
 565
 566   throw new Error("bad file path or address");
 567 }
 568
 569 async function collectSignupFees(insightBaseUrl, pub) {
 570   showQr(pub);
 571
 572   let signupTotalDash = (signupTotal / DUFFS).toFixed(8);
 573   let signupMsg = `Please send >= ${signupTotal} (Đ${signupTotalDash}) to Sign Up to CrowdNode`;
 574   let msgPad = Math.ceil((qrWidth - signupMsg.length) / 2);
 575   let subMsg = "(plus whatever you'd like to deposit)";
 576   let subMsgPad = Math.ceil((qrWidth - subMsg.length) / 2);
 577
 578   console.info();
 579   console.info(" ".repeat(msgPad) + signupMsg);
 580   console.info(" ".repeat(subMsgPad) + subMsg);
 581   console.info();
 582
 583   console.info("");
 584   console.info("(waiting...)");
 585   console.info("");
 586   let payment = await Ws.waitForVout(insightBaseUrl, pub, 0);
 587   console.info(`Received ${payment.satoshis}`);
 588 }
 589
 590 async function collectDeposit(insightBaseUrl, pub, duffAmount) {
 591   showQr(pub, duffAmount);
 592
 593   let depositMsg = `Please send what you wish to deposit to ${pub}`;
 594   if (duffAmount) {
 595     let depositDash = toDash(duffAmount);
 596     depositMsg = `Please deposit ${duffAmount} (Đ${depositDash}) to ${pub}`;
 597   }
 598
 599   let msgPad = Math.ceil((qrWidth - depositMsg.length) / 2);
 600   msgPad = Math.max(0, msgPad);
 601
 602   console.info();
 603   console.info(" ".repeat(msgPad) + depositMsg);
 604   console.info();
 605
 606   console.info("");
 607   console.info("(waiting...)");
 608   console.info("");
 609   let payment = await Ws.waitForVout(insightBaseUrl, pub, 0);
 610   console.info(`Received ${payment.satoshis}`);
 611 }
 612
 613 function toDash(duffs) {
 614   return (duffs / DUFFS).toFixed(8);
 615 }
 616
 617 // Run
 618
 619 main().catch(function (err) {
 620   console.error("Fail:");
 621   console.error(err.stack || err);
 622   process.exit(1);
 623 });