Wallet/src/js/controllers/confirm.js

'use strict';

angular.module('copayApp.controllers').controller('confirmController', function($rootScope, $scope, $interval, $filter, $timeout, $ionicScrollDelegate, $ionicLoading, ionicToast, addressbookService, gettextCatalog, walletService, platformInfo, lodash, configService, $stateParams, $window, $state, $log, profileService, bitcore, bitcoreCash, txFormatService, ongoingProcess, $ionicModal, popupService, $ionicHistory, $ionicConfig, payproService, feeService, bitcoinCashJsService, bwcError, txConfirmNotification, externalLinkService, firebaseEventsService, soundService, clipboardService) {

  var countDown = null;
  var FEE_TOO_HIGH_LIMIT_PER = 15;

  var tx = {};
  var lastTxId = "";

  // Config Related values
  var config = configService.getSync();
  var walletConfig = config.wallet;
  var configFeeLevel = walletConfig.settings.feeLevel ? walletConfig.settings.feeLevel : 'normal';

  // Platform info
  var isCordova = platformInfo.isCordova;

  //custom fee flag
  var usingCustomFee = false;
  var usingMerchantFee = false;

  function refresh() {
    $timeout(function() {
      $scope.$apply();
    }, 10);
  }

  $scope.shareTransaction = function() {
    var explorerTxUrl = 'https://explorer.bitcoin.com/'+tx.coin+'/tx/'+lastTxId;
    if (platformInfo.isCordova) {
      var text = 'Take a look at this Bitcoin transaction here: '+explorerTxUrl;
      window.plugins.socialsharing.share(text, null, null, null);
    } else {
      ionicToast.show(gettextCatalog.getString('Copied to clipboard'), 'bottom', false, 3000);
      clipboardService.copyToClipboard(explorerTxUrl);
    }
  };

  $scope.showWalletSelector = function() {
    $scope.walletSelector = true;
    refresh();
  };

  $scope.$on("$ionicView.beforeLeave", function(event, data) {
    $ionicConfig.views.swipeBackEnabled(true);
  });

  $scope.$on("$ionicView.enter", function(event, data) {
    $ionicConfig.views.swipeBackEnabled(false);
  });

  function exitWithError(err) {
    $log.info('Error setting wallet selector:' + err);
    popupService.showAlert(gettextCatalog.getString(), bwcError.msg(err), function() {
      $ionicHistory.nextViewOptions({
        disableAnimate: true,
        historyRoot: true
      });
      $ionicHistory.clearHistory();
      $state.go('tabs.send');
    });
  };

  function setNoWallet(msg, criticalError) {
    $scope.wallet = null;
    $scope.noWalletMessage = msg;
    $scope.criticalError = criticalError;
    $log.warn('Not ready to make the payment:' + msg);
    $timeout(function() {
      $scope.$apply();
    });
  };

  var setWalletSelector = function(coin, network, minAmount, cb) {

    // no min amount? (sendMax) => look for no empty wallets
    minAmount = minAmount || 1;

    $scope.wallets = profileService.getWallets({
      onlyComplete: true,
      network: network,
      coin: coin
    });

    if (tx.fromWalletId) {
      $scope.wallets = lodash.filter($scope.wallets, function (w) {
        return w.id == tx.fromWalletId;
      });
    }


    if (!$scope.wallets || !$scope.wallets.length) {
      setNoWallet(gettextCatalog.getString('No wallets available'), true);
      return cb();
    }

    var filteredWallets = [];
    var index = 0;
    var walletsUpdated = 0;

    lodash.each($scope.wallets, function (w) {
      walletService.getStatus(w, {}, function (err, status) {
        if (err || !status) {
          $log.error(err);
        } else {
          walletsUpdated++;
          w.status = status;

          if (!status.availableBalanceSat)
            $log.debug('No balance available in: ' + w.name);

          if (status.availableBalanceSat > minAmount) {
            filteredWallets.push(w);
          }
        }

        if (++index == $scope.wallets.length) {
          if (!walletsUpdated)
            return cb('Could not update any wallet');

          if (lodash.isEmpty(filteredWallets)) {
            setNoWallet(gettextCatalog.getString('Insufficient confirmed funds'), true);
          }
          $scope.wallets = lodash.clone(filteredWallets);
          return cb();
        }
      });
    });
  };

  $scope.getContacts = function(addr) {
    addressbookService.list(function(err, ab) {
      if (err) $log.error(err);

      $scope.hasContacts = lodash.isEmpty(ab) ? false : true;
      if (!$scope.hasContacts) return cb();

      var completeContacts = [];
      lodash.each(ab, function(v, k) {
        completeContacts.push({
          name: lodash.isObject(v) ? v.name : v,
          address: k,
          email: lodash.isObject(v) ? v.email : null,
          recipientType: 'contact',
          coin: v.coin,
          displayCoin:  (v.coin == 'bch'
              ? (config.bitcoinCashAlias || defaults.bitcoinCashAlias)
              : (config.bitcoinAlias || defaults.bitcoinAlias)).toUpperCase()
        });
      });

      return cb();
    });
  };

  $scope.$on("$ionicView.beforeEnter", function(event, data) {
    $scope.fromWallet = profileService.getWallet(data.stateParams.fromWalletId); // Wallet to send from


    // Grab stateParams
    tx = {
      amount: parseInt(data.stateParams.amount),
      sendMax: data.stateParams.useSendMax == 'true' ? true : false,
      fromWalletId: data.stateParams.fromWalletId,
      toAddress: data.stateParams.toAddress,
      feeLevel: configFeeLevel,
      spendUnconfirmed: walletConfig.spendUnconfirmed,

      // Vanity tx info (not in the real tx)
      recipientType: $scope.recipientType || null,
      toName: null,
      toEmail: null,
      toColor: null,
      network: false,
      coin: $scope.fromWallet.coin,
      txp: {},
    };

    if (data.stateParams.requiredFeeRate) {
      usingMerchantFee = true;
      tx.feeRate = parseInt(data.stateParams.requiredFeeRate);
    }

    if (tx.coin && tx.coin === 'bch') {
      tx.feeLevel = 'normal';
    }

    var B = data.stateParams.coin === 'bch' ? bitcoreCash : bitcore;
    var networkName;
    $scope.recipientType = null;
    try {
      if (data.stateParams.toWalletId) { // There is a toWalletId, so we presume this is a wallet-to-wallet transfer
        $scope.recipientType = 'wallet'; // set transaction type to wallet-to-wallet
        $ionicLoading.show();

        var toWallet = profileService.getWallet(data.stateParams.toWalletId);
        tx.toColor = toWallet.color;
        tx.toName = toWallet.name;

        // We need an address to send to, so we ask the walletService to create a new address for the toWallet.
        walletService.getAddress(toWallet, true, function (err, addr) {
          $ionicLoading.hide();
          tx.toAddress = addr;
          networkName = (new B.Address(tx.toAddress)).network.name;
          tx.network = networkName;
          setupTx(tx);
        });
      } else { // This is a Wallet-to-address transfer
        networkName = (new B.Address(tx.toAddress)).network.name;
        tx.network = networkName;
        setupTx(tx);
      }
    } catch (e) {
      var message = gettextCatalog.getString('Invalid address');
      popupService.showAlert(null, message, function () {
        $ionicHistory.nextViewOptions({
          disableAnimate: true,
          historyRoot: true
        });
        $state.go('tabs.send').then(function () {
          $ionicHistory.clearHistory();
        });
      });
      return;
    }
  });

  var setupTx = function(tx) {
    if (tx.coin === 'bch') {
      tx.displayAddress = bitcoinCashJsService.readAddress(tx.toAddress).cashaddr;
    } else {
      tx.displayAddress = entry.address;
    }

    addressbookService.get(tx.coin+tx.toAddress, function(err, addr) { // Check if the recipient is a contact
      if (!err && addr) {
        tx.toName = addr.name;
        tx.toEmail = addr.email;
        tx.recipientType = 'contact';
      }
    });

    // Other Scope vars
    $scope.isCordova = isCordova;
    $scope.showAddress = false;
    $scope.walletSelectorTitle = gettextCatalog.getString('Send from');

    setWalletSelector(tx.coin, tx.network, tx.amount, function(err) {
      if (err) {
        return exitWithError('Could not update wallets');
      }

      if ($scope.wallets.length > 1) {
        $scope.showWalletSelector();
      } else if ($scope.wallets.length) {
        setWallet($scope.wallets[0], tx);
      }
    });

    $scope.displayBalanceAsFiat = walletConfig.settings.priceDisplay === 'fiat';

  };


  function getSendMaxInfo(tx, wallet, cb) {
    if (!tx.sendMax) return cb();

    //ongoingProcess.set('retrievingInputs', true);
    walletService.getSendMaxInfo(wallet, {
      feePerKb: tx.feeRate,
      excludeUnconfirmedUtxos: !tx.spendUnconfirmed,
      returnInputs: true,
    }, cb);
  };


  function getTxp(tx, wallet, dryRun, cb) {

    // ToDo: use a credential's (or fc's) function for this
    if (tx.description && !wallet.credentials.sharedEncryptingKey) {
      var msg = gettextCatalog.getString('Could not add message to imported wallet without shared encrypting key');
      $log.warn(msg);
      return setSendError(msg);
    }

    if (tx.amount > Number.MAX_SAFE_INTEGER) {
      var msg = gettextCatalog.getString('Amount too big');
      $log.warn(msg);
      return setSendError(msg);
    }

    var txp = {};

    txp.outputs = [{
      'toAddress': tx.toAddress,
      'amount': tx.amount,
      'message': tx.description
    }];

    if (tx.sendMaxInfo) {
      txp.inputs = tx.sendMaxInfo.inputs;
      txp.fee = tx.sendMaxInfo.fee;
    } else {
      if (usingCustomFee || usingMerchantFee) {
        txp.feePerKb = tx.feeRate;
      } else txp.feeLevel = tx.feeLevel;
    }

    txp.message = tx.description;

    if (tx.paypro) {
      txp.payProUrl = tx.paypro.url;
    }
    txp.excludeUnconfirmedUtxos = !tx.spendUnconfirmed;
    txp.dryRun = dryRun;
    walletService.createTx(wallet, txp, function(err, ctxp) {
      if (err) {
        setSendError(err);
        return cb(err);
      }
      return cb(null, ctxp);
    });
  };

  function updateTx(tx, wallet, opts, cb) {
    ongoingProcess.set('calculatingFee', true);

    if (opts.clearCache) {
      tx.txp = {};
    }

    $scope.tx = tx;

    function updateAmount() {
      if (!tx.amount) return;

      // Amount
      tx.amountStr = txFormatService.formatAmountStr(wallet.coin, tx.amount);
      tx.amountValueStr = tx.amountStr.split(' ')[0];
      tx.amountUnitStr = tx.amountStr.split(' ')[1];
      txFormatService.formatAlternativeStr(wallet.coin, tx.amount, function(v) {
        var parts = v.split(' ');
        tx.alternativeAmountStr = v;
        tx.alternativeAmountValueStr = parts[0];
        tx.alternativeAmountUnitStr = (parts.length > 0) ? parts[1] : '';
      });
    }

    updateAmount();
    refresh();

    // End of quick refresh, before wallet is selected.
    if (!wallet) {
      ongoingProcess.set('calculatingFee', false);
      return cb();
    }

    var feeServiceLevel = usingMerchantFee && wallet.coin == 'btc' ? 'urgent' : tx.feeLevel;
    feeService.getFeeRate(wallet.coin, tx.network, feeServiceLevel, function(err, feeRate) {
      if (err) {
        ongoingProcess.set('calculatingFee', false);
        return cb(err);
      }

      var msg;
      if (usingCustomFee) {
        msg = gettextCatalog.getString('Custom');
        tx.feeLevelName = msg;
      } else if (usingMerchantFee) {
        $log.info('Using Merchant Fee:' + tx.feeRate + ' vs. Urgent level:' + feeRate);
        msg = gettextCatalog.getString('Suggested by Merchant');
        tx.feeLevelName = msg;
      } else {
        tx.feeLevelName = feeService.feeOpts[tx.feeLevel];
        tx.feeRate = feeRate;
      }

      getSendMaxInfo(lodash.clone(tx), wallet, function(err, sendMaxInfo) {
        if (err) {
          ongoingProcess.set('calculatingFee', false);
          var msg = gettextCatalog.getString('Error getting SendMax information');
          return setSendError(msg);
        }

        if (sendMaxInfo) {

          $log.debug('Send max info', sendMaxInfo);

          if (tx.sendMax && sendMaxInfo.amount == 0) {
            ongoingProcess.set('calculatingFee', false);
            setNoWallet(gettextCatalog.getString('Insufficient confirmed funds'));
            popupService.showAlert(gettextCatalog.getString('Error'), gettextCatalog.getString('Not enough funds for fee'));
            return cb('no_funds');
          }

          tx.sendMaxInfo = sendMaxInfo;
          tx.amount = tx.sendMaxInfo.amount;
          updateAmount();
          ongoingProcess.set('calculatingFee', false);
          $timeout(function() {
            showSendMaxWarning(wallet, sendMaxInfo);
          }, 200);
        }

        // txp already generated for this wallet?
        if (tx.txp[wallet.id]) {
          ongoingProcess.set('calculatingFee', false);
          refresh();
          return cb();
        }

        getTxp(lodash.clone(tx), wallet, opts.dryRun, function(err, txp) {
          ongoingProcess.set('calculatingFee', false);
          if (err) {
            if (err.message == 'Insufficient funds') {
              setNoWallet(gettextCatalog.getString('Insufficient funds'));
              popupService.showAlert(gettextCatalog.getString('Error'), gettextCatalog.getString('Not enough funds for fee'));
              return cb('no_funds');
            } else
              return cb(err);
          }

          txp.feeStr = txFormatService.formatAmountStr(wallet.coin, txp.fee);
          txFormatService.formatAlternativeStr(wallet.coin, txp.fee, function(v) {
            txp.alternativeFeeStr = v;
            if (txp.alternativeFeeStr.substring(0, 4) == '0.00')
              txp.alternativeFeeStr = '< ' + txp.alternativeFeeStr;
          });

          var per = (txp.fee / (txp.amount + txp.fee) * 100);
          var perString = per.toFixed(2);
          txp.feeRatePerStr = (perString == '0.00' ? '< ' : '') + perString + '%';
          txp.feeToHigh = per > FEE_TOO_HIGH_LIMIT_PER;

          tx.txp[wallet.id] = txp;
          $log.debug('Confirm. TX Fully Updated for wallet:' + wallet.id, tx);
          refresh();

          return cb();
        });
      });
    });
  }

  function useSelectedWallet() {

    if (!$scope.useSendMax) {
      showAmount(tx.amount);
    }

    $scope.onWalletSelect($scope.wallet);
  }

  function setButtonText(isMultisig, isPayPro) {

    if (isPayPro) {
      if (isCordova) {
        $scope.buttonText = gettextCatalog.getString('Slide to pay');
      } else {
        $scope.buttonText = gettextCatalog.getString('Click to pay');
      }
    } else if (isMultisig) {
      if (isCordova) {
        $scope.buttonText = gettextCatalog.getString('Slide to accept');
      } else {
        $scope.buttonText = gettextCatalog.getString('Click to accept');
      }
    } else {
      if (isCordova) {
        $scope.buttonText = gettextCatalog.getString('Slide to send');
      } else {
        $scope.buttonText = gettextCatalog.getString('Click to send');
      }
    }
  };

  $scope.toggleAddress = function() {
    $scope.showAddress = !$scope.showAddress;
  };


  function showSendMaxWarning(wallet, sendMaxInfo) {
    var feeAlternative = '',
      msg = '';

    function verifyExcludedUtxos() {
      var warningMsg = [];
      if (sendMaxInfo.utxosBelowFee > 0) {
        warningMsg.push(gettextCatalog.getString("A total of {{amountBelowFeeStr}} were excluded. These funds come from UTXOs smaller than the network fee provided.", {
          amountBelowFeeStr: txFormatService.formatAmountStr(wallet.coin, sendMaxInfo.amountBelowFee)
        }));
      }

      if (sendMaxInfo.utxosAboveMaxSize > 0) {
        warningMsg.push(gettextCatalog.getString("A total of {{amountAboveMaxSizeStr}} were excluded. The maximum size allowed for a transaction was exceeded.", {
          amountAboveMaxSizeStr: txFormatService.formatAmountStr(wallet.coin, sendMaxInfo.amountAboveMaxSize)
        }));
      }
      return warningMsg.join('\n');
    };

    feeAlternative = txFormatService.formatAlternativeStr(wallet.coin, sendMaxInfo.fee);
    if (feeAlternative) {
      msg = gettextCatalog.getString("{{feeAlternative}} will be deducted for bitcoin networking fees ({{fee}}).", {
        fee: txFormatService.formatAmountStr(wallet.coin, sendMaxInfo.fee),
        feeAlternative: feeAlternative
      });
    } else {
      msg = gettextCatalog.getString("{{fee}} will be deducted for bitcoin networking fees).", {
        fee: txFormatService.formatAmountStr(wallet.coin, sendMaxInfo.fee)
      });
    }

    var warningMsg = verifyExcludedUtxos();

    if (!lodash.isEmpty(warningMsg))
      msg += '\n' + warningMsg;

    popupService.showAlert(null, msg, function() {});
  };

  $scope.onWalletSelect = function(wallet) {
    setWallet(wallet, tx);
  };

  $scope.showDescriptionPopup = function(tx) {
    var message = gettextCatalog.getString('Add description');
    var opts = {
      defaultText: tx.description
    };

    popupService.showPrompt(null, message, opts, function(res) {
      if (typeof res != 'undefined') tx.description = res;
      $timeout(function() {
        $scope.$apply();
      });
    });
  };

  function _paymentTimeControl(expirationTime) {
    $scope.paymentExpired = false;
    setExpirationTime();

    countDown = $interval(function() {
      setExpirationTime();
    }, 1000);

    function setExpirationTime() {
      var now = Math.floor(Date.now() / 1000);

      if (now > expirationTime) {
        setExpiredValues();
        return;
      }

      var totalSecs = expirationTime - now;
      var m = Math.floor(totalSecs / 60);
      var s = totalSecs % 60;
      $scope.remainingTimeStr = ('0' + m).slice(-2) + ":" + ('0' + s).slice(-2);
    };

    function setExpiredValues() {
      $scope.paymentExpired = true;
      $scope.remainingTimeStr = gettextCatalog.getString('Expired');
      if (countDown) $interval.cancel(countDown);
      $timeout(function() {
        $scope.$apply();
      });
    };
  };

  /* sets a wallet on the UI, creates a TXPs for that wallet */

  function setWallet(wallet, tx) {

    $scope.wallet = wallet;

    // If select another wallet
    tx.coin = wallet.coin;

    if (usingCustomFee) {
    } else {
      tx.feeLevel = wallet.coin == 'bch' ? 'normal' : configFeeLevel;
    }

    setButtonText(wallet.credentials.m > 1, !!tx.paypro);

    if (tx.paypro)
      _paymentTimeControl(tx.paypro.expires);

    updateTx(tx, wallet, {
      dryRun: true
    }, function(err) {
      $timeout(function() {
        $ionicScrollDelegate.resize();
        $scope.$apply();
      }, 10);

    });

  };

  var setSendError = function(msg) {
    $scope.sendStatus = '';
    $timeout(function() {
      $scope.$apply();
    });
    popupService.showAlert(gettextCatalog.getString('Error at confirm'), bwcError.msg(msg));
  };

  $scope.openPPModal = function() {
    $ionicModal.fromTemplateUrl('views/modals/paypro.html', {
      scope: $scope
    }).then(function(modal) {
      $scope.payproModal = modal;
      $scope.payproModal.show();
    });
  };

  $scope.cancel = function() {
    $scope.payproModal.hide();
  };

  $scope.approve = function(tx, wallet, onSendStatusChange) {

    if (!tx || !wallet) return;

    if ($scope.paymentExpired) {
      popupService.showAlert(null, gettextCatalog.getString('This bitcoin payment request has expired.'));
      $scope.sendStatus = '';
      $timeout(function() {
        $scope.$apply();
      });
      return;
    }

    ongoingProcess.set('creatingTx', true, onSendStatusChange);
    getTxp(lodash.clone(tx), wallet, false, function(err, txp) {
      ongoingProcess.set('creatingTx', false, onSendStatusChange);
      if (err) return;

      // confirm txs for more that 20usd, if not spending/touchid is enabled
      function confirmTx(cb) {
        if (walletService.isEncrypted(wallet))
          return cb();

        var amountUsd = parseFloat(txFormatService.formatToUSD(wallet.coin, txp.amount));
        return cb();
      };

      function publishAndSign() {
        if (!wallet.canSign() && !wallet.isPrivKeyExternal()) {
          $log.info('No signing proposal: No private key');

          return walletService.onlyPublish(wallet, txp, function(err) {
            if (err) setSendError(err);
          }, onSendStatusChange);
        }

        walletService.publishAndSign(wallet, txp, function(err, txp) {
          if (err) return setSendError(err);
          if (config.confirmedTxsNotifications && config.confirmedTxsNotifications.enabled) {
            txConfirmNotification.subscribe(wallet, {
              txid: txp.txid
            });
            lastTxId = txp.txid;
          }
        }, onSendStatusChange);
      };

      confirmTx(function(nok) {
        if (nok) {
          $scope.sendStatus = '';
          $timeout(function() {
            $scope.$apply();
          });
          return;
        }
        publishAndSign();
      });
    });
  };

  function statusChangeHandler(processName, showName, isOn) {
    $log.debug('statusChangeHandler: ', processName, showName, isOn);
    if (
      (
        processName === 'broadcastingTx' ||
        ((processName === 'signingTx') && $scope.wallet.m > 1) ||
        (processName == 'sendingTx' && !$scope.wallet.canSign() && !$scope.wallet.isPrivKeyExternal())
      ) && !isOn) {
      $scope.sendStatus = 'success';

      if ($state.current.name === "tabs.send.confirm") { // XX SP: Otherwise all open wallets on other devices play this sound if you have been in a send flow before on that device.
        soundService.play('misc/payment_sent.mp3');
      }
      
      var channel = "ga";
      if (platformInfo.isCordova) {
        channel = "firebase";
      }
      var log = new window.BitAnalytics.LogEvent("transfer_success", [{
        "coin": $scope.wallet.coin,
        "type": "outgoing",
        "amount": $scope.amount,
        "fees": $scope.fee
      }], [channel, "adjust"]);
      window.BitAnalytics.LogEventHandlers.postEvent(log);

      // Should be removed
      firebaseEventsService.logEvent('sent_bitcoin', { coin: $scope.wallet.coin });
      $timeout(function() {
        $scope.$digest();
      }, 100);
    } else if (showName) {
      $scope.sendStatus = showName;
    }
  };

  $scope.statusChangeHandler = statusChangeHandler;

  $scope.onSuccessConfirm = function() {
    $scope.sendStatus = '';
    $ionicHistory.nextViewOptions({
      disableAnimate: true,
      historyRoot: true
    });
    $state.go('tabs.send').then(function() {
      $ionicHistory.clearHistory();
      $state.transitionTo('tabs.home');
    });
  };

  $scope.chooseFeeLevel = function(tx, wallet) {

    if (wallet.coin == 'bch') return;
    if (usingMerchantFee) return;

    var scope = $rootScope.$new(true);
    scope.network = tx.network;
    scope.feeLevel = tx.feeLevel;
    scope.noSave = true;
    scope.coin = wallet.coin;

    if (usingCustomFee) {
      scope.customFeePerKB = tx.feeRate;
      scope.feePerSatByte = tx.feeRate / 1000;
    }

    $ionicModal.fromTemplateUrl('views/modals/chooseFeeLevel.html', {
      scope: scope,
      backdropClickToClose: false,
      hardwareBackButtonClose: false
    }).then(function(modal) {
      scope.chooseFeeLevelModal = modal;
      scope.openModal();
    });
    scope.openModal = function() {
      scope.chooseFeeLevelModal.show();
    };

    scope.hideModal = function(newFeeLevel, customFeePerKB) {
      scope.chooseFeeLevelModal.hide();
      $log.debug('New fee level choosen:' + newFeeLevel + ' was:' + tx.feeLevel);

      usingCustomFee = newFeeLevel == 'custom' ? true : false;

      if (tx.feeLevel == newFeeLevel && !usingCustomFee) return;

      tx.feeLevel = newFeeLevel;
      if (usingCustomFee) tx.feeRate = parseInt(customFeePerKB);

      updateTx(tx, wallet, {
        clearCache: true,
        dryRun: true
      }, function() {});
    };
  };

});