Merge pull request #702 from nos/develop

[Release] 0.4.5

Author: mhuggins

package.json

@@ -2,7 +2,7 @@
   "name": "nOS",
   "description": "nOS: NEO Operating System",
   "author": "nOS",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "private": true,
   "main": "dist/main/main.js",
   "license": "MIT",

src/common/util/getRPCEndpoint.js

@@ -66,7 +66,7 @@ export default async function getRPCEndpoint(net) {
     throw new Error('No eligible nodes found!');
   }
 
-  const heightThreshold = nodes[0].height - 1;
+  const heightThreshold = goodNodes[0].height - 1;
   const highestNodes = goodNodes.filter((n) => n.height >= heightThreshold);
   const urls = highestNodes.map((n) => n.url);
 

src/renderer/account/components/Account/index.js

@@ -10,7 +10,7 @@ import currencyActions from 'settings/actions/currencyActions';
 import authActions from 'login/actions/authActions';
 import withInitialCall from 'shared/hocs/withInitialCall';
 import withNetworkData from 'shared/hocs/withNetworkData';
-import { ASSETS } from 'shared/values/assets';
+import { ASSETS, NOS } from 'shared/values/assets';
 
 import Account from './Account';
 import pricesActions from '../../actions/pricesActions';
@@ -23,7 +23,7 @@ const mapCurrencyDataToProps = (currency) => ({ currency });
 
 const mapBalancesDataToProps = (balances) => ({
   balances: pickBy(balances, ({ scriptHash, balance }) => {
-    return keys(ASSETS).includes(scriptHash) || balance !== '0';
+    return keys(ASSETS).includes(scriptHash) || scriptHash === NOS || balance !== '0';
   })
 });
 

src/renderer/account/components/AccountPanel/AccountPanel.scss

@@ -3,6 +3,7 @@
   $border-width: 1px;
 
   display: flex;
+  align-items: flex-start;
 
   .summary {
     flex: 1 1 auto;

src/renderer/account/components/AccountPanel/Holdings/index.js

@@ -1 +1,28 @@
-export { default } from './Holdings';
+import { withProps } from 'recompose';
+import { sortBy } from 'lodash';
+
+import { NOS, NEO, GAS } from 'shared/values/assets';
+
+import Holdings from './Holdings';
+
+/**
+ * Sort by:
+ * 1. preferred tokens
+ * 2. token symbol (ascending)
+ */
+const customSort = (balances, preferredOrder) => {
+  return sortBy(balances, (token) => {
+    const precidence = preferredOrder.findIndex((v) => v === token.scriptHash);
+
+    return [
+      precidence < 0 ? Infinity : precidence,
+      token.symbol
+    ];
+  });
+};
+
+const sortBalances = ({ balances }) => ({
+  balances: customSort(balances, [NOS, NEO, GAS])
+});
+
+export default withProps(sortBalances)(Holdings);

src/renderer/account/components/AccountPanel/TokenBalance/TokenBalance.js

@@ -7,6 +7,7 @@ import TokenIcon from 'shared/components/TokenIcon';
 
 import balanceShape from '../../../shapes/balanceShape';
 import formatCurrency from '../../../util/formatCurrency';
+import formatBalance from '../../../util/formatBalance';
 import ClaimButton from '../ClaimButton';
 import styles from './TokenBalance.scss';
 
@@ -40,7 +41,9 @@ export default class TokenBalance extends React.PureComponent {
       <div className={styles.token}>
         {this.renderImage()}
         <div className={styles.detail}>
-          <div className={styles.balance}>{token.balance} {token.symbol}</div>
+          <div className={styles.balance}>
+            {formatBalance(token.balance, token.decimals)} {token.symbol}
+          </div>
           <div className={styles.currency}>
             <span className={styles.tokenValue}>
               {formatCurrency(price, currency)}

src/renderer/account/util/formatBalance.js

@@ -0,0 +1,11 @@
+import BigNumber from 'bignumber.js';
+
+export default function formatBalance(balance, decimals) {
+  const value = new BigNumber(balance).toFormat(decimals);
+  const [integer, fraction] = value.split('.');
+
+  return [
+    integer,
+    `.${fraction || 0}`.replace(/\.?0+$/, '')
+  ].join('');
+}

src/renderer/browser/actions/makeTestInvokeActions.js

@@ -1,39 +1,51 @@
 import { createActions } from 'spunky';
-import { rpc, wallet } from '@cityofzion/neon-js';
+import { rpc } from '@cityofzion/neon-js';
 import { isArray } from 'lodash';
 
 import getRPCEndpoint from 'util/getRPCEndpoint';
 
 import createScript from 'shared/util/createScript';
 
 import generateDAppActionId from './generateDAppActionId';
+import createArrayScript from '../util/createArrayScript';
+import validateScriptArgs from '../util/validateScriptArgs';
 
 export const ID = 'testInvoke';
 
-const testInvoke = async ({ net, scriptHash, operation, args, encodeArgs }) => {
-  if (!wallet.isScriptHash(scriptHash)) {
-    throw new Error(`Invalid script hash: "${scriptHash}"`);
-  }
-
-  if (typeof operation !== 'string') {
-    throw new Error(`Invalid operation: "${operation}"`);
-  }
-
-  if (!isArray(args)) {
-    throw new Error(`Invalid arguments: "${args}"`);
+const testInvoke = async ({ net, scriptHash, operation, args, script, encodeArgs }) => {
+  let invokeScript;
+
+  if (scriptHash && operation && args) {
+    validateScriptArgs({ scriptHash, operation, args });
+    invokeScript = createScript(scriptHash, operation, args, encodeArgs);
+  } else if (script) {
+    if (typeof script !== 'string' && !isArray(script)) {
+      throw new Error(`Invalid script: "${script}"`);
+    }
+
+    if (typeof script === 'string') {
+      invokeScript = script;
+    } else if (isArray(script)) {
+      script.forEach(validateScriptArgs);
+      invokeScript = createArrayScript(script, encodeArgs);
+    }
+  } else {
+    throw new Error('Invalid config!');
   }
 
   const endpoint = await getRPCEndpoint(net);
-  const script = createScript(scriptHash, operation, args, encodeArgs);
-  const { result } = await rpc.Query.invokeScript(script).execute(endpoint);
+  const { result } = await rpc.Query.invokeScript(invokeScript).execute(endpoint);
 
   return result;
 };
 
 export default function makeTestInvokeActions(sessionId, requestId) {
   const id = generateDAppActionId(sessionId, `${ID}-${requestId}`);
 
-  return createActions(id, ({ net, scriptHash, operation, args, encodeArgs = true }) => () => {
-    return testInvoke({ net, scriptHash, operation, args, encodeArgs });
-  });
+  return createActions(
+    id,
+    ({ net, scriptHash, operation, args, script, encodeArgs = true }) => () => {
+      return testInvoke({ net, scriptHash, operation, args, script, encodeArgs });
+    }
+  );
 }

src/renderer/browser/components/RequestsProcessor/TestInvoke/index.js

@@ -12,7 +12,7 @@ import withRejectMessage from '../../../hocs/withRejectMessage';
 
 const mapInvokeDataToProps = (result) => ({ result });
 
-const CONFIG_KEYS = ['scriptHash', 'operation', 'args', 'encodeArgs'];
+const CONFIG_KEYS = ['scriptHash', 'operation', 'args', 'script', 'encodeArgs'];
 
 export default function makeTestInvoke(testInvokeActions) {
   return compose(
@@ -26,13 +26,17 @@ export default function makeTestInvoke(testInvokeActions) {
     withNetworkData(),
 
     // Run the test invoke & wait for success or failure
-    withInitialCall(testInvokeActions, ({ net, scriptHash, operation, args, encodeArgs }) => ({
-      net,
-      scriptHash,
-      operation,
-      args,
-      encodeArgs
-    })),
+    withInitialCall(
+      testInvokeActions,
+      ({ net, scriptHash, operation, args, script, encodeArgs }) => ({
+        net,
+        scriptHash,
+        operation,
+        args,
+        script,
+        encodeArgs
+      })
+    ),
     withNullLoader(testInvokeActions),
     withRejectMessage(testInvokeActions, ({ operation, scriptHash, error }) => (
       `Invocation failed for operation "${operation}" on "${scriptHash}": ${error}`

src/renderer/browser/util/createArrayScript.js

@@ -0,0 +1,14 @@
+import Neon from '@cityofzion/neon-js';
+
+import encode from 'shared/util/encodeArgs';
+
+const createArrayScript = (scripts, encodeArgs) => {
+  const invokeScripts = scripts.map(({ args, ...restProps }) => {
+    return { ...restProps, args: encodeArgs ? encode(args) : args };
+  });
+
+  // Create script
+  return Neon.create.script(invokeScripts);
+};
+
+export default createArrayScript;

src/renderer/browser/util/validateScriptArgs.js

@@ -0,0 +1,14 @@
+import { wallet } from '@cityofzion/neon-js';
+import { isArray } from 'lodash';
+
+export default ({ scriptHash, operation, args }) => {
+  if (!wallet.isScriptHash(scriptHash)) {
+    throw new Error(`Invalid script hash: "${scriptHash}"`);
+  }
+  if (typeof operation !== 'string') {
+    throw new Error(`Invalid operation: "${operation}"`);
+  }
+  if (!isArray(args)) {
+    throw new Error(`Invalid arguments: "${args}"`);
+  }
+};

src/renderer/root/components/AuthenticatedLayout/AuthenticatedLayout.js

@@ -13,7 +13,7 @@ import Navigation from './Navigation';
 import AddressBar from './AddressBar';
 import styles from './AuthenticatedLayout.scss';
 
-const POLL_FREQUENCY = 10000; // 10 seconds
+const POLL_FREQUENCY = 14000; // milliseconds
 
 export default class AuthenticatedLayout extends React.PureComponent {
   static propTypes = {

src/renderer/shared/util/getBalances.js

@@ -1,23 +1,54 @@
-import { extend, get, find } from 'lodash';
-import { api, rpc, wallet } from '@cityofzion/neon-js';
+import { get, find, map, mapValues, chunk, filter, extend } from 'lodash';
+import { u, sc, rpc, wallet } from '@cityofzion/neon-js';
 
 import getRPCEndpoint from 'util/getRPCEndpoint';
 
 import getTokens from './getTokens';
 import { GAS, NEO, ASSETS } from '../values/assets';
 
-async function getTokenBalance(endpoint, token, address) {
-  try {
-    const response = await api.nep5.getToken(endpoint, token.scriptHash, address);
-    const balance = (response.balance || 0).toString();
-
-    return {
-      [token.scriptHash]: { ...token, ...response, balance }
-    };
-  } catch (err) {
-    // invalid scriptHash
-    return {};
-  }
+const CHUNK_SIZE = 18;
+
+function parseHexNum(hex) {
+  return hex ? parseInt(u.reverseHex(hex), 16) : 0;
+}
+
+function getRawTokenBalances(url, tokens, address) {
+  const addrScriptHash = u.reverseHex(wallet.getScriptHashFromAddress(address));
+  const sb = new sc.ScriptBuilder();
+
+  tokens.forEach(({ scriptHash }) => {
+    sb.emitAppCall(scriptHash, 'balanceOf', [addrScriptHash]);
+  });
+
+  return rpc.Query.invokeScript(sb.str, false)
+    .execute(url)
+    .then((res) => {
+      const tokenList = {};
+
+      if (res && res.result && res.result.stack && res.result.stack.length >= 1) {
+        for (let i = 0; i < res.result.stack.length; i += 1) {
+          const { scriptHash, decimals } = tokens[i];
+          const value = parseHexNum(res.result.stack[i].value);
+          tokenList[scriptHash] = new u.Fixed8(value).div(10 ** decimals).toString();
+        }
+      }
+      return tokenList;
+    });
+}
+
+async function getTokenBalances(endpoint, address) {
+  const tokens = await getTokens();
+  const chunks = chunk(map(tokens, 'scriptHash'), CHUNK_SIZE);
+
+  const balances = extend({}, ...await Promise.all(chunks.map((scriptHashes) => {
+    const filteredTokens = filter(tokens, (token) => scriptHashes.includes(token.scriptHash));
+    return getRawTokenBalances(endpoint, filteredTokens, address);
+  })));
+
+  return mapValues(balances, (balance, scriptHash) => ({
+    ...find(tokens, { scriptHash }),
+    balance
+  }));
 }
 
 async function getAssetBalances(endpoint, address) {
@@ -40,13 +71,8 @@ export default async function getBalances({ net, address }) {
     throw new Error(`Invalid address: "${address}"`);
   }
 
-  // token balances - // TODO use getTokenBalances to avoid multiple api calls
-  const promises = (await getTokens(net)).map((token) => {
-    return getTokenBalance(endpoint, token, address);
-  });
-
-  // asset balances
-  promises.unshift(getAssetBalances(endpoint, address));
+  const assets = await getAssetBalances(endpoint, address);
+  const tokens = await getTokenBalances(endpoint, address);
 
-  return extend({}, ...await Promise.all(promises));
+  return { ...assets, ...tokens };
 }

src/renderer/shared/util/getTokens.js

@@ -11,16 +11,16 @@ function normalizeImage(src) {
   return trim(src) === '' ? null : src;
 }
 
-export default async function getTokens(net) {
+export default async function getTokens(net = 'MainNet') {
   const networkKey = NETWORK_MAP[net];
 
   const response = await fetch(TOKENS_URL);
   const tokens = values(await response.json());
   const networkTokens = filter(tokens, (token) => token.networks[networkKey]);
   const sortedTokens = sortBy(networkTokens, 'symbol');
 
-  return sortedTokens.map(({ image, networks }) => {
+  return sortedTokens.map(({ image, symbol, networks }) => {
     const { name, hash: scriptHash, decimals, totalSupply } = networks[networkKey];
-    return { name, scriptHash, decimals, totalSupply, image: normalizeImage(image) };
+    return { name, symbol, scriptHash, decimals, totalSupply, image: normalizeImage(image) };
   });
 }

src/renderer/shared/values/assets.js

@@ -1,3 +1,4 @@
+export const NOS = 'c9c0fc5a2b66a29d6b14601e752e6e1a445e088d';
 export const NEO = 'c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b';
 export const GAS = '602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7';