@ledgerhq/live-common 21.5.1 → 21.7.1-patch.1

package/src/exchange/swap/utils/index.test.ts

@@ -0,0 +1,224 @@
+import BigNumber from "bignumber.js";
+
+import { pickExchangeRate, getAccountTuplesForCurrency } from "./index";
+import { getMockExchangeRate } from "../mock";
+import { genAccount } from "../../../mock/account";
+import type {
+  Account,
+  CryptoCurrency,
+  SubAccount,
+  TokenCurrency,
+} from "../../../types";
+import { getCryptoCurrencyById } from "../../../currencies";
+import { getTokenById } from "@ledgerhq/cryptoassets/lib/tokens";
+
+describe("swap/utils/pickExchangeRate", () => {
+  test("calls the callback function with null when no exchange rates are passed", () => {
+    const setExchangeRate = jest.fn();
+    pickExchangeRate([], undefined, setExchangeRate);
+
+    expect(setExchangeRate).toHaveBeenCalledTimes(1);
+    expect(setExchangeRate).toHaveBeenCalledWith(null);
+  });
+
+  test("calls the callback function with null when no exchange rates are passed but there is an exchange rate", () => {
+    const setExchangeRate = jest.fn();
+    const exchangeRate = getMockExchangeRate({ provider: "wyre" });
+    pickExchangeRate([], exchangeRate, setExchangeRate);
+
+    expect(setExchangeRate).toHaveBeenCalledTimes(1);
+    expect(setExchangeRate).toHaveBeenCalledWith(null);
+  });
+
+  test("calls the callback function with the first exchange rate when the exchange passed isn't included in the list", () => {
+    const setExchangeRate = jest.fn();
+    const firstExchangeRate = getMockExchangeRate({
+      provider: "changelly",
+      tradeMethod: "fixed",
+    });
+    const exchangeRates = [
+      firstExchangeRate,
+      getMockExchangeRate({ provider: "changelly", tradeMethod: "float" }),
+    ];
+    const exchangeRate = getMockExchangeRate({ provider: "wyre" });
+
+    pickExchangeRate(exchangeRates, exchangeRate, setExchangeRate);
+
+    expect(setExchangeRate).toHaveBeenCalledTimes(1);
+    expect(setExchangeRate).toHaveBeenCalledWith(firstExchangeRate);
+  });
+
+  test("calls the callback function with the passed exchange rate when the exchange passed is included in the list", () => {
+    const setExchangeRate = jest.fn();
+    const exchangeRate = getMockExchangeRate({
+      provider: "changelly",
+      tradeMethod: "fixed",
+    });
+    const exchangeRates = [
+      getMockExchangeRate({ provider: "changelly", tradeMethod: "float" }),
+      exchangeRate,
+    ];
+
+    pickExchangeRate(exchangeRates, exchangeRate, setExchangeRate);
+
+    expect(setExchangeRate).toHaveBeenCalledTimes(1);
+    expect(setExchangeRate).toHaveBeenCalledWith(exchangeRate);
+  });
+});
+
+/* TODO: Refacto these two function and move them to mock/account.ts if needed */
+function* accountGenerator(currency: CryptoCurrency): Generator<Account> {
+  let id = 0;
+  while (true) {
+    id += 1;
+    yield genAccount(`mocked-account-${id}`, { currency, operationsSize: 0 });
+  }
+}
+const getAccountCreator = (currencyId: string) => {
+  const generator = accountGenerator(getCryptoCurrencyById(currencyId));
+  return () => generator.next().value;
+};
+
+describe("swap/utils/getAccountTuplesForCurrency", () => {
+  const getEthAccount = getAccountCreator("ethereum");
+  const getBtcAccount = getAccountCreator("bitcoin");
+  const getPolkadotAccount = getAccountCreator("polkadot");
+  const getCosmosAccount = getAccountCreator("cosmos");
+
+  describe("CryptoCurrency", () => {
+    test("returns all accounts associated to the CryptoCurrency", () => {
+      const ethCurrency = getCryptoCurrencyById("ethereum");
+      const ethAccounts = [getEthAccount(), getEthAccount()];
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...ethAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        ethCurrency,
+        allAccounts,
+        false
+      );
+
+      expect(results).toHaveLength(2);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(ethAccounts[index]);
+        expect(result.subAccount).toBeNull();
+      });
+    });
+
+    test("returns only associated accounts if they have a balance greater than 0 when the flag is passed", () => {
+      const ethCurrency = getCryptoCurrencyById("ethereum");
+      const richEthAccounts = [
+        { ...getEthAccount(), balance: new BigNumber(10) },
+        { ...getEthAccount(), balance: new BigNumber(10) },
+      ];
+      const poorEthAccounts = { ...getEthAccount(), balance: new BigNumber(0) };
+
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...richEthAccounts,
+        poorEthAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        ethCurrency,
+        allAccounts,
+        true
+      );
+
+      expect(results).toHaveLength(richEthAccounts.length);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(richEthAccounts[index]);
+        expect(result.subAccount).toBeNull();
+      });
+    });
+
+    test("returns an empty array if the CryptoCurrency passed has no associated account", () => {
+      const ethCurrency = getCryptoCurrencyById("ethereum");
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        ethCurrency,
+        allAccounts,
+        false
+      );
+
+      expect(results).toHaveLength(0);
+    });
+  });
+
+  describe("TokenCurrency", () => {
+    const aaveToken = Object.freeze(getTokenById("ethereum/erc20/aave"));
+
+    test("returns correct parent accounts including a new subAccount when a TokenCurrency is provided", () => {
+      const ethAccounts = [
+        { ...getEthAccount(), subAccounts: [] },
+        { ...getEthAccount(), subAccounts: [] },
+      ];
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...ethAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        aaveToken,
+        allAccounts,
+        false
+      );
+
+      expect(results).toHaveLength(ethAccounts.length);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(ethAccounts[index]);
+        expect(
+          (result.subAccount as SubAccount & { token: TokenCurrency }).token
+        ).toEqual(aaveToken);
+      });
+    });
+
+    test("returns correct parent accounts including already existing subAccounts when a TokenCurrency is provided", () => {
+      const ethAccounts = [{ ...getEthAccount(), subAccounts: [aaveToken] }];
+      const allAccounts: Account[] = [
+        getCosmosAccount(),
+        ...ethAccounts,
+        getBtcAccount(),
+        getPolkadotAccount(),
+      ];
+
+      const results = getAccountTuplesForCurrency(
+        aaveToken,
+        allAccounts,
+        false
+      );
+
+      expect(results).toHaveLength(ethAccounts.length);
+      results.forEach((result, index) => {
+        expect(result.account).toEqual(ethAccounts[index]);
+        expect(
+          (result.subAccount as SubAccount & { token: TokenCurrency }).token
+        ).toEqual(aaveToken);
+      });
+    });
+
+    test("returns an empty array when a TokenCurrency is provided but the accounts list is empty", () => {
+      const allAccounts: Account[] = [];
+
+      const results = getAccountTuplesForCurrency(
+        aaveToken,
+        allAccounts,
+        false
+      );
+      expect(results).toHaveLength(0);
+    });
+  });
+});

package/src/exchange/swap/utils/index.ts

@@ -0,0 +1,67 @@
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/cryptoassets";
+import { makeEmptyTokenAccount } from "../../../account";
+import { Account, SubAccount } from "../../../types";
+import type { ExchangeRate } from "../types";
+
+export const KYC_STATUS = {
+  pending: "pending",
+  rejected: "closed",
+  approved: "approved",
+};
+
+export type KYCStatus = keyof typeof KYC_STATUS;
+
+export const pickExchangeRate = (
+  exchangeRates: ExchangeRate[],
+  exchangeRate: ExchangeRate | null | undefined,
+  setExchangeRate: (rate?: ExchangeRate | null) => void
+): void => {
+  const hasRates = exchangeRates?.length > 0;
+  // If the user picked an exchange rate before, try to select the new one that matches.
+  // Otherwise pick the first one.
+  const rate =
+    hasRates &&
+    ((exchangeRate &&
+      exchangeRates.find(
+        ({ tradeMethod, provider }) =>
+          tradeMethod === exchangeRate.tradeMethod &&
+          provider === exchangeRate.provider
+      )) ||
+      exchangeRates[0]);
+  setExchangeRate(rate || null);
+};
+
+export type AccountTuple = {
+  account: Account | null | undefined;
+  subAccount: SubAccount | null | undefined;
+};
+
+export function getAccountTuplesForCurrency(
+  currency: CryptoCurrency | TokenCurrency,
+  allAccounts: Account[],
+  hideEmpty?: boolean
+): AccountTuple[] {
+  if (currency.type === "TokenCurrency") {
+    return allAccounts
+      .filter((account) => account.currency.id === currency.parentCurrency.id)
+      .map((account) => ({
+        account,
+        subAccount:
+          (account.subAccounts &&
+            account.subAccounts.find(
+              (subAcc: SubAccount) =>
+                subAcc.type === "TokenAccount" &&
+                subAcc.token.id === currency.id
+            )) ||
+          makeEmptyTokenAccount(account, currency),
+      }))
+      .filter((a) => (hideEmpty ? a.subAccount?.balance.gt(0) : true));
+  }
+  return allAccounts
+    .filter((account) => account.currency.id === currency.id)
+    .map((account) => ({
+      account,
+      subAccount: null,
+    }))
+    .filter((a) => (hideEmpty ? a.account?.balance.gt(0) : true));
+}

package/src/families/crypto_org/datasets/croeseid.ts

@@ -1,24 +1,22 @@
+// @flow
 import type { CurrenciesData } from "../../../types";
 import type { Transaction } from "../types";
 
 const dataset: CurrenciesData<Transaction> = {
   scanAccounts: [
     {
-      // FIXME use better dataset
-      // use a seed that we "froze" (aka we'll never use it again, but it contains many txs scenario)
-      // then run:
-      // ledger-live generateTestScanAccounts -c  crypto_org_croeseid
-      name: "crypto_org_croeseid seed gre (temporary)",
+      name: "crypto_org_croeseid seed 1",
       apdus: `
       => 5504000019047463726f2c0000808a010080000000800000000000000000
-      <= 02ac96e7f6648484ef48f5cfcd540249c89e4dbfff0553dcf664612c79cfd194297463726f31363734706e6d6b6a6b6c663335703679336e7364357765703378367764656e363438326e79329000
+      <= 02bf9e382bf60d6ffaa982534b3e88014ee472bf091b7ff17167fe8978074349417463726f316b357538747a68386e73666d367571776c633438787a3467356a336d6d387878397a793579399000
       => 5504000019047463726f2c0000808a010080000000800000000000000000
-      <= 02ac96e7f6648484ef48f5cfcd540249c89e4dbfff0553dcf664612c79cfd194297463726f31363734706e6d6b6a6b6c663335703679336e7364357765703378367764656e363438326e79329000
+      <= 02bf9e382bf60d6ffaa982534b3e88014ee472bf091b7ff17167fe8978074349417463726f316b357538747a68386e73666d367571776c633438787a3467356a336d6d387878397a793579399000
       => 5504000019047463726f2c0000808a010080010000800000000000000000
-      <= 02c5546649f7c6f921eb36bd5fef4350cf3a8ff6d33308a4cdf59183cf079c08847463726f31757635307463396d30767534773067333376377937656a687434723636676a66656b347574769000
+      <= 03972a47c0cfce99f4428d078f6fa359a9e972a587d0952274f4d28023cbba3bae7463726f316568713371787873796a77766175367639716e327477763036757437386734763467336a6d709000
+      => 5504000019047463726f2c0000808a010080020000800000000000000000
+      <= 03635321f8045b86d903daedd02a07bc5cb188f1d498563d5f2cdb9392a0cb59c37463726f316b716677736875736734763767666163356a36716d6370346767786337346677676b343868399000
       `,
     },
   ],
 };
-
 export default dataset;

package/src/families/elrond/api/apiCalls.ts

@@ -121,44 +121,16 @@ export default class ElrondApi {
       from = from + TRANSACTIONS_SIZE;
     }
 
-    if (!allTransactions.length) {
-      return allTransactions; //Account does not have any transactions
-    }
-
-    return Promise.all(
-      allTransactions.map(async (transaction) => {
-        const { blockHeight, blockHash } = await this.getConfirmedTransaction(
-          transaction.txHash
-        );
-        return { ...transaction, blockHash, blockHeight };
-      })
-    );
+    return allTransactions;
   }
 
   async getBlockchainBlockHeight() {
     const {
-      data: [{ nonce: blockHeight }],
+      data: [{ round: blockHeight }],
     } = await network({
       method: "GET",
-      url: `${this.API_URL}/blocks?shard=${METACHAIN_SHARD}&fields=nonce`,
+      url: `${this.API_URL}/blocks?shard=${METACHAIN_SHARD}&fields=round`,
     });
     return blockHeight;
   }
-
-  async getConfirmedTransaction(txHash: string) {
-    const {
-      data: {
-        data: {
-          transaction: { hyperblockNonce, blockHash },
-        },
-      },
-    } = await network({
-      method: "GET",
-      url: `${this.API_URL}/transaction/${txHash}`,
-    });
-    return {
-      blockHeight: hyperblockNonce,
-      blockHash,
-    };
-  }
 }

package/src/families/elrond/api/sdk.ts

@@ -71,8 +71,8 @@ function transactionToOperation(
     value: getOperationValue(transaction, addr),
     type,
     hash: transaction.txHash ?? "",
-    blockHash: transaction.blockHash,
-    blockHeight: transaction.blockHeight,
+    blockHash: transaction.miniBlockHash,
+    blockHeight: transaction.round,
     date: new Date(transaction.timestamp ? transaction.timestamp * 1000 : 0),
     extra: {},
     senders: [transaction.sender ?? ""],

package/src/families/elrond/types.ts

@@ -36,6 +36,8 @@ export type Transaction = TransactionCommon & {
   nonce?: number;
   status?: string;
   fee?: BigNumber;
+  round?: number;
+  miniBlockHash?: string;
 };
 
 /**

package/src/families/tezos/bridge/js.ts

@@ -104,6 +104,8 @@ const getTransactionStatus = async (
     if (t.mode === "send") {
       if (!errors.amount && t.amount.eq(0)) {
         errors.amount = new AmountRequired();
+      } else if (!errors.amount && t.amount.lt(0)) {
+        errors.amount = new NotEnoughBalance();
       } else if (t.amount.gt(0) && estimatedFees.times(10).gt(t.amount)) {
         warnings.feeTooHigh = new FeeTooHigh();
       }
@@ -199,6 +201,17 @@ const prepareTransaction = async (
     transaction.storageLimit = new BigNumber(out.storageLimit);
 
     if (transaction.useAllAmount) {
+      // Temporary fix, see https://gitlab.com/tezos/tezos/-/issues/1754
+      // we need to increase the gasLimit and fee returned by the estimation
+      const gasBuffer = 500;
+      const MINIMAL_FEE_PER_GAS_MUTEZ = 0.1;
+      const increasedFee = (gasBuffer: number, opSize: number) => {
+        return gasBuffer * MINIMAL_FEE_PER_GAS_MUTEZ + opSize;
+      };
+      transaction.fees = transaction.fees.plus(
+        increasedFee(gasBuffer, Number(out.opSize))
+      );
+      transaction.gasLimit = transaction.gasLimit.plus(gasBuffer);
       const s = await getTransactionStatus(account, transaction);
       transaction.amount = account.balance.minus(s.estimatedFees);
     }

package/src/mock/account.ts

@@ -293,7 +293,7 @@ type GenAccountOptions = {
   swapHistorySize?: number;
 };
 
-function genTokenAccount(
+export function genTokenAccount(
   index: number,
   account: Account,
   token: TokenCurrency
@@ -340,7 +340,7 @@ export function genAccount(
 ): Account {
   const rng = new Prando(id);
   const currency = opts.currency || rng.nextArrayItem(currencies);
-  const operationsSize = opts.operationsSize || rng.nextInt(1, 200);
+  const operationsSize = opts.operationsSize ?? rng.nextInt(1, 200);
   const swapHistorySize = opts.swapHistorySize || 0;
   const address = genAddress(currency, rng);
   const derivationPath = runDerivationScheme(