lbry-desktop/ui/js/lbry.js

import lbryio from './lbryio.js';
import lighthouse from './lighthouse.js';
import jsonrpc from './jsonrpc.js';
import lbryuri from './lbryuri.js';
import {getLocal, getSession, setSession, setLocal} from './utils.js';

const {remote, ipcRenderer} = require('electron');
const menu = remote.require('./menu/main-menu');

/**
 * Records a publish attempt in local storage. Returns a dictionary with all the data needed to
 * needed to make a dummy claim or file info object.
 */
function savePendingPublish({name, channel_name}) {
  let uri;
  if (channel_name) {
    uri = lbryuri.build({name: channel_name, path: name}, false);
  } else {
    uri = lbryuri.build({name: name}, false);
  }
  const pendingPublishes = getLocal('pendingPublishes') || [];
  const newPendingPublish = {
    name, channel_name,
    claim_id: 'pending_claim_' + uri,
    txid: 'pending_' + uri,
    nout: 0,
    outpoint: 'pending_' + uri + ':0',
    time: Date.now(),
  };
  setLocal('pendingPublishes', [...pendingPublishes, newPendingPublish]);
  return newPendingPublish;
}

/**
 * If there is a pending publish with the given name or outpoint, remove it.
 * A channel name may also be provided along with name.
 */
function removePendingPublishIfNeeded({name, channel_name, outpoint}) {
  function pubMatches(pub) {
    return pub.outpoint === outpoint || (pub.name === name && (!channel_name || pub.channel_name === channel_name));
  }

  setLocal('pendingPublishes', getPendingPublishes().filter(pub => !pubMatches(pub)));
}

/**
 * Gets the current list of pending publish attempts. Filters out any that have timed out and
 * removes them from the list.
 */
function getPendingPublishes() {
  const pendingPublishes = getLocal('pendingPublishes') || [];
  const newPendingPublishes = pendingPublishes.filter(pub => Date.now() - pub.time <= lbry.pendingPublishTimeout);
  setLocal('pendingPublishes', newPendingPublishes);
  return newPendingPublishes;
}

/**
 * Gets a pending publish attempt by its name or (fake) outpoint. A channel name can also be
 * provided along withe the name. If no pending publish is found, returns null.
 */
function getPendingPublish({name, channel_name, outpoint}) {
  const pendingPublishes = getPendingPublishes();
  return pendingPublishes.find(
    pub => pub.outpoint === outpoint || (pub.name === name && (!channel_name || pub.channel_name === channel_name))
  ) || null;
}

function pendingPublishToDummyClaim({channel_name, name, outpoint, claim_id, txid, nout}) {
  return {name, outpoint, claim_id, txid, nout, channel_name};
}

function pendingPublishToDummyFileInfo({name, outpoint, claim_id}) {
  return {name, outpoint, claim_id, metadata: null};
}
window.pptdfi = pendingPublishToDummyFileInfo;

let lbry = {
  isConnected: false,
  rootPath: '.',
  daemonConnectionString: 'http://localhost:5279/lbryapi',
  webUiUri: 'http://localhost:5279',
  peerListTimeout: 6000,
  pendingPublishTimeout: 20 * 60 * 1000,
  colors: {
    primary: '#155B4A'
  },
  defaultClientSettings: {
    showNsfw: false,
    showUnavailable: true,
    debug: false,
    useCustomLighthouseServers: false,
    customLighthouseServers: [],
    showDeveloperMenu: false,
  }
};

lbry.call = function (method, params, callback, errorCallback, connectFailedCallback) {
  jsonrpc.call(lbry.daemonConnectionString, method, params, callback, errorCallback, connectFailedCallback);
}

//core
lbry._connectPromise = null;
lbry.connect = function() {
  if (lbry._connectPromise === null) {

    lbry._connectPromise = new Promise((resolve, reject) => {

      // Check every half second to see if the daemon is accepting connections
      function checkDaemonStarted(tryNum = 0) {
        lbry.isDaemonAcceptingConnections(function (runningStatus) {
          if (runningStatus) {
            resolve(true);
          }
          else {
            if (tryNum <= 600) { // Move # of tries into constant or config option
              setTimeout(function () {
                checkDaemonStarted(tryNum + 1);
              }, tryNum < 100 ? 200 : 1000);
            }
            else {
              reject(new Error("Unable to connect to LBRY"));
            }
          }
        });
      }

      checkDaemonStarted();
    });
  }

  return lbry._connectPromise;
}


//kill this but still better than document.title =, which this replaced
lbry.setTitle = function(title) {
  document.title = title + " - LBRY";
}

//kill this with proper routing
lbry.back = function() {
  if (window.history.length > 1) {
    window.history.back();
  } else {
    window.location.href = "?discover";
  }
}

lbry.isDaemonAcceptingConnections = function (callback) {
  // Returns true/false whether the daemon is at a point it will start returning status
  lbry.call('status', {}, () => callback(true), null, () => callback(false))
};

lbry.checkFirstRun = function(callback) {
  lbry.call('is_first_run', {}, callback);
}

lbry.getNewAddress = function(callback) {
  lbry.call('wallet_new_address', {}, callback);
}

lbry.getUnusedAddress = function(callback) {
  lbry.call('wallet_unused_address', {}, callback);
}

lbry.checkAddressIsMine = function(address, callback) {
  lbry.call('address_is_mine', {address: address}, callback);
}

lbry.getDaemonSettings = function(callback) {
  lbry.call('get_settings', {}, callback);
}

lbry.setDaemonSettings = function(settings, callback) {
  lbry.call('set_settings', settings, callback);
}

lbry.setDaemonSetting = function(setting, value, callback) {
  var setSettingsArgs = {};
  setSettingsArgs[setting] = value;
  lbry.call('set_settings', setSettingsArgs, callback)
}


lbry.getBalance = function(callback) {
  lbry.call("wallet_balance", {}, callback);
}

lbry.sendToAddress = function(amount, address, callback, errorCallback) {
  lbry.call("send_amount_to_address", { "amount" : amount, "address": address }, callback, errorCallback);
}

lbry.getClaimInfo = function(name, callback) {
  if (!name) {
    throw new Error(`Name required.`);
  }
  lbry.call('get_claim_info', { name: name }, callback);
}

lbry.getMyClaim = function(name, callback) {
  lbry.call('claim_list_mine', {}, (claims) => {
    callback(claims.find((claim) => claim.name == name) || null);
  });
}

lbry.getPeersForBlobHash = function(blobHash, callback) {
  let timedOut = false;
  const timeout = setTimeout(() => {
    timedOut = true;
    callback([]);
  }, lbry.peerListTimeout);

  lbry.call('peer_list', { blob_hash: blobHash }, function(peers) {
    if (!timedOut) {
      clearTimeout(timeout);
      callback(peers);
    }
  });
}

/**
 * Takes a LBRY URI; will first try and calculate a total cost using
 * Lighthouse. If Lighthouse can't be reached, it just retrives the
 * key fee.
 *
 * Returns an object with members:
 *   - cost: Number; the calculated cost of the name
 *   - includes_data: Boolean; indicates whether or not the data fee info
 *     from Lighthouse is included.
 */
lbry.costPromiseCache = {}
lbry.getCostInfo = function(uri) {
  if (lbry.costPromiseCache[uri] === undefined) {
    lbry.costPromiseCache[uri] = new Promise((resolve, reject) => {
      const COST_INFO_CACHE_KEY = 'cost_info_cache';
      let costInfoCache = getSession(COST_INFO_CACHE_KEY, {})

      function cacheAndResolve(cost, includesData) {
        costInfoCache[uri] = {cost, includesData};
        setSession(COST_INFO_CACHE_KEY, costInfoCache);
        resolve({cost, includesData});
      }

      if (!uri) {
        return reject(new Error(`URI required.`));
      }

      if (costInfoCache[uri] && costInfoCache[uri].cost) {
        return resolve(costInfoCache[uri])
      }

      function getCost(uri, size) {
        lbry.stream_cost_estimate({uri, ... size !== null ? {size} : {}}).then((cost) => {
          cacheAndResolve(cost, size !== null);
        }, reject);
      }

      function getCostGenerous(uri) {
        // If generous is on, the calculation is simple enough that we might as well do it here in the front end
        lbry.resolve({uri: uri}).then((resolutionInfo) => {
          const fee = resolutionInfo.claim.value.stream.metadata.fee;
          if (fee === undefined) {
            cacheAndResolve(0, true);
          } else if (fee.currency == 'LBC') {
            cacheAndResolve(fee.amount, true);
          } else {
            lbryio.getExchangeRates().then(({lbc_usd}) => {
              cacheAndResolve(fee.amount / lbc_usd, true);
            });
          }
        });
      }

      const uriObj = lbryuri.parse(uri);
      const name = uriObj.path || uriObj.name;

      lbry.settings_get({allow_cached: true}).then(({is_generous_host}) => {
        if (is_generous_host) {
          return getCostGenerous(uri);
        }

        lighthouse.get_size_for_name(name).then((size) => {
          if (size) {
            getCost(name, size);
          }
          else {
            getCost(name, null);
          }
        }, () => {
          getCost(name, null);
        });
      });
    });
  }
  return lbry.costPromiseCache[uri];
}

lbry.getMyClaims = function(callback) {
  lbry.call('get_name_claims', {}, callback);
}

lbry.removeFile = function(outpoint, deleteTargetFile=true, callback) {
  this._removedFiles.push(outpoint);
  // this._updateFileInfoSubscribers(outpoint);

  lbry.file_delete({
    outpoint: outpoint,
    delete_target_file: deleteTargetFile,
  }).then(callback);
}

lbry.getFileInfoWhenListed = function(name, callback, timeoutCallback, tryNum=0) {
  function scheduleNextCheckOrTimeout() {
    if (timeoutCallback && tryNum > 200) {
      timeoutCallback();
    } else {
      setTimeout(() => lbry.getFileInfoWhenListed(name, callback, timeoutCallback, tryNum + 1), 250);
    }
  }

  // Calls callback with file info when it appears in the lbrynet file manager.
  // If timeoutCallback is provided, it will be called if the file fails to appear.
  lbry.file_list({name: name}).then(([fileInfo]) => {
    if (fileInfo) {
      callback(fileInfo);
    } else {
      scheduleNextCheckOrTimeout();
    }
  }, () => scheduleNextCheckOrTimeout());
}

/**
 * Publishes a file. The optional fileListedCallback is called when the file becomes available in
 * lbry.file_list() during the publish process.
 *
 * This currently includes a work-around to cache the file in local storage so that the pending
 * publish can appear in the UI immediately.
 */
lbry.publish = function(params, fileListedCallback, publishedCallback, errorCallback) {
  lbry.call('publish', params, (result) => {
    if (returnedPending) {
      return;
    }

    clearTimeout(returnPendingTimeout);
    publishedCallback(result);
  }, (err) => {
    if (returnedPending) {
      return;
    }

    clearTimeout(returnPendingTimeout);
    errorCallback(err);
  });

  let returnedPending = false;
  // Give a short grace period in case publish() returns right away or (more likely) gives an error
  const returnPendingTimeout = setTimeout(() => {
    returnedPending = true;

    if (publishedCallback) {
      savePendingPublish({name: params.name, channel_name: params.channel_name});
      publishedCallback(true);
    }

    if (fileListedCallback) {
      const {name, channel_name} = params;
      savePendingPublish({name: params.name, channel_name: params.channel_name});
      fileListedCallback(true);
    }
  }, 2000);

  //lbry.getFileInfoWhenListed(params.name, function(fileInfo) {
  //  fileListedCallback(fileInfo);
  //});
}


lbry.getClientSettings = function() {
  var outSettings = {};
  for (let setting of Object.keys(lbry.defaultClientSettings)) {
    var localStorageVal = localStorage.getItem('setting_' + setting);
    outSettings[setting] = (localStorageVal === null ? lbry.defaultClientSettings[setting] : JSON.parse(localStorageVal));
  }
  return outSettings;
}

lbry.getClientSetting = function(setting) {
  var localStorageVal = localStorage.getItem('setting_' + setting);
  if (setting == 'showDeveloperMenu')
  {
    return true;
  }
  return (localStorageVal === null ? lbry.defaultClientSettings[setting] : JSON.parse(localStorageVal));
}

lbry.setClientSettings = function(settings) {
  for (let setting of Object.keys(settings)) {
    lbry.setClientSetting(setting, settings[setting]);
  }
}

lbry.setClientSetting = function(setting, value) {
  return localStorage.setItem('setting_' + setting, JSON.stringify(value));
}

lbry.getSessionInfo = function(callback) {
  lbry.call('get_lbry_session_info', {}, callback);
}

lbry.reportBug = function(message, callback) {
  lbry.call('report_bug', {
    message: message
  }, callback);
}

//utilities
lbry.formatCredits = function(amount, precision)
{
  return amount.toFixed(precision || 1).replace(/\.?0+$/, '');
}

lbry.formatName = function(name) {
  // Converts LBRY name to standard format (all lower case, no special characters, spaces replaced by dashes)
  name = name.replace('/\s+/g', '-');
  name = name.toLowerCase().replace(/[^a-z0-9\-]/g, '');
  return name;
}

lbry.nameIsValid = function(name, checkCase=true) {
  const regexp = new RegExp('^[a-z0-9-]+$', checkCase ? '' : 'i');
  return regexp.test(name);
}

lbry.loadJs = function(src, type, onload)
{
  var lbryScriptTag = document.getElementById('lbry'),
      newScriptTag = document.createElement('script'),
      type = type || 'text/javascript';

  newScriptTag.src = src;
  newScriptTag.type = type;
  if (onload)
  {
    newScriptTag.onload = onload;
  }
  lbryScriptTag.parentNode.insertBefore(newScriptTag, lbryScriptTag);
}

lbry.imagePath = function(file)
{
  return lbry.rootPath + '/img/' + file;
}

lbry.getMediaType = function(contentType, fileName) {
  if (contentType) {
    return /^[^/]+/.exec(contentType);
  } else if (fileName) {
    var dotIndex = fileName.lastIndexOf('.');
    if (dotIndex == -1) {
      return 'unknown';
    }

    var ext = fileName.substr(dotIndex + 1);
    if (/^mp4|mov|m4v|flv|f4v$/i.test(ext)) {
      return 'video';
    } else if (/^mp3|m4a|aac|wav|flac|ogg$/i.test(ext)) {
      return 'audio';
    } else if (/^html|htm|pdf|odf|doc|docx|md|markdown|txt$/i.test(ext)) {
      return 'document';
    } else {
      return 'unknown';
    }
  } else {
    return 'unknown';
  }
}

lbry.stop = function(callback) {
  lbry.call('stop', {}, callback);
};

lbry.fileInfo = {};
lbry._subscribeIdCount = 0;
lbry._fileInfoSubscribeCallbacks = {};
lbry._fileInfoSubscribeInterval = 500000;
lbry._balanceSubscribeCallbacks = {};
lbry._balanceSubscribeInterval = 5000;
lbry._removedFiles = [];
lbry._claimIdOwnershipCache = {};

lbry._updateClaimOwnershipCache = function(claimId) {
  lbry.getMyClaims((claimInfos) => {
    lbry._claimIdOwnershipCache[claimId] = !!claimInfos.reduce(function(match, claimInfo) {
      return match || claimInfo.claim_id == claimId;
    }, false);
  });

};

lbry._updateFileInfoSubscribers = function(outpoint) {
  const callSubscribedCallbacks = (outpoint, fileInfo) => {
    for (let callback of Object.values(this._fileInfoSubscribeCallbacks[outpoint])) {
      callback(fileInfo);
    }
  }

  if (lbry._removedFiles.includes(outpoint)) {
    callSubscribedCallbacks(outpoint, false);
  } else {
    lbry.file_list({
      outpoint: outpoint,
      full_status: true,
    }).then(([fileInfo]) => {
      if (fileInfo) {
        if (this._claimIdOwnershipCache[fileInfo.claim_id] === undefined) {
          this._updateClaimOwnershipCache(fileInfo.claim_id);
        }
        fileInfo.isMine = !!this._claimIdOwnershipCache[fileInfo.claim_id];
      }

      callSubscribedCallbacks(outpoint, fileInfo);
    });
  }

  if (Object.keys(this._fileInfoSubscribeCallbacks[outpoint]).length) {
    setTimeout(() => {
      this._updateFileInfoSubscribers(outpoint);
    }, lbry._fileInfoSubscribeInterval);
  }
}

lbry.fileInfoSubscribe = function(outpoint, callback) {
  if (!lbry._fileInfoSubscribeCallbacks[outpoint])
  {
    lbry._fileInfoSubscribeCallbacks[outpoint] = {};
  }

  const subscribeId = ++lbry._subscribeIdCount;
  lbry._fileInfoSubscribeCallbacks[outpoint][subscribeId] = callback;
  lbry._updateFileInfoSubscribers(outpoint);
  return subscribeId;
}

lbry.fileInfoUnsubscribe = function(outpoint, subscribeId) {
  delete lbry._fileInfoSubscribeCallbacks[outpoint][subscribeId];
}

lbry._balanceUpdateInterval = null;
lbry._updateBalanceSubscribers = function() {
  lbry.get_balance().then(function(balance) {
    for (let callback of Object.values(lbry._balanceSubscribeCallbacks)) {
      callback(balance);
    }
  });

  if (!lbry._balanceUpdateInterval && Object.keys(lbry._balanceSubscribeCallbacks).length) {
    lbry._balanceUpdateInterval = setInterval(() => {
      lbry._updateBalanceSubscribers();
    }, lbry._balanceSubscribeInterval);
  }
}

lbry.balanceSubscribe = function(callback) {
  const subscribeId = ++lbry._subscribeIdCount;
  lbry._balanceSubscribeCallbacks[subscribeId] = callback;
  lbry._updateBalanceSubscribers();
  return subscribeId;
}

lbry.balanceUnsubscribe = function(subscribeId) {
  delete lbry._balanceSubscribeCallbacks[subscribeId];
  if (lbry._balanceUpdateInterval && !Object.keys(lbry._balanceSubscribeCallbacks).length) {
    clearInterval(lbry._balanceUpdateInterval)
  }
}

lbry.showMenuIfNeeded = function() {
  const showingMenu = sessionStorage.getItem('menuShown') || null;
  const chosenMenu = lbry.getClientSetting('showDeveloperMenu') ? 'developer' : 'normal';
  if (chosenMenu != showingMenu) {
    menu.showMenubar(chosenMenu == 'developer');
  }
  sessionStorage.setItem('menuShown', chosenMenu);
};

lbry.getVersionInfo = function() {
  return new Promise((resolve, reject) => {
    ipcRenderer.once('version-info-received', (event, versionInfo) => { resolve(versionInfo) });
    ipcRenderer.send('version-info-requested');
  });
}


/**
 * Wrappers for API methods to simulate missing or future behavior. Unlike the old-style stubs,
 * these are designed to be transparent wrappers around the corresponding API methods.
 */

/**
 * Returns results from the file_list API method, plus dummy entries for pending publishes.
 * (If a real publish with the same name is found, the pending publish will be ignored and removed.)
 */
lbry.file_list = function(params={}) {
  return new Promise((resolve, reject) => {
    const {name, channel_name, outpoint} = params;

    /**
     * If we're searching by outpoint, check first to see if there's a matching pending publish.
     * Pending publishes use their own faux outpoints that are always unique, so we don't need
     * to check if there's a real file.
     */
    if (outpoint) {
      const pendingPublish = getPendingPublish({outpoint});
      if (pendingPublish) {
        resolve([pendingPublishToDummyFileInfo(pendingPublish)]);
        return;
      }
    }

    lbry.call('file_list', params, (fileInfos) => {
      removePendingPublishIfNeeded({name, channel_name, outpoint});

      const dummyFileInfos = getPendingPublishes().map(pendingPublishToDummyFileInfo);
      resolve([...fileInfos, ...dummyFileInfos]);
    }, reject, reject);
  });
}

lbry.claim_list_mine = function(params={}) {
  return new Promise((resolve, reject) => {
    lbry.call('claim_list_mine', params, (claims) => {
      for (let {name, channel_name, txid, nout} of claims) {
        removePendingPublishIfNeeded({name, channel_name, outpoint: txid + ':' + nout});
      }

      const dummyClaims = getPendingPublishes().map(pendingPublishToDummyClaim);
      resolve([...claims, ...dummyClaims]);
    }, reject, reject)
  });
}

lbry.resolve = function(params={}) {
  const claimCacheKey = 'resolve_claim_cache',
        claimCache = getSession(claimCacheKey, {})
  return new Promise((resolve, reject) => {
    if (!params.uri) {
      throw "Resolve has hacked cache on top of it that requires a URI"
    }
    if (params.uri && claimCache[params.uri] !== undefined) {
      resolve(claimCache[params.uri]);
    } else {
      lbry.call('resolve', params, function(data) {
        claimCache[params.uri] = data;
        setSession(claimCacheKey, claimCache)
        resolve(data)
      }, reject)
    }
  });
}

// Adds caching.
lbry.settings_get = function(params={}) {
  return new Promise((resolve, reject) => {
    if (params.allow_cached) {
      const cached = getSession('settings');
      if (cached) {
        return resolve(cached);
      }
    }

    lbry.call('settings_get', {}, (settings) => {
      setSession('settings', settings);
      resolve(settings);
    });
  });
}

// lbry.get = function(params={}) {
//   return function(params={}) {
//     return new Promise((resolve, reject) => {
//       jsonrpc.call(lbry.daemonConnectionString, "get", params, resolve, reject, reject);
//     });
//   };
// }

lbry = new Proxy(lbry, {
  get: function(target, name) {
    if (name in target) {
      return target[name];
    }

    return function(params={}) {
      return new Promise((resolve, reject) => {
        jsonrpc.call(lbry.daemonConnectionString, name, params, resolve, reject, reject);
      });
    };
  }
});

export default lbry;