@bitpay-labs/bitcore-wallet-service 11.5.2

package/src/lib/chain/xrp/index.ts

@@ -0,0 +1,338 @@
+import { BitcoreLib, Deriver, Transactions, Validation, xrpl } from '@bitpay-labs/crypto-wallet-core';
+import _ from 'lodash';
+import { IWallet } from 'src/lib/model';
+import { IAddress } from 'src/lib/model/address';
+import { IChain } from '../../../types/chain';
+import { Common } from '../../common';
+import { Errors } from '../../errors/errordefinitions';
+import logger from '../../logger';
+import { WalletService } from '../../server';
+
+const { Defaults, Utils } = Common;
+
+export class XrpChain implements IChain {
+  /**
+   * Converts Bitcore Balance Response.
+   * @param {Object} bitcoreBalance - { unconfirmed, confirmed, balance }
+   * @param {Number} locked - Sum of txp.amount
+   * @returns {Object} balance - Total amount & locked amount.
+   */
+  private convertBitcoreBalance(bitcoreBalance, locked, reserve = Defaults.MIN_XRP_BALANCE) {
+    const { confirmed, balance } = bitcoreBalance;
+    let activatedLocked = locked;
+    // If XRP address has a min balance of X XRP, subtract activation fee for true spendable balance.
+    if (balance > 0) {
+      activatedLocked = locked + reserve;
+    }
+    const convertedBalance = {
+      totalAmount: balance,
+      totalConfirmedAmount: confirmed,
+      lockedAmount: activatedLocked,
+      lockedConfirmedAmount: activatedLocked,
+      availableAmount: balance - activatedLocked,
+      availableConfirmedAmount: confirmed - activatedLocked,
+      byAddress: []
+    };
+    return convertedBalance;
+  }
+
+  supportsMultisig() {
+    return false;
+  }
+
+  supportsThresholdsig() {
+    return true;
+  }
+
+  getSizeSafetyMargin() {
+    return 0;
+  }
+
+  getInputSizeSafetyMargin() {
+    return 0;
+  }
+
+  getWalletBalance(server: WalletService, wallet: IWallet, opts, cb) {
+    const bc = server._getBlockchainExplorer(wallet.chain || wallet.coin, wallet.network);
+    bc.getBalance(wallet, (err, balance) => {
+      if (err) {
+        return cb(err);
+      }
+      bc.getReserve((err, reserve) => {
+        if (err) {
+          return cb(err);
+        }
+        server.getPendingTxs(opts, (err, txps) => {
+          if (err) return cb(err);
+          const lockedSum = txps.reduce((sum, txp) => {
+            return sum + txp.amount + (txp.fee || 0);
+          }, 0) || 0;
+          const convertedBalance = this.convertBitcoreBalance(balance, lockedSum, reserve);
+          server.storage.fetchAddresses(server.walletId, (err, addresses: IAddress[]) => {
+            if (err) return cb(err);
+            if (addresses.length > 0) {
+              const byAddress = [
+                {
+                  address: addresses[0].address,
+                  path: addresses[0].path,
+                  amount: convertedBalance.totalAmount
+                }
+              ];
+              convertedBalance.byAddress = byAddress;
+            }
+            return cb(null, convertedBalance);
+          });
+        });
+      });
+    });
+  }
+
+  getWalletSendMaxInfo(server, wallet, opts, cb) {
+    server.getBalance({}, (err, balance) => {
+      if (err) return cb(err);
+      const { availableAmount } = balance;
+      const fee = opts.feePerKb;
+      return cb(null, {
+        utxosBelowFee: 0,
+        amountBelowFee: 0,
+        amount: availableAmount - fee,
+        feePerKb: opts.feePerKb,
+        fee
+      });
+    });
+  }
+
+  getDustAmountValue() {
+    return 0;
+  }
+
+  getTransactionCount(server, wallet, from) {
+    return new Promise((resolve, reject) => {
+      server._getTransactionCount(wallet, from, (err, nonce) => {
+        if (err) return reject(err);
+        return resolve(nonce);
+      });
+    });
+  }
+
+  getChangeAddress() { }
+
+  checkDust(_output, _opts) { }
+
+  checkScriptOutput(_output) { }
+
+  getFee(server, wallet, opts) {
+    return new Promise((resolve, reject) => {
+      // This is used for sendmax flow
+      if (Utils.isNumber(opts.fee)) {
+        return resolve({ feePerKb: opts.fee });
+      }
+      server._getFeePerKb(wallet, opts, (err, inFeePerKb) => {
+        if (err) {
+          return reject(err);
+        }
+        const feePerKb = inFeePerKb;
+        opts.fee = feePerKb;
+        return resolve({ feePerKb });
+      });
+    });
+  }
+
+  getBitcoreTx(txp, opts = { signed: true }) {
+    const { destinationTag, outputs, outputOrder, multiTx } = txp;
+    const chain = 'XRP';
+    const unsignedTxs = [];
+    const length = multiTx ? outputOrder.length : outputs.length;
+    for (let index = 0; index < length; index++) {
+      let outputIdx = index;
+      if (multiTx) {
+        outputIdx = outputOrder[index];
+      }
+      if (!outputs?.[outputIdx]) {
+        throw new Error('Output index out of range');
+      }
+      const recepient = {
+        amount: outputs[outputIdx].amount,
+        address: outputs[outputIdx].toAddress,
+        tag: outputs[outputIdx].tag
+      };
+      const _tag = recepient?.tag || destinationTag;
+      const rawTx = Transactions.create({
+        ...txp,
+        tag: _tag ? Number(_tag) : undefined,
+        chain,
+        nonce: Number(txp.nonce) + Number(index),
+        recipients: [recepient]
+      });
+      unsignedTxs.push(rawTx);
+    }
+    const tx = {
+      uncheckedSerialize: () => unsignedTxs,
+      txid: () => txp.txid,
+      txids: () => txp.txid ? [txp.txid] : [],
+      toObject: () => {
+        const ret = _.clone(txp);
+        ret.outputs[0].satoshis = ret.outputs[0].amount;
+        return ret;
+      },
+      getFee: () => {
+        return txp.fee;
+      },
+      getChangeOutput: () => null
+    };
+
+    if (opts.signed) {
+      const sigs = txp.getCurrentSignatures();
+      for (const x of sigs) {
+        this.addSignaturesToBitcoreTx(tx, txp.inputs, txp.inputPaths, x.signatures, x.xpub);
+      }
+    }
+
+    return tx;
+  }
+
+  convertFeePerKb(p, feePerKb) {
+    return [p, feePerKb];
+  }
+
+  checkTx(txp) {
+    try {
+      this.getBitcoreTx(txp);
+    } catch (ex) {
+      logger.warn('Error building XRP transaction: %o', ex);
+      return ex;
+    }
+  }
+
+  checkTxUTXOs(_server, _txp, _opts, cb) {
+    return cb();
+  }
+
+  selectTxInputs(server, txp, wallet, opts, cb) {
+    server.getBalance({ wallet }, (err, balance) => {
+      if (err) return cb(err);
+      const { totalAmount, availableAmount } = balance;
+      const minXrpBalance = Defaults.MIN_XRP_BALANCE;
+      if (totalAmount - minXrpBalance < txp.getTotalAmount()) {
+        return cb(Errors.INSUFFICIENT_FUNDS);
+      } else if (availableAmount < txp.getTotalAmount()) {
+        return cb(Errors.LOCKED_FUNDS);
+      } else {
+        return cb(this.checkTx(txp));
+      }
+    });
+  }
+
+  checkUtxos(_opts) { }
+
+  checkValidTxAmount(output): boolean {
+    if (!Utils.isNumber(output.amount) || isNaN(output.amount) || output.amount < 0) {
+      return false;
+    }
+    return true;
+  }
+
+  isUTXOChain() {
+    return false;
+  }
+  isSingleAddress() {
+    return true;
+  }
+
+  addressFromStorageTransform(network, address): void {
+    if (network != 'livenet') {
+      const x = address.address.indexOf(':' + network);
+      if (x >= 0) {
+        address.address = address.address.substr(0, x);
+      }
+    }
+  }
+
+  addressToStorageTransform(network, address): void {
+    if (network != 'livenet') address.address += ':' + network;
+  }
+
+  addSignaturesToBitcoreTx(tx, inputs, inputPaths, signatures, xpub) {
+    if (signatures.length === 0) {
+      throw new Error('Signatures Required');
+    }
+
+    const chain = 'XRP'; // TODO use lowercase always to avoid confusion
+    const network = tx.network || tx.toObject().network;
+    const unsignedTxs = tx.uncheckedSerialize();
+    const signedTxs = [];
+    const txids = [];
+    for (let index = 0; index < signatures.length; index++) {
+      const pubKey = new BitcoreLib.HDPublicKey(xpub).deriveChild(inputPaths[index] || 'm/0/0').publicKey.toString();
+      if (Deriver.getAddress(chain, network, pubKey) !== tx.toObject().from) { // sanity check
+        throw new Error('Unknown public key for signature');
+      }
+
+      let signature: string = signatures[index];
+      try {
+        // Backward compatibility.
+        // Old versions of CWC returned just the signature for the XRPTxProvider.sign() method.
+        // Commit 5ff87d7724cabeccf683d1bd7c73eb2efd42f9c5 changed it to return the fully signed
+        //  transaction to be consistent with other chains' responses. Thus, signatures[] may
+        //  be the signed transaction blobs instead of just the signature string.
+        const decoded = xrpl.decode(signatures[index]);
+        if (decoded.TxnSignature) signature = decoded.TxnSignature as string;
+      } catch { /* ignore */ }
+
+      const signed = Transactions.applySignature({
+        chain,
+        tx: unsignedTxs[index],
+        signature,
+        pubKey
+      });
+      signedTxs.push(signed);
+
+      // bitcore users id for txid...
+      tx.id = Transactions.getHash({ tx: signed, chain, network });
+      txids.push(tx.id);
+    }
+    tx.txids = () => txids;
+    tx.uncheckedSerialize = () => signedTxs;
+  }
+
+  notifyConfirmations() {
+    return false;
+  }
+
+  validateAddress(wallet, inaddr, opts) {
+    const chain = 'xrp';
+    const isValidTo = Validation.validateAddress(chain, wallet.network, inaddr);
+    if (!isValidTo) {
+      throw Errors.INVALID_ADDRESS;
+    }
+    const isValidFrom = Validation.validateAddress(chain, wallet.network, opts.from);
+    if (!isValidFrom) {
+      throw Errors.INVALID_ADDRESS;
+    }
+    return;
+  }
+
+  onCoin(_coin) {
+    return null;
+  }
+  onTx(_tx) {
+    // TODO
+    // format tx to
+    // {address, amount}
+    return null;
+  }
+
+  getReserve(server: WalletService, wallet: IWallet, cb: (err?, reserve?: number) => void) {
+    const bc = server._getBlockchainExplorer(wallet.chain || wallet.coin, wallet.network);
+    bc.getReserve((err, reserve) => {
+      if (err) {
+        return cb(err);
+      }
+      return cb(null, reserve);
+    });
+  }
+
+  refreshTxData(_server: WalletService, txp, _opts, cb) {
+    return cb(null, txp);
+  }
+}

package/src/lib/cleanfiatrates.ts

@@ -0,0 +1,160 @@
+import * as async from 'async';
+import * as _ from 'lodash';
+import moment from 'moment';
+import * as mongodb from 'mongodb';
+import config from '../config';
+import logger from './logger';
+import { Storage } from './storage';
+
+const ObjectID = mongodb.ObjectID;
+
+const objectIdDate = function(date) {
+  return Math.floor(date.getTime() / 1000).toString(16) + '0000000000000000';
+};
+
+export class CleanFiatRates {
+  db: mongodb.Db;
+  client: mongodb.MongoClient;
+  from: Date;
+  to: Date;
+
+  constructor() {}
+
+  run(cb) {
+    const dbConfig = config.storageOpts.mongoDb;
+
+    let uri = dbConfig.uri;
+
+    uri = uri + 'readPreference=secondaryPreferred';
+    console.log('Connected to ', uri);
+
+    if (!dbConfig.dbname) {
+      return cb(new Error('No dbname at config.'));
+    }
+
+    mongodb.MongoClient.connect(dbConfig.uri, { useUnifiedTopology: true }, (err, client) => {
+      if (err) {
+        return cb(err);
+      }
+      this.db = client.db(dbConfig.dbname);
+      this.client = client;
+
+      this.cleanFiatRates((err, rates) => {
+        if (err) return cb(err);
+
+        this.client.close(err => {
+          if (err) logger.error('%o', err);
+          return cb(null, rates);
+        });
+      });
+    });
+  }
+
+  cleanFiatRates(cb) {
+    let dates;
+    async.series(
+      [
+        next => {
+          console.log('## Getting dates to keep...');
+          this._getDatesToKeep((err, res) => {
+            if (err) {
+              return next(err);
+            }
+            dates = res;
+            next();
+          });
+        },
+        next => {
+          console.log('## Cleaning fiat rates...');
+          this._cleanFiatRates(dates, next);
+        }
+      ],
+      (err, results) => {
+        if (err) return cb(err);
+        return cb(null, results[1]);
+      }
+    );
+  }
+
+  async _getDatesToKeep(cb) {
+    this.from = new Date();
+    this.from.setMonth(this.from.getMonth() - 2); // from 2 month ago
+    console.log(`\tFrom: ${moment(this.from).toDate()}`);
+
+    this.to = new Date();
+    this.to.setMonth(this.to.getMonth() - 1); // to 1 month ago
+    console.log(`\tTo: ${moment(this.to).toDate()}`);
+
+    const objectIdFromDate = objectIdDate(this.from);
+    const objectIdToDate = objectIdDate(this.to);
+
+    this.db
+      .collection(Storage.collections.FIAT_RATES2)
+      .find({
+        _id: {
+          $gte: new ObjectID(objectIdFromDate),
+          $lte: new ObjectID(objectIdToDate)
+        }
+      })
+      .sort({ _id: 1 })
+      .toArray((err, results) => {
+        if (err) return cb(err);
+
+        const datesToKeep = [];
+
+        // Timestamps grouped by coin avoiding duplicates.
+        const tsGruopedByCoin = _.reduce(
+          results,
+          (r, a) => {
+            r[a.coin] = _.uniq([...(r[a.coin] || []), a.ts]);
+            return r;
+          },
+          {}
+        );
+
+        // keep one date every hour for each coin
+        for (const [key, tsGroup] of Object.entries(tsGruopedByCoin)) {
+          console.log(`\tFiltering times for ${key.toUpperCase()}`);
+          let prevTime = null;
+          let isSameHour;
+
+          for (const ts of tsGroup as number[]) {
+            if (prevTime > ts + 60 * 10000) return cb(new Error('Results not in order'));
+
+            if (prevTime) {
+              isSameHour = moment(prevTime).isSame(moment(ts), 'hour');
+              if (!isSameHour) {
+                datesToKeep.push(ts);
+              }
+            } else {
+              // keep first date in case prevTime doesn't exist.
+              datesToKeep.push(ts);
+            }
+            prevTime = ts;
+          }
+        }
+        return cb(null, datesToKeep);
+      });
+  }
+
+  async _cleanFiatRates(datesToKeep, cb) {
+    try {
+      this.db
+        .collection(Storage.collections.FIAT_RATES2)
+        .remove({
+          ts: {
+            $nin: datesToKeep,
+            $gte: moment(this.from).valueOf(),
+            $lte: moment(this.to).valueOf()
+          }
+        })
+        .then(data => {
+          console.log(`\t${data.result.n} entries were removed from fiat_rates2`);
+          return cb(null, data.result);
+        });
+    } catch (err) {
+      console.log('\t!! Cannot remove data from fiat_rates2:', err);
+      return cb(err);
+    }
+  }
+}