Merge branch 'development' into fix/dev-tools-pages/finalTouches

* development: (49 commits)
  upgrade to ddex api v3 (#1507)
  Add new deployment related instructions to pipeline README (#1499)
  feature: implement logging and friendly wallet name for Opera
  Fix prettier
  Add missing dependencies
  Remove second yarn call
  Add .gitkeep
  Rename sol-trace-based-tools-common to sol-tracing-utils
  Update packages/sol-trace/README.md
  Update packages/sol-trace/CHANGELOG.json
  Update packages/sol-trace-based-tools-common/src/source_maps.ts
  Update packages/sol-trace-based-tools-common/CHANGELOG.json
  Update packages/sol-profiler/CHANGELOG.json
  Update packages/sol-coverage/CHANGELOG.json
  Update packages/monorepo-scripts/src/test_installation.ts
  chore: changelog update
  fix: account for undefined errors in promisify, not only null
  Clean up docs before publish
  In README's, don't mention non-existent tests (#1497)
  fix: use getBackendBaseUrl instead of hardcoded string
  ...

6 files changed, 74 insertions, 9 deletions

diff --git a/packages/instant/src/constants.ts b/packages/instant/src/constants.ts
index 22f0cb6a4..bfd9e9098 100644
--- a/packages/instant/src/constants.ts
+++ b/packages/instant/src/constants.ts
@@ -16,6 +16,7 @@ export const ONE_SECOND_MS = 1000;
 export const ONE_MINUTE_MS = ONE_SECOND_MS * 60;
 export const GIT_SHA = process.env.GIT_SHA;
 export const NODE_ENV = process.env.NODE_ENV;
+export const SLIPPAGE_PERCENTAGE = 0.2;
 export const NPM_PACKAGE_VERSION = process.env.NPM_PACKAGE_VERSION;
 export const DEFAULT_UNKOWN_ASSET_NAME = '???';
 export const ACCOUNT_UPDATE_INTERVAL_TIME_MS = ONE_SECOND_MS * 5;
@@ -73,5 +74,6 @@ export const PROVIDER_TYPE_TO_NAME: { [key in ProviderType]: string } = {
     [ProviderType.CoinbaseWallet]: 'Coinbase Wallet',
     [ProviderType.Parity]: 'Parity',
     [ProviderType.TrustWallet]: 'Trust Wallet',
+    [ProviderType.Opera]: 'Opera Wallet',
     [ProviderType.Fallback]: 'Fallback',
 };
diff --git a/packages/instant/src/types.ts b/packages/instant/src/types.ts
index ae672c919..f07a407da 100644
--- a/packages/instant/src/types.ts
+++ b/packages/instant/src/types.ts
@@ -183,6 +183,7 @@ export enum ProviderType {
     CoinbaseWallet = 'COINBASE_WALLET',
     Cipher = 'CIPHER',
     TrustWallet = 'TRUST_WALLET',
+    Opera = 'OPERA',
     Fallback = 'FALLBACK',
 }
 
diff --git a/packages/instant/src/util/asset.ts b/packages/instant/src/util/asset.ts
index faaeb7c22..b009a327f 100644
--- a/packages/instant/src/util/asset.ts
+++ b/packages/instant/src/util/asset.ts
@@ -1,8 +1,10 @@
-import { AssetBuyerError } from '@0x/asset-buyer';
+import { AssetBuyerError, InsufficientAssetLiquidityError } from '@0x/asset-buyer';
 import { AssetProxyId, ObjectMap } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+import { Web3Wrapper } from '@0x/web3-wrapper';
 import * as _ from 'lodash';
 
-import { DEFAULT_UNKOWN_ASSET_NAME } from '../constants';
+import { BIG_NUMBER_ZERO, DEFAULT_UNKOWN_ASSET_NAME } from '../constants';
 import { assetDataNetworkMapping } from '../data/asset_data_network_mapping';
 import { Asset, AssetMetaData, ERC20Asset, Network, ZeroExInstantError } from '../types';
 
@@ -111,6 +113,21 @@ export const assetUtils = {
     assetBuyerErrorMessage: (asset: ERC20Asset, error: Error): string | undefined => {
         if (error.message === AssetBuyerError.InsufficientAssetLiquidity) {
             const assetName = assetUtils.bestNameForAsset(asset, 'of this asset');
+            if (
+                error instanceof InsufficientAssetLiquidityError &&
+                error.amountAvailableToFill.greaterThan(BIG_NUMBER_ZERO)
+            ) {
+                const unitAmountAvailableToFill = Web3Wrapper.toUnitAmount(
+                    error.amountAvailableToFill,
+                    asset.metaData.decimals,
+                );
+                const roundedUnitAmountAvailableToFill = unitAmountAvailableToFill.round(2, BigNumber.ROUND_DOWN);
+
+                if (roundedUnitAmountAvailableToFill.greaterThan(BIG_NUMBER_ZERO)) {
+                    return `There are only ${roundedUnitAmountAvailableToFill} ${assetName} available to buy`;
+                }
+            }
+
             return `Not enough ${assetName} available`;
         } else if (error.message === AssetBuyerError.InsufficientZrxLiquidity) {
             return 'Not enough ZRX available';
diff --git a/packages/instant/src/util/buy_quote_updater.ts b/packages/instant/src/util/buy_quote_updater.ts
index 6191c92e3..37974e71c 100644
--- a/packages/instant/src/util/buy_quote_updater.ts
+++ b/packages/instant/src/util/buy_quote_updater.ts
@@ -5,6 +5,7 @@ import * as _ from 'lodash';
 import { Dispatch } from 'redux';
 import { oc } from 'ts-optchain';
 
+import { SLIPPAGE_PERCENTAGE } from '../constants';
 import { Action, actions } from '../redux/actions';
 import { AffiliateInfo, ERC20Asset, QuoteFetchOrigin } from '../types';
 import { analytics } from '../util/analytics';
@@ -33,8 +34,12 @@ export const buyQuoteUpdater = {
         }
         const feePercentage = oc(options.affiliateInfo).feePercentage();
         let newBuyQuote: BuyQuote | undefined;
+        const slippagePercentage = SLIPPAGE_PERCENTAGE;
         try {
-            newBuyQuote = await assetBuyer.getBuyQuoteAsync(asset.assetData, baseUnitValue, { feePercentage });
+            newBuyQuote = await assetBuyer.getBuyQuoteAsync(asset.assetData, baseUnitValue, {
+                feePercentage,
+                slippagePercentage,
+            });
         } catch (error) {
             const errorMessage = assetUtils.assetBuyerErrorMessage(asset, error);
 
diff --git a/packages/instant/src/util/env.ts b/packages/instant/src/util/env.ts
index aedf4f5d6..7d4f836ff 100644
--- a/packages/instant/src/util/env.ts
+++ b/packages/instant/src/util/env.ts
@@ -42,18 +42,21 @@ export const envUtil = {
         }
     },
     getProviderType(provider: Provider): ProviderType | undefined {
+        const anyProvider = provider as any;
         if (provider.constructor.name === 'EthereumProvider') {
             return ProviderType.Mist;
-        } else if ((provider as any).isTrust) {
+        } else if (anyProvider.isTrust) {
             return ProviderType.TrustWallet;
-        } else if ((provider as any).isParity) {
+        } else if (anyProvider.isParity) {
             return ProviderType.Parity;
-        } else if ((provider as any).isMetaMask) {
+        } else if (anyProvider.isMetaMask) {
             return ProviderType.MetaMask;
         } else if (!_.isUndefined(_.get(window, 'SOFA'))) {
             return ProviderType.CoinbaseWallet;
         } else if (!_.isUndefined(_.get(window, '__CIPHER__'))) {
             return ProviderType.Cipher;
+        } else if (envUtil.getBrowser() === Browser.Opera && !anyProvider.isMetaMask) {
+            return ProviderType.Opera;
         }
         return;
     },
diff --git a/packages/instant/test/util/asset.test.ts b/packages/instant/test/util/asset.test.ts
index fc4e4e2e4..402a556d5 100644
--- a/packages/instant/test/util/asset.test.ts
+++ b/packages/instant/test/util/asset.test.ts
@@ -1,5 +1,6 @@
-import { AssetBuyerError } from '@0x/asset-buyer';
+import { AssetBuyerError, BigNumber, InsufficientAssetLiquidityError } from '@0x/asset-buyer';
 import { AssetProxyId, ObjectMap } from '@0x/types';
+import { Web3Wrapper } from '@0x/web3-wrapper';
 
 import { Asset, AssetMetaData, ERC20Asset, ERC20AssetMetaData, Network, ZeroExInstantError } from '../../src/types';
 import { assetUtils } from '../../src/util/asset';
@@ -19,6 +20,16 @@ const ZRX_ASSET: ERC20Asset = {
 const META_DATA_MAP: ObjectMap<AssetMetaData> = {
     [ZRX_ASSET_DATA]: ZRX_META_DATA,
 };
+const WAX_ASSET: ERC20Asset = {
+    assetData: '0xf47261b000000000000000000000000039bb259f66e1c59d5abef88375979b4d20d98022',
+    metaData: {
+        assetProxyId: AssetProxyId.ERC20,
+        decimals: 8,
+        primaryColor: '#EDB740',
+        symbol: 'wax',
+        name: 'WAX',
+    },
+};
 
 describe('assetDataUtil', () => {
     describe('bestNameForAsset', () => {
@@ -47,13 +58,39 @@ describe('assetDataUtil', () => {
         });
     });
     describe('assetBuyerErrorMessage', () => {
-        it('should return message for InsufficientAssetLiquidity', () => {
+        it('should return message for generic InsufficientAssetLiquidity error', () => {
             const insufficientAssetError = new Error(AssetBuyerError.InsufficientAssetLiquidity);
             expect(assetUtils.assetBuyerErrorMessage(ZRX_ASSET, insufficientAssetError)).toEqual(
                 'Not enough ZRX available',
             );
         });
-        it('should return message for InsufficientAssetLiquidity', () => {
+        describe('InsufficientAssetLiquidityError', () => {
+            it('should return custom message for token w/ 18 decimals', () => {
+                const amountAvailable = Web3Wrapper.toBaseUnitAmount(new BigNumber(20.059), 18);
+                expect(
+                    assetUtils.assetBuyerErrorMessage(ZRX_ASSET, new InsufficientAssetLiquidityError(amountAvailable)),
+                ).toEqual('There are only 20.05 ZRX available to buy');
+            });
+            it('should return custom message for token w/ 18 decimals and small amount available', () => {
+                const amountAvailable = Web3Wrapper.toBaseUnitAmount(new BigNumber(0.01), 18);
+                expect(
+                    assetUtils.assetBuyerErrorMessage(ZRX_ASSET, new InsufficientAssetLiquidityError(amountAvailable)),
+                ).toEqual('There are only 0.01 ZRX available to buy');
+            });
+            it('should return custom message for token w/ 8 decimals', () => {
+                const amountAvailable = Web3Wrapper.toBaseUnitAmount(new BigNumber(3), 8);
+                expect(
+                    assetUtils.assetBuyerErrorMessage(WAX_ASSET, new InsufficientAssetLiquidityError(amountAvailable)),
+                ).toEqual('There are only 3 WAX available to buy');
+            });
+            it('should return generic message when amount available rounds to zero', () => {
+                const amountAvailable = Web3Wrapper.toBaseUnitAmount(new BigNumber(0.002), 18);
+                expect(
+                    assetUtils.assetBuyerErrorMessage(ZRX_ASSET, new InsufficientAssetLiquidityError(amountAvailable)),
+                ).toEqual('Not enough ZRX available');
+            });
+        });
+        it('should return message for InsufficientZrxLiquidity', () => {
             const insufficientZrxError = new Error(AssetBuyerError.InsufficientZrxLiquidity);
             expect(assetUtils.assetBuyerErrorMessage(ZRX_ASSET, insufficientZrxError)).toEqual(
                 'Not enough ZRX available',