lib/dash.js

   1 "use strict";
   2
   3 let Dash = module.exports;
   4
   5 const DUFFS = 100000000;
   6 const DUST = 10000;
   7 const FEE = 1000;
   8
   9 let Dashcore = require("@dashevo/dashcore-lib");
  10 let Transaction = Dashcore.Transaction;
  11
  12 Dash.create = function ({
  13   //@ts-ignore TODO
  14   insightApi,
  15 }) {
  16   let dashApi = {};
  17
  18   /**
  19    * Instant Balance is accurate with Instant Send
  20    * @param {String} address
  21    * @returns {Promise<InstantBalance>}
  22    */
  23   dashApi.getInstantBalance = async function (address) {
  24     let body = await insightApi.getUtxos(address);
  25     let utxos = await getUtxos(body);
  26     let balance = utxos.reduce(function (total, utxo) {
  27       return total + utxo.satoshis;
  28     }, 0);
  29     // because 0.1 + 0.2 = 0.30000000000000004,
  30     // but we would only want 0.30000000
  31     let floatBalance = parseFloat((balance / DUFFS).toFixed(8));
  32
  33     return {
  34       addrStr: address,
  35       balance: floatBalance,
  36       balanceSat: balance,
  37       _utxoCount: utxos.length,
  38       _utxoAmounts: utxos.map(function (utxo) {
  39         return utxo.satoshis;
  40       }),
  41     };
  42   };
  43
  44   /**
  45    * Full Send!
  46    * @param {String} privKey
  47    * @param {String} pub
  48    */
  49   dashApi.createBalanceTransfer = async function (privKey, pub) {
  50     let pk = new Dashcore.PrivateKey(privKey);
  51     let changeAddr = pk.toPublicKey().toAddress().toString();
  52
  53     let body = await insightApi.getUtxos(changeAddr);
  54     let utxos = await getUtxos(body);
  55     let balance = utxos.reduce(function (total, utxo) {
  56       return total + utxo.satoshis;
  57     }, 0);
  58
  59     //@ts-ignore - no input required, actually
  60     let tmpTx = new Transaction()
  61       //@ts-ignore - allows single value or array
  62       .from(utxos);
  63     tmpTx.to(pub, balance - 1000);
  64     tmpTx.sign(pk);
  65
  66     // TODO getsmartfeeestimate??
  67     // fee = 1duff/byte (2 chars hex is 1 byte)
  68     //       +10 to be safe (the tmpTx may be a few bytes off)
  69     let fee = 10 + tmpTx.toString().length / 2;
  70
  71     //@ts-ignore - no input required, actually
  72     let tx = new Transaction()
  73       //@ts-ignore - allows single value or array
  74       .from(utxos);
  75     tx.to(pub, balance - fee);
  76     tx.fee(fee);
  77     tx.sign(pk);
  78
  79     return tx;
  80   };
  81
  82   /**
  83    * Send with change back
  84    * @param {String} privKey
  85    * @param {(String|import('@dashevo/dashcore-lib').Address)} payAddr
  86    * @param {Number} amount
  87    * @param {(String|import('@dashevo/dashcore-lib').Address)} [changeAddr]
  88    */
  89   dashApi.createPayment = async function (
  90     privKey,
  91     payAddr,
  92     amount,
  93     changeAddr,
  94   ) {
  95     let pk = new Dashcore.PrivateKey(privKey);
  96     let utxoAddr = pk.toPublicKey().toAddress().toString();
  97     if (!changeAddr) {
  98       changeAddr = utxoAddr;
  99     }
 100
 101     // TODO make more accurate?
 102     let feePreEstimate = 1000;
 103     let utxos = await getOptimalUtxos(utxoAddr, amount + feePreEstimate);
 104     let balance = getBalance(utxos);
 105
 106     if (!utxos.length) {
 107       throw new Error(`not enough funds available in utxos for ${utxoAddr}`);
 108     }
 109
 110     // (estimate) don't send dust back as change
 111     if (balance - amount <= DUST + FEE) {
 112       amount = balance;
 113     }
 114
 115     //@ts-ignore - no input required, actually
 116     let tmpTx = new Transaction()
 117       //@ts-ignore - allows single value or array
 118       .from(utxos);
 119     tmpTx.to(payAddr, amount);
 120     //@ts-ignore - the JSDoc is wrong in dashcore-lib/lib/transaction/transaction.js
 121     tmpTx.change(changeAddr);
 122     tmpTx.sign(pk);
 123
 124     // TODO getsmartfeeestimate??
 125     // fee = 1duff/byte (2 chars hex is 1 byte)
 126     //       +10 to be safe (the tmpTx may be a few bytes off - probably only 4 -
 127     //       due to how small numbers are encoded)
 128     let fee = 10 + tmpTx.toString().length / 2;
 129
 130     // (adjusted) don't send dust back as change
 131     if (balance + -amount + -fee <= DUST) {
 132       amount = balance - fee;
 133     }
 134
 135     //@ts-ignore - no input required, actually
 136     let tx = new Transaction()
 137       //@ts-ignore - allows single value or array
 138       .from(utxos);
 139     tx.to(payAddr, amount);
 140     tx.fee(fee);
 141     //@ts-ignore - see above
 142     tx.change(changeAddr);
 143     tx.sign(pk);
 144
 145     return tx;
 146   };
 147
 148   // TODO make more optimal
 149   /**
 150    * @param {String} utxoAddr
 151    * @param {Number} fullAmount - including fee estimate
 152    */
 153   async function getOptimalUtxos(utxoAddr, fullAmount) {
 154     // get smallest coin larger than transaction
 155     // if that would create dust, donate it as tx fee
 156     let body = await insightApi.getUtxos(utxoAddr);
 157     let utxos = await getUtxos(body);
 158     let balance = getBalance(utxos);
 159
 160     if (balance < fullAmount) {
 161       return [];
 162     }
 163
 164     // from largest to smallest
 165     utxos.sort(function (a, b) {
 166       return b.satoshis - a.satoshis;
 167     });
 168
 169     /** @type Array<CoreUtxo> */
 170     let included = [];
 171     let total = 0;
 172
 173     // try to get just one
 174     utxos.every(function (utxo) {
 175       if (utxo.satoshis > fullAmount) {
 176         included[0] = utxo;
 177         total = utxo.satoshis;
 178         return true;
 179       }
 180       return false;
 181     });
 182     if (total) {
 183       return included;
 184     }
 185
 186     // try to use as few coins as possible
 187     utxos.some(function (utxo) {
 188       included.push(utxo);
 189       total += utxo.satoshis;
 190       return total >= fullAmount;
 191     });
 192     return included;
 193   }
 194
 195   /**
 196    * @param {Array<CoreUtxo>} utxos
 197    */
 198   function getBalance(utxos) {
 199     return utxos.reduce(function (total, utxo) {
 200       return total + utxo.satoshis;
 201     }, 0);
 202   }
 203
 204   /**
 205    * @param {Array<InsightUtxo>} body
 206    */
 207   async function getUtxos(body) {
 208     /** @type Array<CoreUtxo> */
 209     let utxos = [];
 210
 211     await body.reduce(async function (promise, utxo) {
 212       await promise;
 213
 214       let data = await insightApi.getTx(utxo.txid);
 215
 216       // TODO the ideal would be the smallest amount that is greater than the required amount
 217
 218       let utxoIndex = -1;
 219       data.vout.some(function (vout, index) {
 220         if (!vout.scriptPubKey?.addresses?.includes(utxo.address)) {
 221           return false;
 222         }
 223
 224         let satoshis = Math.round(parseFloat(vout.value) * DUFFS);
 225         if (utxo.satoshis !== satoshis) {
 226           return false;
 227         }
 228
 229         utxoIndex = index;
 230         return true;
 231       });
 232
 233       utxos.push({
 234         txId: utxo.txid,
 235         outputIndex: utxoIndex,
 236         address: utxo.address,
 237         script: utxo.scriptPubKey,
 238         satoshis: utxo.satoshis,
 239       });
 240     }, Promise.resolve());
 241
 242     return utxos;
 243   }
 244
 245   return dashApi;
 246 };