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   process.exit(0);
 379   return;
 380 }
 381
 382 async function signup(args, state) {
 383   if (state.status?.signup) {
 384     console.info(
 385       `${state.pub} is already signed up. Here's the account status:`,
 386     );
 387     console.info(`    ${state.signup} SignUpForApi`);
 388     console.info(`    ${state.accept} AcceptTerms`);
 389     console.info(`    ${state.deposit} DepositReceived`);
 390     process.exit(0);
 391     return;
 392   }
 393
 394   let hasEnough = state.balanceInfo.balanceSat > signupOnly + feeEstimate;
 395   if (!hasEnough) {
 396     await collectSignupFees(state.insightBaseUrl, state.pub);
 397   }
 398   console.info("Requesting account...");
 399   await CrowdNode.signup(state.privKey, state.hotwallet);
 400   state.signup = "✅";
 401   console.info(`    ${state.signup} SignUpForApi`);
 402   console.info(`    ${state.accept} AcceptTerms`);
 403   process.exit(0);
 404   return;
 405 }
 406
 407 async function accept(args, state) {
 408   if (state.status?.accept) {
 409     console.info(
 410       `${state.pub} is already signed up. Here's the account status:`,
 411     );
 412     console.info(`    ${state.signup} SignUpForApi`);
 413     console.info(`    ${state.accept} AcceptTerms`);
 414     console.info(`    ${state.deposit} DepositReceived`);
 415     process.exit(0);
 416     return;
 417   }
 418   let hasEnough = state.balanceInfo.balanceSat > acceptOnly + feeEstimate;
 419   if (!hasEnough) {
 420     await collectSignupFees(state.insightBaseUrl, state.pub);
 421   }
 422   console.info("Accepting terms...");
 423   await CrowdNode.accept(state.privKey, state.hotwallet);
 424   state.accept = "✅";
 425   console.info(`    ${state.signup} SignUpForApi`);
 426   console.info(`    ${state.accept} AcceptTerms`);
 427   console.info(`    ${state.deposit} DepositReceived`);
 428   process.exit(0);
 429   return;
 430 }
 431
 432 async function deposit(args, state) {
 433   if (!state.status?.accept) {
 434     console.error(`no account for address ${state.pub}`);
 435     process.exit(1);
 436     return;
 437   }
 438
 439   // this would allow for at least 2 withdrawals costing (21000 + 1000)
 440   let reserve = 50000;
 441   let reserveDash = toDash(reserve);
 442   if (!state.noReserve) {
 443     console.info(
 444       `reserving ${reserve} (Đ${reserveDash}) for withdrawals (--no-reserve to disable)`,
 445     );
 446   } else {
 447     reserve = 0;
 448   }
 449
 450   // TODO if unconfirmed, check utxos instead
 451
 452   // deposit what the user asks, or all that we have,
 453   // or all that the user deposits - but at least 2x the reserve
 454   let desiredAmountDash = parseFloat(args.shift() || 0);
 455   let desiredAmountDuff = Math.round(desiredAmountDash * DUFFS);
 456   let effectiveAmount = desiredAmountDuff;
 457   if (!effectiveAmount) {
 458     effectiveAmount = state.balanceInfo.balanceSat - reserve;
 459   }
 460   let needed = Math.max(reserve * 2, effectiveAmount + reserve);
 461
 462   if (state.balanceInfo.balanceSat < needed) {
 463     let ask = 0;
 464     if (desiredAmountDuff) {
 465       ask = desiredAmountDuff + reserve + -state.balanceInfo.balanceSat;
 466     }
 467     await collectDeposit(state.insightBaseUrl, state.pub, ask);
 468     state.balanceInfo = await state.dashApi.getInstantBalance(state.pub);
 469     if (state.balanceInfo.balanceSat < needed) {
 470       let balanceDash = toDash(state.balanceInfo.balanceSat);
 471       console.error(
 472         `Balance is still too small: ${state.balanceInfo.balanceSat} (Đ${balanceDash})`,
 473       );
 474       process.exit(1);
 475       return;
 476     }
 477   }
 478   if (!desiredAmountDuff) {
 479     effectiveAmount = state.balanceInfo.balanceSat - reserve;
 480   }
 481
 482   console.info(
 483     `(holding ${reserve} (Đ${reserveDash}) in reserve for API calls)`,
 484   );
 485   let effectiveDash = toDash(effectiveAmount);
 486   console.info(
 487     `Initiating deposit of ${effectiveAmount} (Đ${effectiveDash})...`,
 488   );
 489   await CrowdNode.deposit(state.privKey, state.hotwallet, effectiveAmount);
 490   state.deposit = "✅";
 491   console.info(`    ${state.deposit} DepositReceived`);
 492   process.exit(0);
 493   return;
 494 }
 495
 496 async function withdrawal(args, state) {
 497   if (!state.status?.accept) {
 498     console.error(`no account for address ${state.pub}`);
 499     process.exit(1);
 500     return;
 501   }
 502
 503   let percentStr = args.shift() || "100.0";
 504   // pass: .1 0.1, 1, 1.0, 10, 10.0, 100, 100.0
 505   // fail: 1000, 10.00
 506   if (!/^1?\d?\d?(\.\d)?$/.test(percentStr)) {
 507     console.error("Error: withdrawal percent must be between 0.1 and 100.0");
 508     process.exit(1);
 509   }
 510   let percent = parseFloat(percentStr);
 511
 512   let permil = Math.round(percent * 10);
 513   if (permil <= 0 || permil > 1000) {
 514     console.error("Error: withdrawal percent must be between 0.1 and 100.0");
 515     process.exit(1);
 516   }
 517
 518   let realPercentStr = (permil / 10).toFixed(1);
 519   console.info(`Initiating withdrawal of ${realPercentStr}...`);
 520
 521   let paid = await CrowdNode.withdrawal(state.privKey, state.hotwallet, permil);
 522   //let paidFloat = (paid.satoshis / DUFFS).toFixed(8);
 523   //let paidInt = paid.satoshis.toString().padStart(9, "0");
 524   console.info(`API Response: ${paid.api}`);
 525   process.exit(0);
 526   return;
 527 }
 528
 529 /*
 530 async function stake(args, state) {
 531   // TODO
 532   return;
 533 }
 534 */
 535
 536 // Helpers
 537
 538 async function wifFileToAddr(keyfile) {
 539   let privKey = keyfile;
 540
 541   let err = await Fs.access(keyfile).catch(Object);
 542   if (!err) {
 543     privKey = await Fs.readFile(keyfile, "utf8");
 544     privKey = privKey.trim();
 545   }
 546
 547   if (34 === privKey.length) {
 548     // actually payment addr
 549     return privKey;
 550   }
 551
 552   if (52 === privKey.length) {
 553     let pk = new Dashcore.PrivateKey(privKey);
 554     let pub = pk.toPublicKey().toAddress().toString();
 555     return pub;
 556   }
 557
 558   throw new Error("bad file path or address");
 559 }
 560
 561 async function collectSignupFees(insightBaseUrl, pub) {
 562   showQr(pub);
 563
 564   let signupTotalDash = (signupTotal / DUFFS).toFixed(8);
 565   let signupMsg = `Please send >= ${signupTotal} (Đ${signupTotalDash}) to Sign Up to CrowdNode`;
 566   let msgPad = Math.ceil((qrWidth - signupMsg.length) / 2);
 567   let subMsg = "(plus whatever you'd like to deposit)";
 568   let subMsgPad = Math.ceil((qrWidth - subMsg.length) / 2);
 569
 570   console.info();
 571   console.info(" ".repeat(msgPad) + signupMsg);
 572   console.info(" ".repeat(subMsgPad) + subMsg);
 573   console.info();
 574
 575   console.info("");
 576   console.info("(waiting...)");
 577   console.info("");
 578   let payment = await Ws.waitForVout(insightBaseUrl, pub, 0);
 579   console.info(`Received ${payment.satoshis}`);
 580 }
 581
 582 async function collectDeposit(insightBaseUrl, pub, duffAmount) {
 583   showQr(pub, duffAmount);
 584
 585   let depositMsg = `Please send what you wish to deposit to ${pub}`;
 586   if (duffAmount) {
 587     let depositDash = toDash(duffAmount);
 588     depositMsg = `Please deposit ${duffAmount} (Đ${depositDash}) to ${pub}`;
 589   }
 590
 591   let msgPad = Math.ceil((qrWidth - depositMsg.length) / 2);
 592   msgPad = Math.max(0, msgPad);
 593
 594   console.info();
 595   console.info(" ".repeat(msgPad) + depositMsg);
 596   console.info();
 597
 598   console.info("");
 599   console.info("(waiting...)");
 600   console.info("");
 601   let payment = await Ws.waitForVout(insightBaseUrl, pub, 0);
 602   console.info(`Received ${payment.satoshis}`);
 603 }
 604
 605 function toDash(duffs) {
 606   return (duffs / DUFFS).toFixed(8);
 607 }
 608
 609 // Run
 610
 611 main().catch(function (err) {
 612   console.error("Fail:");
 613   console.error(err.stack || err);
 614   process.exit(1);
 615 });