@ledgerhq/coin-evm 0.2.1 → 0.2.2-nightly.0

package/src/__tests__/transaction.unit.test.ts

@@ -1,12 +1,8 @@
 import BigNumber from "bignumber.js";
 import { ethers } from "ethers";
 import { transactionToEthersTransaction } from "../adapters";
-import * as rpcAPI from "../api/rpc.common";
-import {
-  fromTransactionRaw,
-  getSerializedTransaction,
-  toTransactionRaw,
-} from "../transaction";
+import * as rpcAPI from "../api/rpc/rpc.common";
+import { fromTransactionRaw, getSerializedTransaction, toTransactionRaw } from "../transaction";
 import {
   Transaction as EvmTransaction,
   EvmTransactionEIP1559,
@@ -134,17 +130,13 @@ describe("EVM Family", () => {
           gasPrice: ethers.BigNumber.from(10000),
         };
 
-        expect(transactionToEthersTransaction(legacyTx)).toEqual(
-          legacyEthersTx
-        );
+        expect(transactionToEthersTransaction(legacyTx)).toEqual(legacyEthersTx);
       });
     });
 
     describe("getSerializedTransaction", () => {
       beforeAll(() => {
-        jest
-          .spyOn(rpcAPI, "getTransactionCount")
-          .mockImplementation(() => Promise.resolve(0));
+        jest.spyOn(rpcAPI, "getTransactionCount").mockImplementation(() => Promise.resolve(0));
       });
 
       it("should serialize a type 0 transaction", async () => {
@@ -165,7 +157,7 @@ describe("EVM Family", () => {
         const serializedTx = await getSerializedTransaction(transactionLegacy);
 
         expect(serializedTx).toBe(
-          "0xdf8064825208946775e49108cb77cda06fc3bef51bcd497602ad886480018080"
+          "0xdf8064825208946775e49108cb77cda06fc3bef51bcd497602ad886480018080",
         );
       });
 
@@ -188,7 +180,7 @@ describe("EVM Family", () => {
         const serializedTx = await getSerializedTransaction(transactionEIP1559);
 
         expect(serializedTx).toBe(
-          "0x02df01806464825208946775e49108cb77cda06fc3bef51bcd497602ad886480c0"
+          "0x02df01806464825208946775e49108cb77cda06fc3bef51bcd497602ad886480c0",
         );
       });
     });

package/src/adapters.ts

@@ -4,10 +4,7 @@ import BigNumber from "bignumber.js";
 import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { Operation, OperationType } from "@ledgerhq/types-live";
 import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
-import {
-  decodeAccountId,
-  encodeTokenAccountId,
-} from "@ledgerhq/coin-framework/account/index";
+import { decodeAccountId, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import {
   Transaction as EvmTransaction,
@@ -20,9 +17,7 @@ import {
 /**
  * Adapter to convert a Ledger Live transaction to an Ethers transaction
  */
-export const transactionToEthersTransaction = (
-  tx: EvmTransaction
-): ethers.Transaction => {
+export const transactionToEthersTransaction = (tx: EvmTransaction): ethers.Transaction => {
   const ethersTx = {
     to: tx.recipient,
     value: ethers.BigNumber.from(tx.amount.toFixed()),
@@ -36,16 +31,14 @@ export const transactionToEthersTransaction = (
   // is EIP-1559 transaction (type 2)
   if (tx.type === 2) {
     ethersTx.maxFeePerGas = ethers.BigNumber.from(
-      (tx as EvmTransactionEIP1559).maxFeePerGas.toFixed()
+      (tx as EvmTransactionEIP1559).maxFeePerGas.toFixed(),
     );
     ethersTx.maxPriorityFeePerGas = ethers.BigNumber.from(
-      (tx as EvmTransactionEIP1559).maxPriorityFeePerGas.toFixed()
+      (tx as EvmTransactionEIP1559).maxPriorityFeePerGas.toFixed(),
     );
   } else {
     // is Legacy transaction (type 0)
-    ethersTx.gasPrice = ethers.BigNumber.from(
-      (tx as EvmTransactionLegacy).gasPrice.toFixed()
-    );
+    ethersTx.gasPrice = ethers.BigNumber.from((tx as EvmTransactionLegacy).gasPrice.toFixed());
   }
 
   return ethersTx as ethers.Transaction;
@@ -56,7 +49,7 @@ export const transactionToEthersTransaction = (
  */
 export const etherscanOperationToOperation = (
   accountId: string,
-  tx: EtherscanOperation
+  tx: EtherscanOperation,
 ): Operation => {
   const { xpubOrAddress: address } = decodeAccountId(accountId);
   const checksummedAddress = eip55.encode(address);
@@ -99,13 +92,10 @@ export const etherscanOperationToOperation = (
  */
 export const etherscanERC20EventToOperation = (
   accountId: string,
-  event: EtherscanERC20Event
+  event: EtherscanERC20Event,
 ): { tokenCurrency: TokenCurrency; operation: Operation } | null => {
   const { currencyId, xpubOrAddress: address } = decodeAccountId(accountId);
-  const tokenCurrency = findTokenByAddressInCurrency(
-    event.contractAddress,
-    currencyId
-  );
+  const tokenCurrency = findTokenByAddressInCurrency(event.contractAddress, currencyId);
   if (!tokenCurrency) return null;
 
   const tokenAccountId = encodeTokenAccountId(accountId, tokenCurrency);

package/src/api/{etherscan.ts → explorer/etherscan.ts}

@@ -3,19 +3,16 @@ import { Operation } from "@ledgerhq/types-live";
 import axios, { AxiosRequestConfig } from "axios";
 import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { makeLRUCache } from "@ledgerhq/live-network/cache";
-import { EtherscanERC20Event, EtherscanOperation } from "../types";
-import { EtherscanAPIError } from "../errors";
-import {
-  etherscanERC20EventToOperation,
-  etherscanOperationToOperation,
-} from "../adapters";
+import { EtherscanERC20Event, EtherscanOperation } from "../../types";
+import { EtherscanAPIError } from "../../errors";
+import { etherscanERC20EventToOperation, etherscanOperationToOperation } from "../../adapters";
 
 export const ETHERSCAN_TIMEOUT = 5000; // 5 seconds between 2 calls
 export const DEFAULT_RETRIES_API = 8;
 
 async function fetchWithRetries<T>(
   params: AxiosRequestConfig,
-  retries = DEFAULT_RETRIES_API
+  retries = DEFAULT_RETRIES_API,
 ): Promise<T> {
   try {
     const { data } = await axios.request<{
@@ -25,10 +22,10 @@ async function fetchWithRetries<T>(
     }>(params);
 
     if (!Number(data.status) && data.message === "NOTOK") {
-      throw new EtherscanAPIError(
-        "Error while fetching data from Etherscan like API",
-        { params, data }
-      );
+      throw new EtherscanAPIError("Error while fetching data from Etherscan like API", {
+        params,
+        data,
+      });
     }
 
     return data.result;
@@ -47,12 +44,7 @@ async function fetchWithRetries<T>(
  * Get all the last "normal" transactions (no tokens / NFTs)
  */
 export const getLastCoinOperations = makeLRUCache<
-  [
-    currency: CryptoCurrency,
-    address: string,
-    accountId: string,
-    fromBlock: number
-  ],
+  [currency: CryptoCurrency, address: string, accountId: string, fromBlock: number],
   Operation[]
 >(
   async (currency, address, accountId, fromBlock) => {
@@ -72,23 +64,18 @@ export const getLastCoinOperations = makeLRUCache<
     });
 
     return ops
-      .map((tx) => etherscanOperationToOperation(accountId, tx))
+      .map(tx => etherscanOperationToOperation(accountId, tx))
       .filter(Boolean) as Operation[];
   },
   (currency, address, accountId, fromBlock) => accountId + fromBlock,
-  { ttl: 5 * 1000 }
+  { ttl: 5 * 1000 },
 );
 
 /**
  * Get all the last ERC20 transactions
  */
 export const getLastTokenOperations = makeLRUCache<
-  [
-    currency: CryptoCurrency,
-    address: string,
-    accountId: string,
-    fromBlock: number
-  ],
+  [currency: CryptoCurrency, address: string, accountId: string, fromBlock: number],
   { tokenCurrency: TokenCurrency; operation: Operation }[]
 >(
   async (currency, address, accountId, fromBlock) => {
@@ -107,15 +94,13 @@ export const getLastTokenOperations = makeLRUCache<
       url,
     });
 
-    return ops
-      .map((event) => etherscanERC20EventToOperation(accountId, event))
-      .filter(Boolean) as {
+    return ops.map(event => etherscanERC20EventToOperation(accountId, event)).filter(Boolean) as {
       tokenCurrency: TokenCurrency;
       operation: Operation;
     }[];
   },
   (currency, address, accountId, fromBlock) => accountId + fromBlock,
-  { ttl: 5 * 1000 }
+  { ttl: 5 * 1000 },
 );
 
 export default {

package/src/api/explorer/index.ts

@@ -0,0 +1,34 @@
+import { CacheRes } from "@ledgerhq/live-network/cache";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { Operation } from "@ledgerhq/types-live";
+import etherscanLikeApi from "./etherscan";
+
+type ExplorerApi = {
+  getLastCoinOperations: CacheRes<
+    [currency: CryptoCurrency, address: string, accountId: string, fromBlock: number],
+    Operation[]
+  >;
+  getLastTokenOperations: CacheRes<
+    [currency: CryptoCurrency, address: string, accountId: string, fromBlock: number],
+    {
+      tokenCurrency: TokenCurrency;
+      operation: Operation;
+    }[]
+  >;
+};
+
+/**
+ * Switch to select one of the compatible explorer
+ */
+export const getExplorerApi = (currency: CryptoCurrency): ExplorerApi => {
+  const apiType = currency.ethereumLikeInfo?.explorer?.type;
+
+  switch (apiType) {
+    case "etherscan":
+    case "blockscout":
+      return etherscanLikeApi;
+
+    default:
+      throw new Error(`No explorer found for currency "${currency.id}"`);
+  }
+};

package/src/api/gasTracker/index.ts

@@ -0,0 +1,31 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { GasOptions } from "../../types";
+import { getGasOptions as ledgerGetGasOptions } from "./ledger";
+
+type GasTrackerApi = {
+  getGasOptions: ({
+    currency,
+    options,
+  }: {
+    currency: CryptoCurrency;
+    options?: {
+      useEIP1559: boolean;
+    };
+  }) => Promise<GasOptions>;
+};
+
+export const getGasTracker = (currency: CryptoCurrency): GasTrackerApi | null => {
+  switch (currency.ethereumLikeInfo?.gasTracker?.type) {
+    case "ledger":
+      return {
+        getGasOptions: ledgerGetGasOptions,
+      };
+
+    /**
+     * We return null instead of throwing an error because not having a gas tracker
+     * is not necessarily an error.
+     */
+    default:
+      return null;
+  }
+};

package/src/api/gasTracker/ledger.ts

@@ -0,0 +1,103 @@
+import { getEnv } from "@ledgerhq/live-env";
+import network from "@ledgerhq/live-network/network";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { BigNumber } from "bignumber.js";
+import { GasOptions } from "../../types";
+import { GasTrackerDoesNotSupportEIP1559, NoGasTrackerFound } from "../../errors";
+
+type GasTracker = {
+  explorerId: string;
+  compatibilty: {
+    eip1559: boolean;
+  };
+};
+
+// FIXME: how to know if a Ledger gasTracker supports EIP1559?
+// Shouldn't this be a dynamic / remote config? For example if there is an
+// update of the explorer backend to support EIP1559, we should be able to
+// update this config without having to release a new version of the app?
+const currencyIdGasTrackerMap = new Map<CryptoCurrency["id"], GasTracker>([
+  ["avalanche_c_chain", { explorerId: "avax", compatibilty: { eip1559: false } }],
+  ["bsc", { explorerId: "bnb", compatibilty: { eip1559: false } }],
+  ["ethereum", { explorerId: "eth", compatibilty: { eip1559: true } }],
+  ["ethereum_classic", { explorerId: "etc", compatibilty: { eip1559: false } }],
+  ["polygon", { explorerId: "matic", compatibilty: { eip1559: true } }],
+  ["ethereum_ropsten", { explorerId: "eth_ropsten", compatibilty: { eip1559: true } }],
+  ["ethereum_goerli", { explorerId: "eth_goerli", compatibilty: { eip1559: true } }],
+]);
+
+export const getGasOptions = async ({
+  currency,
+  options,
+}: {
+  currency: CryptoCurrency;
+  options?: {
+    useEIP1559: boolean;
+  };
+}): Promise<GasOptions> => {
+  const gasTrackerConfig = currencyIdGasTrackerMap.get(currency.id);
+
+  if (!gasTrackerConfig) {
+    throw new NoGasTrackerFound(`No gas tracker found for ${currency.id}`);
+  }
+
+  const { useEIP1559 = false } = options || {};
+
+  if (useEIP1559 && !gasTrackerConfig.compatibilty.eip1559) {
+    throw new GasTrackerDoesNotSupportEIP1559(
+      `Gas tracker does not support EIP1559 for ${currency.id}`,
+    );
+  }
+
+  const { low, medium, high, next_base } = await network({
+    method: "GET",
+    url: `${getEnv("EXPLORER")}/blockchain/v4/${gasTrackerConfig.explorerId}/gastracker/barometer${
+      useEIP1559 ? "?display=eip1559" : ""
+    }`,
+  }).then(({ data }) => ({
+    low: new BigNumber(data.low),
+    medium: new BigNumber(data.medium),
+    high: new BigNumber(data.high),
+    next_base: new BigNumber(data.next_base),
+  }));
+
+  const EIP1559_BASE_FEE_MULTIPLIER: number = getEnv("EIP1559_BASE_FEE_MULTIPLIER");
+
+  if (useEIP1559) {
+    return {
+      slow: {
+        maxFeePerGas: next_base.times(EIP1559_BASE_FEE_MULTIPLIER).plus(low),
+        maxPriorityFeePerGas: low,
+        gasPrice: null,
+      },
+      medium: {
+        maxFeePerGas: next_base.times(EIP1559_BASE_FEE_MULTIPLIER).plus(medium),
+        maxPriorityFeePerGas: medium,
+        gasPrice: null,
+      },
+      fast: {
+        maxFeePerGas: next_base.times(EIP1559_BASE_FEE_MULTIPLIER).plus(high),
+        maxPriorityFeePerGas: high,
+        gasPrice: null,
+      },
+    };
+  }
+
+  return {
+    slow: {
+      gasPrice: low,
+      maxFeePerGas: null,
+      maxPriorityFeePerGas: null,
+    },
+    medium: {
+      gasPrice: medium,
+      maxFeePerGas: null,
+      maxPriorityFeePerGas: null,
+    },
+    fast: {
+      gasPrice: high,
+      maxFeePerGas: null,
+      maxPriorityFeePerGas: null,
+    },
+  };
+};

package/src/api/{rpc.common.ts → rpc/rpc.common.ts}

@@ -6,12 +6,12 @@ import { delay } from "@ledgerhq/live-promise";
 import { Account } from "@ledgerhq/types-live";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { makeLRUCache } from "@ledgerhq/live-network/cache";
-import OptimismGasPriceOracleAbi from "../abis/optimismGasPriceOracle.abi.json";
-import { FeeData, FeeHistory, Transaction as EvmTransaction } from "../types";
-import { GasEstimationError, InsufficientFunds } from "../errors";
-import { transactionToEthersTransaction } from "../adapters";
-import { getSerializedTransaction } from "../transaction";
-import ERC20Abi from "../abis/erc20.abi.json";
+import OptimismGasPriceOracleAbi from "../../abis/optimismGasPriceOracle.abi.json";
+import { FeeData, FeeHistory, Transaction as EvmTransaction } from "../../types";
+import { GasEstimationError, InsufficientFunds } from "../../errors";
+import { transactionToEthersTransaction } from "../../adapters";
+import { getSerializedTransaction } from "../../transaction";
+import ERC20Abi from "../../abis/erc20.abi.json";
 
 export const RPC_TIMEOUT = 5000; // wait 5 sec after a fail
 export const DEFAULT_RETRIES_RPC_METHODS = 3;
@@ -22,8 +22,7 @@ export const DEFAULT_RETRIES_RPC_METHODS = 3;
  * at instanciation which could result in rate limits being reached
  * on some specific nodes (E.g. the main Optimism RPC)
  */
-const PROVIDERS_BY_RPC: Record<string, ethers.providers.StaticJsonRpcProvider> =
-  {};
+const PROVIDERS_BY_RPC: Record<string, ethers.providers.StaticJsonRpcProvider> = {};
 
 /**
  * Connects to RPC Node
@@ -36,7 +35,7 @@ const PROVIDERS_BY_RPC: Record<string, ethers.providers.StaticJsonRpcProvider> =
 export async function withApi<T>(
   currency: CryptoCurrency,
   execute: (api: ethers.providers.StaticJsonRpcProvider) => Promise<T>,
-  retries = DEFAULT_RETRIES_RPC_METHODS
+  retries = DEFAULT_RETRIES_RPC_METHODS,
 ): Promise<T> {
   if (!currency?.ethereumLikeInfo?.rpc) {
     throw new Error("Currency doesn't have an RPC node provided");
@@ -44,10 +43,9 @@ export async function withApi<T>(
 
   try {
     if (!PROVIDERS_BY_RPC[currency.ethereumLikeInfo.rpc]) {
-      PROVIDERS_BY_RPC[currency.ethereumLikeInfo.rpc] =
-        new ethers.providers.StaticJsonRpcProvider(
-          currency.ethereumLikeInfo.rpc
-        );
+      PROVIDERS_BY_RPC[currency.ethereumLikeInfo.rpc] = new ethers.providers.StaticJsonRpcProvider(
+        currency.ethereumLikeInfo.rpc,
+      );
     }
 
     const provider = PROVIDERS_BY_RPC[currency.ethereumLikeInfo.rpc];
@@ -68,12 +66,9 @@ export async function withApi<T>(
  */
 export const getBalanceAndBlock: (
   currency: CryptoCurrency,
-  addr: string
-) => Promise<{ blockHeight: number; balance: BigNumber }> = async (
-  currency,
-  addr
-) =>
-  withApi(currency, async (api) => {
+  addr: string,
+) => Promise<{ blockHeight: number; balance: BigNumber }> = async (currency, addr) =>
+  withApi(currency, async api => {
     const [balance, blockHeight] = await Promise.all([
       getCoinBalance(currency, addr),
       api.getBlockNumber(),
@@ -90,20 +85,17 @@ export const getBalanceAndBlock: (
  */
 export const getTransaction = (
   currency: CryptoCurrency,
-  hash: string
+  hash: string,
 ): Promise<ethers.providers.TransactionResponse> =>
-  withApi(currency, (api) => {
+  withApi(currency, api => {
     return api.getTransaction(hash);
   });
 
 /**
  * Get the balance of an address
  */
-export const getCoinBalance = (
-  currency: CryptoCurrency,
-  address: string
-): Promise<BigNumber> =>
-  withApi(currency, async (api) => {
+export const getCoinBalance = (currency: CryptoCurrency, address: string): Promise<BigNumber> =>
+  withApi(currency, async api => {
     const balance = await api.getBalance(address);
     return new BigNumber(balance.toString());
   });
@@ -114,9 +106,9 @@ export const getCoinBalance = (
 export const getTokenBalance = (
   currency: CryptoCurrency,
   address: string,
-  contractAddress: string
+  contractAddress: string,
 ): Promise<BigNumber> =>
-  withApi(currency, async (api) => {
+  withApi(currency, async api => {
     const erc20 = new ethers.Contract(contractAddress, ERC20Abi, api);
     const balance = await erc20.balanceOf(address);
     return new BigNumber(balance.toString());
@@ -125,11 +117,8 @@ export const getTokenBalance = (
 /**
  * Get account nonce
  */
-export const getTransactionCount = (
-  currency: CryptoCurrency,
-  addr: string
-): Promise<number> =>
-  withApi(currency, async (api) => {
+export const getTransactionCount = (currency: CryptoCurrency, addr: string): Promise<number> =>
+  withApi(currency, async api => {
     return api.getTransactionCount(addr);
   });
 
@@ -138,9 +127,9 @@ export const getTransactionCount = (
  */
 export const getGasEstimation = (
   account: Account,
-  transaction: EvmTransaction
+  transaction: EvmTransaction,
 ): Promise<BigNumber> =>
-  withApi(account.currency, async (api) => {
+  withApi(account.currency, async api => {
     const { to, value, data } = transactionToEthersTransaction(transaction);
 
     try {
@@ -162,7 +151,7 @@ export const getGasEstimation = (
  * Get an estimation of fees on the network
  */
 export const getFeesEstimation = (currency: CryptoCurrency): Promise<FeeData> =>
-  withApi(currency, async (api) => {
+  withApi(currency, async api => {
     const block = await api.getBlock("latest");
     const currencySupports1559 = Boolean(block.baseFeePerGas);
 
@@ -175,10 +164,7 @@ export const getFeesEstimation = (currency: CryptoCurrency): Promise<FeeData> =>
         ]);
         // Taking the average priority fee used on the last 5 blocks
         const maxPriorityFeeAverage = feeHistory.reward
-          .reduce(
-            (acc, [curr]) => acc.plus(new BigNumber(curr)),
-            new BigNumber(0)
-          )
+          .reduce((acc, [curr]) => acc.plus(new BigNumber(curr)), new BigNumber(0))
           .dividedToIntegerBy(feeHistory.reward.length);
 
         // A maxPriorityFeePerGas too low might make a transaction stuck forever
@@ -189,7 +175,7 @@ export const getFeesEstimation = (currency: CryptoCurrency): Promise<FeeData> =>
           : maxPriorityFeeAverage;
 
         const nextBaseFee = new BigNumber(
-          feeHistory.baseFeePerGas[feeHistory.baseFeePerGas.length - 1]
+          feeHistory.baseFeePerGas[feeHistory.baseFeePerGas.length - 1],
         );
 
         return {
@@ -206,15 +192,11 @@ export const getFeesEstimation = (currency: CryptoCurrency): Promise<FeeData> =>
     })();
 
     return {
-      maxFeePerGas: feeData.maxFeePerGas
-        ? new BigNumber(feeData.maxFeePerGas.toString())
-        : null,
+      maxFeePerGas: feeData.maxFeePerGas ? new BigNumber(feeData.maxFeePerGas.toString()) : null,
       maxPriorityFeePerGas: feeData.maxPriorityFeePerGas
         ? new BigNumber(feeData.maxPriorityFeePerGas.toString())
         : null,
-      gasPrice: feeData.gasPrice
-        ? new BigNumber(feeData.gasPrice.toString())
-        : null,
+      gasPrice: feeData.gasPrice ? new BigNumber(feeData.gasPrice.toString()) : null,
     };
   });
 
@@ -223,11 +205,11 @@ export const getFeesEstimation = (currency: CryptoCurrency): Promise<FeeData> =>
  */
 export const broadcastTransaction = (
   currency: CryptoCurrency,
-  signedTxHex: string
+  signedTxHex: string,
 ): Promise<ethers.providers.TransactionResponse> =>
   withApi(
     currency,
-    async (api) => {
+    async api => {
       try {
         return await api.sendTransaction(signedTxHex);
       } catch (e) {
@@ -238,7 +220,7 @@ export const broadcastTransaction = (
         throw e;
       }
     },
-    0
+    0,
   );
 
 /**
@@ -246,9 +228,9 @@ export const broadcastTransaction = (
  */
 export const getBlock = (
   currency: CryptoCurrency,
-  blockHeight: number
+  blockHeight: number,
 ): Promise<ethers.providers.Block> =>
-  withApi(currency, async (api) => {
+  withApi(currency, async api => {
     return api.getBlock(blockHeight);
   });
 
@@ -257,13 +239,13 @@ export const getBlock = (
  */
 export const getSubAccount: (
   currency: CryptoCurrency,
-  addr: string
+  addr: string,
 ) => Promise<{
   blockHeight: number;
   balance: BigNumber;
   nonce: number;
 }> = async (currency, addr) =>
-  withApi(currency, async (api) => {
+  withApi(currency, async api => {
     const [balance, nonce, blockHeight] = await Promise.all([
       getCoinBalance(currency, addr),
       getTransactionCount(currency, addr),
@@ -286,12 +268,9 @@ export const getSubAccount: (
  *
  * @see https://help.optimism.io/hc/en-us/articles/4411895794715-How-do-transaction-fees-on-Optimism-work-
  */
-export const getOptimismAdditionalFees = makeLRUCache<
-  [CryptoCurrency, EvmTransaction],
-  BigNumber
->(
+export const getOptimismAdditionalFees = makeLRUCache<[CryptoCurrency, EvmTransaction], BigNumber>(
   async (currency, transaction) =>
-    withApi(currency, async (api) => {
+    withApi(currency, async api => {
       if (!["optimism", "optimism_goerli"].includes(currency.id)) {
         return new BigNumber(0);
       }
@@ -317,11 +296,9 @@ export const getOptimismAdditionalFees = makeLRUCache<
         // @see https://community.optimism.io/docs/developers/build/transaction-fees/#displaying-fees-to-users
         "0x420000000000000000000000000000000000000F",
         OptimismGasPriceOracleAbi,
-        api
-      );
-      const additionalL1Fees = await optimismGasOracle.getL1Fee(
-        serializedTransaction
+        api,
       );
+      const additionalL1Fees = await optimismGasOracle.getL1Fee(serializedTransaction);
       return new BigNumber(additionalL1Fees.toString());
     }),
   (currency, transaction) => {
@@ -335,7 +312,7 @@ export const getOptimismAdditionalFees = makeLRUCache<
 
     return "getOptimismL1BaseFee_" + currency.id + "_" + serializedTransaction;
   },
-  { ttl: 15 * 1000 } // preventing rate limit by caching this for at least 15sec
+  { ttl: 15 * 1000 }, // preventing rate limit by caching this for at least 15sec
 );
 
 export default {