Merge branch 'master' into redux-persist

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.12.0
+current_version = 0.12.2rc2
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)((?P<release>[a-z]+)(?P<candidate>\d+))?

CHANGELOG.md

@@ -12,8 +12,8 @@ Web UI version numbers should always match the corresponding version of LBRY App
   *
 
 ### Changed
-  *
+  * Upgraded to lbry daemon 0.13, including updating API signatures
-  *
+  * Channels resolve much faster
 
 ### Fixed
   * Fix help menu force reloading whole app

app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "LBRY",
-  "version": "0.12.0",
+  "version": "0.12.2rc2",
   "main": "main.js",
   "description": "LBRY is a fully decentralized, open-source protocol facilitating the discovery, access, and (sometimes) purchase of data.",
   "author": {

build/DAEMON_URL

@@ -1 +1 @@
-https://github.com/lbryio/lbry/releases/download/v0.11.0/lbrynet-daemon-v0.11.0-OSNAME.zip
+https://github.com/lbryio/lbry/releases/download/v0.13.1rc1/lbrynet-daemon-v0.13.1rc1-OSNAME.zip

ui/js/actions/content.js

@@ -256,23 +256,22 @@ export function doPurchaseUri(uri, purchaseModalName) {
   };
 }
 
-export function doFetchClaimsByChannel(uri) {
+export function doFetchClaimsByChannel(uri, page = 1) {
   return function(dispatch, getState) {
     dispatch({
       type: types.FETCH_CHANNEL_CLAIMS_STARTED,
       data: { uri },
     });
 
-    lbry.resolve({ uri }).then(resolutionInfo => {
+    lbry.claim_list_by_channel({ uri, page }).then(result => {
-      const { claims_in_channel } = resolutionInfo
+      const claimResult = result[uri],
-        ? resolutionInfo
+        claims = claimResult ? claimResult.claims_in_channel : [];
-        : { claims_in_channel: [] };
 
       dispatch({
         type: types.FETCH_CHANNEL_CLAIMS_COMPLETED,
         data: {
           uri,
-          claims: claims_in_channel,
+          claims: claims,
         },
       });
     });

ui/js/actions/file_info.js

@@ -89,7 +89,7 @@ export function doDeleteFile(outpoint, deleteFromComputer) {
 
     lbry.file_delete({
       outpoint: outpoint,
-      delete_target_file: deleteFromComputer,
+      delete_from_download_dir: deleteFromComputer,
     });
 
     dispatch(doCloseModal());

ui/js/actions/wallet.js

@@ -22,7 +22,7 @@ export function doFetchTransactions() {
       type: types.FETCH_TRANSACTIONS_STARTED,
     });
 
-    lbry.call("transaction_list", {}, results => {
+    lbry.transaction_list().then(results => {
       dispatch({
         type: types.FETCH_TRANSACTIONS_COMPLETED,
         data: {
@@ -55,7 +55,7 @@ export function doCheckAddressIsMine(address) {
       type: types.CHECK_ADDRESS_IS_MINE_STARTED,
     });
 
-    lbry.checkAddressIsMine(address, isMine => {
+    lbry.wallet_is_address_mine({ address }).then(isMine => {
       if (!isMine) dispatch(doGetNewAddress());
 
       dispatch({
@@ -103,12 +103,12 @@ export function doSendDraftTransaction() {
       dispatch(doOpenModal("transactionFailed"));
     };
 
-    lbry.sendToAddress(
+    lbry
-      draftTx.amount,
+      .send_amount_to_address({
-      draftTx.address,
+        amount: draftTx.amount,
-      successCallback,
+        address: draftTx.address,
-      errorCallback
+      })
-    );
+      .then(successCallback, errorCallback);
   };
 }
 

ui/js/component/file-selector.js

@@ -21,7 +21,9 @@ class FileSelector extends React.PureComponent {
   handleButtonClick() {
     remote.dialog.showOpenDialog(
       {
-        properties: [this.props.type == "file" ? "openFile" : "openDirectory"],
+        properties: this.props.type == "file"
+          ? ["openFile"]
+          : ["openDirectory", "createDirectory"],
       },
       paths => {
         if (!paths) {

ui/js/component/fileTile/view.jsx

@@ -19,14 +19,14 @@ class FileTile extends React.PureComponent {
   }
 
   componentDidMount() {
-    this.resolve(this.props);
+    const { isResolvingUri, claim, uri, resolveUri } = this.props;
+
+    if (!isResolvingUri && !claim && uri) resolveUri(uri);
   }
 
   componentWillReceiveProps(nextProps) {
-    this.resolve(nextProps);
+    const { isResolvingUri, claim, uri, resolveUri } = this.props;
-  }
 
-  resolve({ isResolvingUri, claim, uri, resolveUri }) {
     if (!isResolvingUri && claim === undefined && uri) resolveUri(uri);
   }
 

ui/js/lbry.js

@@ -1,50 +1,61 @@
-import lbryio from './lbryio.js';
+import lbryio from "./lbryio.js";
-import lighthouse from './lighthouse.js';
+import lighthouse from "./lighthouse.js";
-import jsonrpc from './jsonrpc.js';
+import jsonrpc from "./jsonrpc.js";
-import lbryuri from './lbryuri.js';
+import lbryuri from "./lbryuri.js";
-import { getLocal, getSession, setSession, setLocal } from './utils.js';
+import { getLocal, getSession, setSession, setLocal } from "./utils.js";
 
-const { remote, ipcRenderer } = require('electron');
+const { remote, ipcRenderer } = require("electron");
-const menu = remote.require('./menu/main-menu');
+const menu = remote.require("./menu/main-menu");
 
 let lbry = {
-	isConnected: false,
+  isConnected: false,
-	daemonConnectionString: 'http://localhost:5279/lbryapi',
+  daemonConnectionString: "http://localhost:5279/lbryapi",
-	pendingPublishTimeout: 20 * 60 * 1000,
+  pendingPublishTimeout: 20 * 60 * 1000,
-	defaultClientSettings: {
+  defaultClientSettings: {
-		showNsfw: false,
+    showNsfw: false,
-		showUnavailable: true,
+    showUnavailable: true,
-		debug: false,
+    debug: false,
-		useCustomLighthouseServers: false,
+    useCustomLighthouseServers: false,
-		customLighthouseServers: [],
+    customLighthouseServers: [],
-		showDeveloperMenu: false,
+    showDeveloperMenu: false,
-		language: 'en'
+    language: "en",
-	}
+  },
 };
 
+function apiCall(method, params, resolve, reject) {
+  return jsonrpc.call(
+    lbry.daemonConnectionString,
+    method,
+    params,
+    resolve,
+    reject,
+    reject
+  );
+}
+
 /**
  * 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;
+  let uri;
-	if (channel_name) {
+  if (channel_name) {
-		uri = lbryuri.build({ name: channel_name, path: name }, false);
+    uri = lbryuri.build({ name: channel_name, path: name }, false);
-	} else {
+  } else {
-		uri = lbryuri.build({ name: name }, false);
+    uri = lbryuri.build({ name: name }, false);
-	}
+  }
-	const pendingPublishes = getLocal('pendingPublishes') || [];
+  const pendingPublishes = getLocal("pendingPublishes") || [];
-	const newPendingPublish = {
+  const newPendingPublish = {
-		name,
+    name,
-		channel_name,
+    channel_name,
-		claim_id: 'pending_claim_' + uri,
+    claim_id: "pending_claim_" + uri,
-		txid: 'pending_' + uri,
+    txid: "pending_" + uri,
-		nout: 0,
+    nout: 0,
-		outpoint: 'pending_' + uri + ':0',
+    outpoint: "pending_" + uri + ":0",
-		time: Date.now()
+    time: Date.now(),
-	};
+  };
-	setLocal('pendingPublishes', [...pendingPublishes, newPendingPublish]);
+  setLocal("pendingPublishes", [...pendingPublishes, newPendingPublish]);
-	return newPendingPublish;
+  return newPendingPublish;
 }
 
 /**
@@ -52,18 +63,18 @@ function savePendingPublish({ name, channel_name }) {
  * A channel name may also be provided along with name.
  */
 function removePendingPublishIfNeeded({ name, channel_name, outpoint }) {
-	function pubMatches(pub) {
+  function pubMatches(pub) {
-		return (
+    return (
-			pub.outpoint === outpoint ||
+      pub.outpoint === outpoint ||
-			(pub.name === name &&
+      (pub.name === name &&
-				(!channel_name || pub.channel_name === channel_name))
+        (!channel_name || pub.channel_name === channel_name))
-		);
+    );
-	}
+  }
 
-	setLocal(
+  setLocal(
-		'pendingPublishes',
+    "pendingPublishes",
-		lbry.getPendingPublishes().filter(pub => !pubMatches(pub))
+    lbry.getPendingPublishes().filter(pub => !pubMatches(pub))
-	);
+  );
 }
 
 /**
@@ -71,12 +82,12 @@ function removePendingPublishIfNeeded({ name, channel_name, outpoint }) {
  * removes them from the list.
  */
 lbry.getPendingPublishes = function() {
-	const pendingPublishes = getLocal('pendingPublishes') || [];
+  const pendingPublishes = getLocal("pendingPublishes") || [];
-	const newPendingPublishes = pendingPublishes.filter(
+  const newPendingPublishes = pendingPublishes.filter(
-		pub => Date.now() - pub.time <= lbry.pendingPublishTimeout
+    pub => Date.now() - pub.time <= lbry.pendingPublishTimeout
-	);
+  );
-	setLocal('pendingPublishes', newPendingPublishes);
+  setLocal("pendingPublishes", newPendingPublishes);
-	return newPendingPublishes;
+  return newPendingPublishes;
 };
 
 /**
@@ -84,97 +95,61 @@ lbry.getPendingPublishes = function() {
  * provided along withe the name. If no pending publish is found, returns null.
  */
 function getPendingPublish({ name, channel_name, outpoint }) {
-	const pendingPublishes = lbry.getPendingPublishes();
+  const pendingPublishes = lbry.getPendingPublishes();
-	return (
+  return (
-		pendingPublishes.find(
+    pendingPublishes.find(
-			pub =>
+      pub =>
-				pub.outpoint === outpoint ||
+        pub.outpoint === outpoint ||
-				(pub.name === name &&
+        (pub.name === name &&
-					(!channel_name || pub.channel_name === channel_name))
+          (!channel_name || pub.channel_name === channel_name))
-		) || null
+    ) || null
-	);
+  );
 }
 
 function pendingPublishToDummyClaim({
-	channel_name,
+  channel_name,
-	name,
+  name,
-	outpoint,
+  outpoint,
-	claim_id,
+  claim_id,
-	txid,
+  txid,
-	nout
+  nout,
 }) {
-	return { name, outpoint, claim_id, txid, nout, channel_name };
+  return { name, outpoint, claim_id, txid, nout, channel_name };
 }
 
 function pendingPublishToDummyFileInfo({ name, outpoint, claim_id }) {
-	return { name, outpoint, claim_id, metadata: null };
+  return { name, outpoint, claim_id, metadata: null };
 }
 
-lbry.call = function(
-	method,
-	params,
-	callback,
-	errorCallback,
-	connectFailedCallback
-) {
-	return jsonrpc.call(
-		lbry.daemonConnectionString,
-		method,
-		params,
-		callback,
-		errorCallback,
-		connectFailedCallback
-	);
-};
-
 //core
 lbry._connectPromise = null;
 lbry.connect = function() {
-	if (lbry._connectPromise === null) {
+  if (lbry._connectPromise === null) {
-		lbry._connectPromise = new Promise((resolve, reject) => {
+    lbry._connectPromise = new Promise((resolve, reject) => {
-			let tryNum = 0;
+      let tryNum = 0;
 
-			function checkDaemonStartedFailed() {
+      function checkDaemonStartedFailed() {
-				if (tryNum <= 100) {
+        if (tryNum <= 200) {
-					// Move # of tries into constant or config option
+          // Move # of tries into constant or config option
-					setTimeout(() => {
+          setTimeout(() => {
-						tryNum++;
+            tryNum++;
-						checkDaemonStarted();
+            checkDaemonStarted();
-					}, tryNum < 50 ? 400 : 1000);
+          }, tryNum < 50 ? 400 : 1000);
-				} else {
+        } else {
-					reject(new Error('Unable to connect to LBRY'));
+          reject(new Error("Unable to connect to LBRY"));
-				}
+        }
-			}
+      }
 
-			// Check every half second to see if the daemon is accepting connections
+      // Check every half second to see if the daemon is accepting connections
-			function checkDaemonStarted() {
+      function checkDaemonStarted() {
-				lbry.call(
+        lbry.status().then(resolve).catch(checkDaemonStartedFailed);
-					'status',
+      }
-					{},
-					resolve,
-					checkDaemonStartedFailed,
-					checkDaemonStartedFailed
-				);
-			}
 
-			checkDaemonStarted();
+      checkDaemonStarted();
-		});
+    });
-	}
+  }
 
-	return lbry._connectPromise;
+  return lbry._connectPromise;
-};
-
-lbry.checkAddressIsMine = function(address, callback) {
-	lbry.call('wallet_is_address_mine', { address: address }, callback);
-};
-
-lbry.sendToAddress = function(amount, address, callback, errorCallback) {
-	lbry.call(
-		'send_amount_to_address',
-		{ amount: amount, address: address },
-		callback,
-		errorCallback
-	);
 };
 
 /**
@@ -189,46 +164,46 @@ lbry.sendToAddress = function(amount, address, callback, errorCallback) {
  */
 lbry.costPromiseCache = {};
 lbry.getCostInfo = function(uri) {
-	if (lbry.costPromiseCache[uri] === undefined) {
+  if (lbry.costPromiseCache[uri] === undefined) {
-		lbry.costPromiseCache[uri] = new Promise((resolve, reject) => {
+    lbry.costPromiseCache[uri] = new Promise((resolve, reject) => {
-			const COST_INFO_CACHE_KEY = 'cost_info_cache';
+      const COST_INFO_CACHE_KEY = "cost_info_cache";
-			let costInfoCache = getSession(COST_INFO_CACHE_KEY, {});
+      let costInfoCache = getSession(COST_INFO_CACHE_KEY, {});
 
-			function cacheAndResolve(cost, includesData) {
+      function cacheAndResolve(cost, includesData) {
-				costInfoCache[uri] = { cost, includesData };
+        costInfoCache[uri] = { cost, includesData };
-				setSession(COST_INFO_CACHE_KEY, costInfoCache);
+        setSession(COST_INFO_CACHE_KEY, costInfoCache);
-				resolve({ cost, includesData });
+        resolve({ cost, includesData });
-			}
+      }
 
-			if (!uri) {
+      if (!uri) {
-				return reject(new Error(`URI required.`));
+        return reject(new Error(`URI required.`));
-			}
+      }
 
-			if (costInfoCache[uri] && costInfoCache[uri].cost) {
+      if (costInfoCache[uri] && costInfoCache[uri].cost) {
-				return resolve(costInfoCache[uri]);
+        return resolve(costInfoCache[uri]);
-			}
+      }
 
-			function getCost(uri, size) {
+      function getCost(uri, size) {
-				lbry
+        lbry
-					.stream_cost_estimate({ uri, ...(size !== null ? { size } : {}) })
+          .stream_cost_estimate({ uri, ...(size !== null ? { size } : {}) })
-					.then(cost => {
+          .then(cost => {
-						cacheAndResolve(cost, size !== null);
+            cacheAndResolve(cost, size !== null);
-					}, reject);
+          }, reject);
-			}
+      }
 
-			const uriObj = lbryuri.parse(uri);
+      const uriObj = lbryuri.parse(uri);
-			const name = uriObj.path || uriObj.name;
+      const name = uriObj.path || uriObj.name;
 
-			lighthouse.get_size_for_name(name).then(size => {
+      lighthouse.get_size_for_name(name).then(size => {
-				if (size) {
+        if (size) {
-					getCost(name, size);
+          getCost(name, size);
-				} else {
+        } else {
-					getCost(name, null);
+          getCost(name, null);
-				}
+        }
-			});
+      });
-		});
+    });
-	}
+  }
-	return lbry.costPromiseCache[uri];
+  return lbry.costPromiseCache[uri];
 };
 
 /**
@@ -238,144 +213,124 @@ lbry.getCostInfo = function(uri) {
  * 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(
+lbry.publishDeprecated = function(
-	params,
+  params,
-	fileListedCallback,
+  fileListedCallback,
-	publishedCallback,
+  publishedCallback,
-	errorCallback
+  errorCallback
 ) {
-	lbry.call(
+  lbry.publish(params).then(
-		'publish',
+    result => {
-		params,
+      if (returnedPending) {
-		result => {
+        return;
-			if (returnedPending) {
+      }
-				return;
-			}
 
-			clearTimeout(returnPendingTimeout);
+      clearTimeout(returnPendingTimeout);
-			publishedCallback(result);
+      publishedCallback(result);
-		},
+    },
-		err => {
+    err => {
-			if (returnedPending) {
+      if (returnedPending) {
-				return;
+        return;
-			}
+      }
 
-			clearTimeout(returnPendingTimeout);
+      clearTimeout(returnPendingTimeout);
-			errorCallback(err);
+      errorCallback(err);
-		}
+    }
-	);
+  );
 
-	let returnedPending = false;
+  let returnedPending = false;
-	// Give a short grace period in case publish() returns right away or (more likely) gives an error
+  // Give a short grace period in case publish() returns right away or (more likely) gives an error
-	const returnPendingTimeout = setTimeout(() => {
+  const returnPendingTimeout = setTimeout(() => {
-		returnedPending = true;
+    returnedPending = true;
 
-		if (publishedCallback) {
+    if (publishedCallback) {
-			savePendingPublish({
+      savePendingPublish({
-				name: params.name,
+        name: params.name,
-				channel_name: params.channel_name
+        channel_name: params.channel_name,
-			});
+      });
-			publishedCallback(true);
+      publishedCallback(true);
-		}
+    }
 
-		if (fileListedCallback) {
+    if (fileListedCallback) {
-			const { name, channel_name } = params;
+      const { name, channel_name } = params;
-			savePendingPublish({
+      savePendingPublish({
-				name: params.name,
+        name: params.name,
-				channel_name: params.channel_name
+        channel_name: params.channel_name,
-			});
+      });
-			fileListedCallback(true);
+      fileListedCallback(true);
-		}
+    }
-	}, 2000);
+  }, 2000);
 };
 
 lbry.getClientSettings = function() {
-	var outSettings = {};
+  var outSettings = {};
-	for (let setting of Object.keys(lbry.defaultClientSettings)) {
+  for (let setting of Object.keys(lbry.defaultClientSettings)) {
-		var localStorageVal = localStorage.getItem('setting_' + setting);
+    var localStorageVal = localStorage.getItem("setting_" + setting);
-		outSettings[setting] = localStorageVal === null
+    outSettings[setting] = localStorageVal === null
-			? lbry.defaultClientSettings[setting]
+      ? lbry.defaultClientSettings[setting]
-			: JSON.parse(localStorageVal);
+      : JSON.parse(localStorageVal);
-	}
+  }
-	return outSettings;
+  return outSettings;
 };
 
 lbry.getClientSetting = function(setting) {
-	var localStorageVal = localStorage.getItem('setting_' + setting);
+  var localStorageVal = localStorage.getItem("setting_" + setting);
-	if (setting == 'showDeveloperMenu') {
+  if (setting == "showDeveloperMenu") {
-		return true;
+    return true;
-	}
+  }
-	return localStorageVal === null
+  return localStorageVal === null
-		? lbry.defaultClientSettings[setting]
+    ? lbry.defaultClientSettings[setting]
-		: JSON.parse(localStorageVal);
+    : JSON.parse(localStorageVal);
 };
 
 lbry.setClientSettings = function(settings) {
-	for (let setting of Object.keys(settings)) {
+  for (let setting of Object.keys(settings)) {
-		lbry.setClientSetting(setting, settings[setting]);
+    lbry.setClientSetting(setting, settings[setting]);
-	}
+  }
 };
 
 lbry.setClientSetting = function(setting, value) {
-	return localStorage.setItem('setting_' + setting, JSON.stringify(value));
+  return localStorage.setItem("setting_" + setting, JSON.stringify(value));
-};
-
-lbry.getSessionInfo = function(callback) {
-	lbry.call('status', { session_status: true }, 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+$/, '');
+  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)
+  // Converts LBRY name to standard format (all lower case, no special characters, spaces replaced by dashes)
-	name = name.replace('/s+/g', '-');
+  name = name.replace("/s+/g", "-");
-	name = name.toLowerCase().replace(/[^a-z0-9\-]/g, '');
+  name = name.toLowerCase().replace(/[^a-z0-9\-]/g, "");
-	return name;
+  return name;
 };
 
 lbry.imagePath = function(file) {
-	return 'img/' + file;
+  return "img/" + file;
 };
 
 lbry.getMediaType = function(contentType, fileName) {
-	if (contentType) {
+  if (contentType) {
-		return /^[^/]+/.exec(contentType)[0];
+    return /^[^/]+/.exec(contentType)[0];
-	} else if (fileName) {
+  } else if (fileName) {
-		var dotIndex = fileName.lastIndexOf('.');
+    var dotIndex = fileName.lastIndexOf(".");
-		if (dotIndex == -1) {
+    if (dotIndex == -1) {
-			return 'unknown';
+      return "unknown";
-		}
+    }
 
-		var ext = fileName.substr(dotIndex + 1);
+    var ext = fileName.substr(dotIndex + 1);
-		if (/^mp4|mov|m4v|flv|f4v$/i.test(ext)) {
+    if (/^mp4|mov|m4v|flv|f4v$/i.test(ext)) {
-			return 'video';
+      return "video";
-		} else if (/^mp3|m4a|aac|wav|flac|ogg$/i.test(ext)) {
+    } else if (/^mp3|m4a|aac|wav|flac|ogg$/i.test(ext)) {
-			return 'audio';
+      return "audio";
-		} else if (/^html|htm|pdf|odf|doc|docx|md|markdown|txt$/i.test(ext)) {
+    } else if (/^html|htm|pdf|odf|doc|docx|md|markdown|txt$/i.test(ext)) {
-			return 'document';
+      return "document";
-		} else {
+    } else {
-			return 'unknown';
+      return "unknown";
-		}
+    }
-	} else {
+  } else {
-		return 'unknown';
+    return "unknown";
-	}
+  }
-};
-
-lbry.stop = function(callback) {
-	lbry.call('stop', {}, callback);
 };
 
 lbry._subscribeIdCount = 0;
@@ -384,57 +339,57 @@ lbry._balanceSubscribeInterval = 5000;
 
 lbry._balanceUpdateInterval = null;
 lbry._updateBalanceSubscribers = function() {
-	lbry.wallet_balance().then(function(balance) {
+  lbry.wallet_balance().then(function(balance) {
-		for (let callback of Object.values(lbry._balanceSubscribeCallbacks)) {
+    for (let callback of Object.values(lbry._balanceSubscribeCallbacks)) {
-			callback(balance);
+      callback(balance);
-		}
+    }
-	});
+  });
 
-	if (
+  if (
-		!lbry._balanceUpdateInterval &&
+    !lbry._balanceUpdateInterval &&
-		Object.keys(lbry._balanceSubscribeCallbacks).length
+    Object.keys(lbry._balanceSubscribeCallbacks).length
-	) {
+  ) {
-		lbry._balanceUpdateInterval = setInterval(() => {
+    lbry._balanceUpdateInterval = setInterval(() => {
-			lbry._updateBalanceSubscribers();
+      lbry._updateBalanceSubscribers();
-		}, lbry._balanceSubscribeInterval);
+    }, lbry._balanceSubscribeInterval);
-	}
+  }
 };
 
 lbry.balanceSubscribe = function(callback) {
-	const subscribeId = ++lbry._subscribeIdCount;
+  const subscribeId = ++lbry._subscribeIdCount;
-	lbry._balanceSubscribeCallbacks[subscribeId] = callback;
+  lbry._balanceSubscribeCallbacks[subscribeId] = callback;
-	lbry._updateBalanceSubscribers();
+  lbry._updateBalanceSubscribers();
-	return subscribeId;
+  return subscribeId;
 };
 
 lbry.balanceUnsubscribe = function(subscribeId) {
-	delete lbry._balanceSubscribeCallbacks[subscribeId];
+  delete lbry._balanceSubscribeCallbacks[subscribeId];
-	if (
+  if (
-		lbry._balanceUpdateInterval &&
+    lbry._balanceUpdateInterval &&
-		!Object.keys(lbry._balanceSubscribeCallbacks).length
+    !Object.keys(lbry._balanceSubscribeCallbacks).length
-	) {
+  ) {
-		clearInterval(lbry._balanceUpdateInterval);
+    clearInterval(lbry._balanceUpdateInterval);
-	}
+  }
 };
 
 lbry.showMenuIfNeeded = function() {
-	const showingMenu = sessionStorage.getItem('menuShown') || null;
+  const showingMenu = sessionStorage.getItem("menuShown") || null;
-	const chosenMenu = lbry.getClientSetting('showDeveloperMenu')
+  const chosenMenu = lbry.getClientSetting("showDeveloperMenu")
-		? 'developer'
+    ? "developer"
-		: 'normal';
+    : "normal";
-	if (chosenMenu != showingMenu) {
+  if (chosenMenu != showingMenu) {
-		menu.showMenubar(chosenMenu == 'developer');
+    menu.showMenubar(chosenMenu == "developer");
-	}
+  }
-	sessionStorage.setItem('menuShown', chosenMenu);
+  sessionStorage.setItem("menuShown", chosenMenu);
 };
 
 lbry.getAppVersionInfo = function() {
-	return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
-		ipcRenderer.once('version-info-received', (event, versionInfo) => {
+    ipcRenderer.once("version-info-received", (event, versionInfo) => {
-			resolve(versionInfo);
+      resolve(versionInfo);
-		});
+    });
-		ipcRenderer.send('version-info-requested');
+    ipcRenderer.send("version-info-requested");
-	});
+  });
 };
 
 /**
@@ -447,117 +402,99 @@ lbry.getAppVersionInfo = function() {
  * (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) => {
+  return new Promise((resolve, reject) => {
-		const { name, channel_name, outpoint } = params;
+    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) {
+    if (outpoint) {
-			const pendingPublish = getPendingPublish({ outpoint });
+      const pendingPublish = getPendingPublish({ outpoint });
-			if (pendingPublish) {
+      if (pendingPublish) {
-				resolve([pendingPublishToDummyFileInfo(pendingPublish)]);
+        resolve([pendingPublishToDummyFileInfo(pendingPublish)]);
-				return;
+        return;
-			}
+      }
-		}
+    }
+    
+    apiCall(
+      "file_list",
+      params,
+      fileInfos => {
+        removePendingPublishIfNeeded({ name, channel_name, outpoint });
 
-		lbry.call(
+        const dummyFileInfos = lbry
-			'file_list',
+          .getPendingPublishes()
-			params,
+          .map(pendingPublishToDummyFileInfo);
-			fileInfos => {
+        resolve([...fileInfos, ...dummyFileInfos]);
-				removePendingPublishIfNeeded({ name, channel_name, outpoint });
+      },
-
+      reject
-				const dummyFileInfos = lbry
+    );
-					.getPendingPublishes()
+  });
-					.map(pendingPublishToDummyFileInfo);
-				resolve([...fileInfos, ...dummyFileInfos]);
-			},
-			reject,
-			reject
-		);
-	});
 };
 
 lbry.claim_list_mine = function(params = {}) {
-	return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
-		lbry.call(
+    apiCall(
-			'claim_list_mine',
+      "claim_list_mine",
-			params,
+      params,
-			claims => {
+      claims => {
-				for (let { name, channel_name, txid, nout } of claims) {
+        for (let { name, channel_name, txid, nout } of claims) {
-					removePendingPublishIfNeeded({
+          removePendingPublishIfNeeded({
-						name,
+            name,
-						channel_name,
+            channel_name,
-						outpoint: txid + ':' + nout
+            outpoint: txid + ":" + nout,
-					});
+          });
-				}
+        }
 
-				const dummyClaims = lbry
+        const dummyClaims = lbry
-					.getPendingPublishes()
+          .getPendingPublishes()
-					.map(pendingPublishToDummyClaim);
+          .map(pendingPublishToDummyClaim);
-				resolve([...claims, ...dummyClaims]);
+        resolve([...claims, ...dummyClaims]);
-			},
+      },
-			reject,
+      reject
-			reject
+    );
-		);
+  });
-	});
 };
 
-const claimCacheKey = 'resolve_claim_cache';
+
-lbry._claimCache = getSession(claimCacheKey, {});
 lbry._resolveXhrs = {};
 lbry.resolve = function(params = {}) {
-	return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
-		if (!params.uri) {
+    if (!params.uri) {
-			throw __('Resolve has hacked cache on top of it that requires a URI');
+      throw __("Resolve has hacked cache on top of it that requires a URI");
-		}
+    }
-		if (params.uri && lbry._claimCache[params.uri] !== undefined) {
+    lbry._resolveXhrs[params.uri] = apiCall(
-			resolve(lbry._claimCache[params.uri]);
+      "resolve",
-		} else {
+      params,
-			lbry._resolveXhrs[params.uri] = lbry.call(
+      function(data) {
-				'resolve',
+        resolve(data && data[params.uri] ? data[params.uri] : {});
-				params,
+      },
-				function(data) {
+      reject
-					if (data !== undefined) {
+    );
-						lbry._claimCache[params.uri] = data;
+  });
-					}
-					setSession(claimCacheKey, lbry._claimCache);
-					resolve(data);
-				},
-				reject
-			);
-		}
-	});
 };
 
 lbry.cancelResolve = function(params = {}) {
-	const xhr = lbry._resolveXhrs[params.uri];
+  const xhr = lbry._resolveXhrs[params.uri];
-	if (xhr && xhr.readyState > 0 && xhr.readyState < 4) {
+  if (xhr && xhr.readyState > 0 && xhr.readyState < 4) {
-		xhr.abort();
+    xhr.abort();
-	}
+  }
 };
 
 lbry = new Proxy(lbry, {
-	get: function(target, name) {
+  get: function(target, name) {
-		if (name in target) {
+    if (name in target) {
-			return target[name];
+      return target[name];
-		}
+    }
 
-		return function(params = {}) {
+    return function(params = {}) {
-			return new Promise((resolve, reject) => {
+      return new Promise((resolve, reject) => {
-				jsonrpc.call(
+        apiCall(name, params, resolve, reject);
-					lbry.daemonConnectionString,
+      });
-					name,
+    };
-					params,
+  },
-					resolve,
-					reject,
-					reject
-				);
-			});
-		};
-	}
 });
 
 export default lbry;

ui/js/page/help/view.jsx

@@ -26,12 +26,12 @@ class HelpPage extends React.PureComponent {
           upgradeAvailable: upgradeAvailable,
         });
       });
-    lbry.call("version", {}, info => {
+    lbry.version().then(info => {
       this.setState({
         versionInfo: info,
       });
     });
-    lbry.getSessionInfo(info => {
+    lbry.status({ session_status: true }).then(info => {
       this.setState({
         lbryId: info.lbry_id,
       });

ui/js/page/publish/view.jsx

@@ -134,7 +134,7 @@ class PublishPage extends React.PureComponent {
         publishArgs.file_path = this.refs.file.getValue();
       }
 
-      lbry.publish(
+      lbry.publishDeprecated(
         publishArgs,
         message => {
           this.handlePublishStarted();

ui/js/page/report.js

@@ -1,37 +1,45 @@
 import React from "react";
 import Link from "component/link";
 import { FormRow } from "component/form";
-import Modal from "../component/modal.js";
+import { doShowSnackBar } from "actions/app";
 import lbry from "../lbry.js";
 
-class ReportPage extends React.PureComponent {
+class ReportPage extends React.Component {
   constructor(props) {
     super(props);
 
     this.state = {
       submitting: false,
-      modal: null,
+      message: "",
     };
   }
 
   submitMessage() {
-    if (this._messageArea.value) {
+    const message = this.state.message;
+    if (message) {
       this.setState({
         submitting: true,
       });
-      lbry.reportBug(this._messageArea.value, () => {
+      lbry.report_bug({ message }).then(() => {
         this.setState({
           submitting: false,
-          modal: "submitted",
         });
+
+        // Display global notice
+        const action = doShowSnackBar({
+          message: __("Message received! Thanks for helping."),
+          isError: false,
+        });
+        window.app.store.dispatch(action);
       });
-      this._messageArea.value = "";
+
+      this.setState({ message: "" });
     }
   }
 
-  closeModal() {
+  onMessageChange(event) {
     this.setState({
-      modal: null,
+      message: event.target.value,
     });
   }
 
@@ -49,9 +57,12 @@ class ReportPage extends React.PureComponent {
             <div className="form-row">
               <FormRow
                 type="textarea"
-                ref={t => (this._messageArea = t)}
                 rows="10"
                 name="message"
+                value={this.state.message}
+                onChange={event => {
+                  this.onMessageChange(event);
+                }}
                 placeholder={__("Description of your issue")}
               />
             </div>
@@ -83,17 +94,6 @@ class ReportPage extends React.PureComponent {
             />.
           </div>
         </section>
-        <Modal
-          isOpen={this.state.modal == "submitted"}
-          contentLabel={__("Bug report submitted")}
-          onConfirmed={event => {
-            this.closeModal(event);
-          }}
-        >
-          {__(
-            "Your bug report has been submitted! Thank you for your feedback."
-          )}
-        </Modal>
       </main>
     );
   }

ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lbry-web-ui",
-  "version": "0.12.0",
+  "version": "0.12.2rc2",
   "description": "LBRY UI",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",