feat: adding a getSendAmountFee function (#107)

* added getsendamountfee to wallet core, needed for updating fees in extension and mobile

* added return statement to return sendFees

* remove unnecessary comment

* fix PR comments, reversed to previous string amount type

* fix: new push to change title

Author: johannafransn

src/store/getters.ts

@@ -1,5 +1,5 @@
 import { Client } from '@chainify/client';
-import { Nullable } from '@chainify/types';
+import { FeeDetails, Nullable } from '@chainify/types';
 import { Asset, assets as cryptoassets, AssetTypes, ChainId, unitToCurrency } from '@liquality/cryptoassets';
 import BN, { BigNumber } from 'bignumber.js';
 import { mapValues, orderBy, uniq } from 'lodash';
@@ -201,6 +201,12 @@ export default {
       return account;
     };
   },
+  assetFees(...context: GetterContext) {
+    const { state } = rootGetterContext(context);
+    return (asset: AssetType): FeeDetails | undefined => {
+      return state.fees?.[state.activeNetwork]?.[state.activeWalletId]?.[asset]
+    }
+  },
   accountsWithBalance(...context: GetterContext): Account[] {
     const { getters } = rootGetterContext(context);
     const { accountsData } = getters;
@@ -226,101 +232,102 @@ export default {
     const { accounts, activeNetwork, activeWalletId, enabledChains } = state;
     const { accountFiatBalance, assetFiatBalance, assetMarketCap } = getters;
 
+
     const _accounts = accounts[activeWalletId]?.[activeNetwork]
       ? accounts[activeWalletId]![activeNetwork].filter(
-          (account) =>
-            account.assets &&
-            account.enabled &&
-            account.assets.length > 0 &&
-            enabledChains[activeWalletId]?.[activeNetwork]?.includes(account.chain)
-        )
-          .map((account) => {
-            /*
-                Calculate fiat balances and asset balances
-                Sort and group assets by dollar value / token amount / market cap
-            */
-            const totalFiatBalance = accountFiatBalance(activeWalletId, activeNetwork, account.id);
-            const assetsWithFiat: AssetInfo[] = [];
-            const assetsWithMarketCap: AssetInfo[] = [];
-            const assetsWithTokenBalance: AssetInfo[] = [];
-            let assetsMarketCap: CurrenciesInfo = {} as any;
-            let hasFiat = false;
-            let hasTokenBalance = false;
-            let nativeAssetMarketCap = new BN(0);
-
-            const fiatBalances = Object.entries(account.balances).reduce((accum, [asset, balance]) => {
-              const fiat = assetFiatBalance(asset, new BN(balance));
-              const marketCap = assetMarketCap(asset);
-              const tokenBalance = account.balances[asset];
-              let type = AssetTypes.erc20;
-              let matchingAsset;
-
-              if (cryptoassets[asset]) {
-                type = cryptoassets[asset].type;
-                matchingAsset = cryptoassets[asset].matchingAsset;
+        (account) =>
+          account.assets &&
+          account.enabled &&
+          account.assets.length > 0 &&
+          enabledChains[activeWalletId]?.[activeNetwork]?.includes(account.chain)
+      )
+        .map((account) => {
+          /*
+              Calculate fiat balances and asset balances
+              Sort and group assets by dollar value / token amount / market cap
+          */
+          const totalFiatBalance = accountFiatBalance(activeWalletId, activeNetwork, account.id);
+          const assetsWithFiat: AssetInfo[] = [];
+          const assetsWithMarketCap: AssetInfo[] = [];
+          const assetsWithTokenBalance: AssetInfo[] = [];
+          let assetsMarketCap: CurrenciesInfo = {} as any;
+          let hasFiat = false;
+          let hasTokenBalance = false;
+          let nativeAssetMarketCap = new BN(0);
+
+          const fiatBalances = Object.entries(account.balances).reduce((accum, [asset, balance]) => {
+            const fiat = assetFiatBalance(asset, new BN(balance));
+            const marketCap = assetMarketCap(asset);
+            const tokenBalance = account.balances[asset];
+            let type = AssetTypes.erc20;
+            let matchingAsset;
+
+            if (cryptoassets[asset]) {
+              type = cryptoassets[asset].type;
+              matchingAsset = cryptoassets[asset].matchingAsset;
+            }
+
+            if (fiat) {
+              hasFiat = true;
+              assetsWithFiat.push({ asset, type, amount: fiat });
+            } else if (marketCap) {
+              if (type === AssetTypes.native && !matchingAsset) {
+                nativeAssetMarketCap = marketCap;
               }
 
-              if (fiat) {
-                hasFiat = true;
-                assetsWithFiat.push({ asset, type, amount: fiat });
-              } else if (marketCap) {
-                if (type === AssetTypes.native && !matchingAsset) {
-                  nativeAssetMarketCap = marketCap;
-                }
-
-                assetsWithMarketCap.push({ asset, type, amount: marketCap || new BN(0) });
-              } else {
-                if (!hasTokenBalance) {
-                  hasTokenBalance = new BN(tokenBalance).gt(0);
-                }
-
-                assetsWithTokenBalance.push({ asset, type, amount: new BN(tokenBalance) });
+              assetsWithMarketCap.push({ asset, type, amount: marketCap || new BN(0) });
+            } else {
+              if (!hasTokenBalance) {
+                hasTokenBalance = new BN(tokenBalance).gt(0);
               }
 
-              assetsMarketCap = {
-                ...assetsMarketCap,
-                [asset]: marketCap || new BN(0),
-              };
-
-              return {
-                ...accum,
-                [asset]: fiat,
-              };
-            }, {});
-
-            const sortedAssetsByFiat = orderBy(assetsWithFiat, 'amount', 'desc');
-            const sortedAssetsByMarketCap = orderBy(assetsWithMarketCap, 'amount', 'desc');
-            const sortedAssetsByTokenBalance = orderBy(assetsWithTokenBalance, 'amount', 'desc');
-
-            const orderedAssets = orderAssets(
-              hasFiat,
-              hasTokenBalance,
-              sortedAssetsByFiat,
-              sortedAssetsByMarketCap,
-              sortedAssetsByTokenBalance
-            );
+              assetsWithTokenBalance.push({ asset, type, amount: new BN(tokenBalance) });
+            }
+
+            assetsMarketCap = {
+              ...assetsMarketCap,
+              [asset]: marketCap || new BN(0),
+            };
 
             return {
-              ...account,
-              assets: orderedAssets.length ? orderedAssets : account.assets,
-              nativeAssetMarketCap,
-              assetsMarketCap,
-              fiatBalances,
-              totalFiatBalance,
+              ...accum,
+              [asset]: fiat,
             };
-          })
-          .sort(orderChains)
-          .reduce((acc: { [key: string]: Account[] }, account) => {
-            /*
-                Group sorted assets by chain / multiaccount ordering
-            */
-            const { chain } = account;
-
-            acc[chain] = acc[chain] ?? [];
-            acc[chain].push(account);
-
-            return acc;
-          }, {})
+          }, {});
+
+          const sortedAssetsByFiat = orderBy(assetsWithFiat, 'amount', 'desc');
+          const sortedAssetsByMarketCap = orderBy(assetsWithMarketCap, 'amount', 'desc');
+          const sortedAssetsByTokenBalance = orderBy(assetsWithTokenBalance, 'amount', 'desc');
+
+          const orderedAssets = orderAssets(
+            hasFiat,
+            hasTokenBalance,
+            sortedAssetsByFiat,
+            sortedAssetsByMarketCap,
+            sortedAssetsByTokenBalance
+          );
+
+          return {
+            ...account,
+            assets: orderedAssets.length ? orderedAssets : account.assets,
+            nativeAssetMarketCap,
+            assetsMarketCap,
+            fiatBalances,
+            totalFiatBalance,
+          };
+        })
+        .sort(orderChains)
+        .reduce((acc: { [key: string]: Account[] }, account) => {
+          /*
+              Group sorted assets by chain / multiaccount ordering
+          */
+          const { chain } = account;
+
+          acc[chain] = acc[chain] ?? [];
+          acc[chain].push(account);
+
+          return acc;
+        }, {})
       : [];
     return Object.values(_accounts).flat();
   },

src/utils/asset.ts

@@ -155,7 +155,10 @@ export const getNativeAsset = (asset: Asset) => {
 };
 
 export const getFeeAsset = (asset: Asset) => {
-  return cryptoassets[asset]?.feeAsset;
+  if (!cryptoassets[asset]) {
+    throw new Error('Asset does not exist')
+  }
+  return cryptoassets[asset].feeAsset;
 };
 
 export const getAssetColorStyle = (asset: Asset) => {

src/utils/fees.ts

@@ -1,7 +1,11 @@
-import { ChainId, unitToCurrency } from '@liquality/cryptoassets';
+import { BitcoinBaseWalletProvider, BitcoinEsploraApiProvider } from '@chainify/bitcoin';
+import { Client } from '@chainify/client';
+import { FeeDetails } from '@chainify/types';
+import { ChainId, currencyToUnit, unitToCurrency } from '@liquality/cryptoassets';
 import BN from 'bignumber.js';
-import { Asset } from '../store/types';
-import { getNativeAsset, isERC20, isEthereumChain } from './asset';
+import store from '../store';
+import { AccountId, Asset } from '../store/types';
+import { getFeeAsset, getNativeAsset, isERC20, isEthereumChain } from './asset';
 import cryptoassets from './cryptoassets';
 
 type FeeUnits = { [asset: Asset]: number };
@@ -42,4 +46,46 @@ function isEIP1559Fees(chain: ChainId) {
   return chain === ChainId.Ethereum || chain === ChainId.Polygon || chain === ChainId.Avalanche;
 }
 
-export { FEE_OPTIONS, getSendFee, getTxFee, getFeeLabel, isEIP1559Fees };
+
+async function getSendAmountFee(accountId: AccountId, asset: Asset, amount?: BN) {
+  const getMax = amount === undefined
+  const sendFees: {
+    [speed in keyof FeeDetails]: BN
+  } = { slow: new BN(0), average: new BN(0), fast: new BN(0), }
+
+  const assetFees = store.getters.assetFees(asset);
+  const feeAsset = getFeeAsset(asset) || getNativeAsset(asset)
+  if (assetFees) {
+    for (const [speed, fee] of Object.entries(assetFees)) {
+      const feePrice = fee.fee.maxPriorityFeePerGas + fee.fee.suggestedBaseFeePerGas || fee.fee
+      sendFees[speed as keyof FeeDetails] = getSendFee(feeAsset, feePrice)
+    }
+    if (asset === 'BTC') {
+      const client = store.getters.client({
+        network: store.state.activeNetwork,
+        walletId: store.state.activeWalletId,
+        asset: asset,
+        accountId: accountId
+      }) as Client<
+        BitcoinEsploraApiProvider,
+        BitcoinBaseWalletProvider
+      >;
+      const feePerBytes = Object.values(assetFees).map((fee) => fee.fee)
+      const value = getMax ? undefined : currencyToUnit(cryptoassets[asset], amount)
+      try {
+        const txs = feePerBytes.map((fee) => ({ value, fee }))
+
+        const totalFees = await client.wallet.getTotalFees(txs, getMax)
+        for (const [speed, fee] of Object.entries(assetFees)) {
+          const totalFee = unitToCurrency(cryptoassets[asset], totalFees[fee.fee])
+          sendFees[speed as keyof FeeDetails] = totalFee
+        }
+      } catch (e) {
+        console.error(e)
+      }
+    }
+    return sendFees
+  }
+}
+
+export { FEE_OPTIONS, getSendFee, getTxFee, getFeeLabel, isEIP1559Fees, getSendAmountFee };