const asResultAccount = (unsafe: mixed): AccountData => {     index,     balance,     // $FlowFixMe No idea how to make flow like this-    swapHistory: invalidSwapHistory ? [] : swapHistory,+    swapHistory: swapHistory || invalidSwapHistory ? [] : swapHistory,

 export const accountDataToAccount = ({     index,     freshAddress,     freshAddressPath,-    swapHistory: swapHistory.map(fromSwapOperationRaw),+    swapHistory: (swapHistory || []).map(fromSwapOperationRaw),

 const asResultAccount = (unsafe: mixed): AccountData => {     index,     balance,     // $FlowFixMe No idea how to make flow like this-    swapHistory: invalidSwapHistory ? [] : swapHistory,+    swapHistory: swapHistory || invalidSwapHistory ? [] : swapHistory,

 const asResultAccount = (unsafe: mixed): AccountData => {     index,     balance,     // $FlowFixMe No idea how to make flow like this-    swapHistory: invalidSwapHistory ? [] : swapHistory,+    swapHistory: swapHistory || invalidSwapHistory ? [] : swapHistory,

 const asResultAccount = (unsafe: mixed): AccountData => {     index,     balance,     // $FlowFixMe No idea how to make flow like this

+// @flow++import type {+  CryptoCurrency,+  TokenAccount,+  Account,+  SyncConfig,+} from "../../types";+import type { CoreAccount } from "../../libcore/types";+import { minimalOperationsBuilder } from "../../reconciliation";+import { buildASAOperation } from "./buildASAOperation";+import { BigNumber } from "bignumber.js";+import { findTokenById, listTokensForCryptoCurrency } from "../../currencies";+import { promiseAllBatched } from "../../promise";++const OperationOrderKey = {+  date: 0,+};++async function buildAlgorandTokenAccount({+  parentAccountId,+  token,+  coreAccount,+  existingTokenAccount,+  balance,+}) {+  const id = parentAccountId + "+" + token.id;+  const getAllOperations = async () => {+    const query = await coreAccount.queryOperations();+    await query.complete();+    await query.addOrder(OperationOrderKey.date, false);+    const coreOperations = await query.execute();++    const operations = await minimalOperationsBuilder(+      (existingTokenAccount && existingTokenAccount.operations) || [],+      coreOperations,+      (coreOperation) =>+        buildASAOperation({+          coreOperation,+          accountId: id,+        })+    );++    return operations;+  };++  const operations = await getAllOperations();++  const tokenAccount: $Exact<TokenAccount> = {+    type: "TokenAccount",+    id,+    parentId: parentAccountId,+    starred: false,+    token,+    operationsCount: operations.length,+    operations,+    pendingOperations: [],+    balance,+    swapHistory: [],+    creationDate:+      operations.length > 0+        ? operations[operations.length - 1].date+        : new Date(),+  };++  return tokenAccount;+}++async function algorandBuildTokenAccounts({+  currency,+  coreAccount,+  accountId,+  existingAccount,+  syncConfig,+}: {+  currency: CryptoCurrency,+  coreAccount: CoreAccount,+  accountId: string,+  existingAccount: ?Account,+  syncConfig: SyncConfig,+}): Promise<?(TokenAccount[])> {+  const { blacklistedTokenIds = [] } = syncConfig;+  if (listTokensForCryptoCurrency(currency).length === 0) return undefined;+  const tokenAccounts = [];+  const algorandAccount = await coreAccount.asAlgorandAccount();+  const accountASA = await algorandAccount.getAssetsBalances();++  const existingAccountByTicker = {}; // used for fast lookup+  const existingAccountTickers = []; // used to keep track of ordering+  if (existingAccount && existingAccount.subAccounts) {+    for (const existingSubAccount of existingAccount.subAccounts) {+      if (existingSubAccount.type === "TokenAccount") {+        const { ticker, id } = existingSubAccount.token;+        if (!blacklistedTokenIds.includes(id)) {+          existingAccountTickers.push(ticker);+          existingAccountByTicker[ticker] = existingSubAccount;+        }+      }+    }+  }++  // filter by token existence+  promiseAllBatched(3, accountASA, async (asa) => {

+/********************************************************************************

 const Exchange = () => {       </Box>       <TabBar tabs={tabs.map(tab => t(tab.title))} onIndexChange={setActiveTabIndex} />       <Card grow style={{ overflow: "hidden" }}>-        {tabs[activeTabIndex].component}+        <Component defaultCurrency={maybeDefaultCurrency} />

 const stringParser = (v: mixed): ?string =>  const envDefinitions = {   API_ALGORAND_BLOCKCHAIN_EXPLORER_API_ENDPOINT: {-    def: "https://algorand.coin.staging.aws.ledger.com",+    def: "https://algorand.coin.ledger.com/",

+// @flow++import { useState, useCallback, useMemo } from "react";+import type { Account, SubAccount } from "@ledgerhq/live-common/lib/types/account";+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/live-common/lib/types/currencies";+import { BigNumber } from "bignumber.js";++type CryptoOrTokenCurrency = TokenCurrency | CryptoCurrency;++const generateTokenAccount = (account: Account, currency: TokenCurrency): SubAccount => ({+  type: "TokenAccount",+  id: account.id + "+" + currency.contractAddress,+  parentId: account.id,+  token: currency,+  balance: BigNumber(0),+  operationsCount: 0,+  creationDate: new Date(),+  operations: [],+  pendingOperations: [],+  starred: false,+});++export type AccountTuple = {+  account: ?Account,+  subAccount: ?SubAccount,+};++function getAccountTuplesForCurrency(+  currency: CryptoOrTokenCurrency,+  allAccounts: Account[],+): 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,+            )) ||+          generateTokenAccount(account, currency),+      }));+  }+  return allAccounts+    .filter(account => account.currency.id === currency.id)+    .map(account => ({+      account,+      subAccount: null,+    }));+}++export function useCurrencyAccountSelect(+  allCurrencies: CryptoOrTokenCurrency[],+  allAccounts: Account[],+) {+  const [state, setState] = useState(() => {+    const defaultCurrency = allCurrencies[0];+    const availableAccounts = getAccountTuplesForCurrency(defaultCurrency, allAccounts);+    const { account, subAccount } = availableAccounts.length+      ? availableAccounts[0]+      : { account: null, subAccount: null };++    return {+      currency: defaultCurrency,+      account,+      subAccount,+    };+  });++  const { currency, account, subAccount } = state;

 const FeatureRow = ({ feature }: Props) => {   return (     <SettingsRow       event={`${feature.name}Row`}-      title={feature.title}+      title={type === "integer" ? `${feature.title}` : feature.title}

+// @flow++import React, { useCallback, useState, useEffect } from "react";+import { Switch, TextInput, StyleSheet } from "react-native";+import { getEnvDefault } from "@ledgerhq/live-common/lib/env";++import { View } from "react-native-animatable";+import Track from "../../../analytics/Track";+import colors from "../../../colors";++type Props = {+  name: *,+  isDefault: boolean,+  readOnly: boolean,+  onChange: (name: string, val: mixed) => boolean,+  value: number,+  minValue: number,+  maxValue: number,+};++const FeatureInteger = ({+  name,+  isDefault,+  readOnly,+  onChange,+  value,+  minValue,+  maxValue,+}: Props) => {+  const constraintValue = useCallback(+    v => {+      let value = v;+      if (typeof maxValue === "number" && parseInt(value, 10) > maxValue) {+        value = maxValue;+      }+      if (typeof minValue === "number" && parseInt(value, 10) < minValue) {+        value = minValue;+      }++      if (!value) {+        value = maxValue || minValue;

 export const NavigatorName = {   Onboarding: "Onboarding",   PasswordAddFlow: "PasswordAddFlow",   PasswordModifyFlow: "PasswordModifyFlow",+  ManagerProdiver: "ManagerProdiver",

+// @flow++import type { TokenCurrency } from "../../types";+import { getCryptoCurrencyById } from "../../data/cryptocurrencies";+import { addTokens } from "../../data/tokens";++type TokenType = "asa";+

 export default (arg: {               if (process.env.VERBOSE) {                 log("libcore-call", id + "." + method, args);               }-              const constructorArgs =-                typeof njsBuggyMethodIsNotStatic === "function"-                  ? njsBuggyMethodIsNotStatic(args)-                  : args;-              const value = new m(...constructorArgs)[method](...args);+              let value;

+// @flow+import expect from "expect";+import invariant from "invariant";+import type { Transaction } from "./types";+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";+import { isAccountEmpty } from "../../account";+import { pickSiblings } from "../../bot/specs";+import type { AppSpec } from "../../bot/types";++const currency = getCryptoCurrencyById("algorand");++// Minimum fees+const minFees = parseCurrencyUnit(currency.units[0], "0.001");++// Minimum balance required for a new non-ASA account+const minBalanceNewAccount = parseCurrencyUnit(currency.units[0], "0.1");++// Minimum balance for a non-ASA account+let getMinBalance = (account) => {+  const minBalance = parseCurrencyUnit(currency.units[0], "0.1");+  const numberOfTokens = account.subAccounts+    ? account.subAccounts.filter((a) => a.type === "TokenAccount").length+    : 0;+  return minBalance.multipliedBy(1 + numberOfTokens);+};++// Spendable balance for a non-ASA account+let getSpendableBalance = (maxSpendable) => {+  maxSpendable = maxSpendable.minus(minFees);+  invariant(maxSpendable.gt(0), "spendable balance is too low");+  return maxSpendable;+};++// Ensure that, when the recipient corresponds to an empty account,+// the amount to send is greater or equal to the required minimum+// balance for such a recipient+let checkSendableToEmptyAccount = (amount, recipient) => {+  if (isAccountEmpty(recipient) && amount.lte(minBalanceNewAccount)) {+    invariant(+      amount.gt(minBalanceNewAccount),+      "not enough funds to send to new account"+    );+  }+};++// Extract asset ID from asset-type subaccount+let extractAssetId = (subaccount) => {+  if (subaccount.type !== "TokenAccount") {+    return null;+  }++  const assetIdRegex = /algorand\/asa\/(\d+)/g; // e.g, 'algorand/asa/312769'

+// @flow+import expect from "expect";+import invariant from "invariant";+import type { Transaction } from "./types";+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";+import { isAccountEmpty } from "../../account";+import { pickSiblings } from "../../bot/specs";+import type { AppSpec } from "../../bot/types";++const currency = getCryptoCurrencyById("algorand");++// Minimum fees+const minFees = parseCurrencyUnit(currency.units[0], "0.001");++// Minimum balance required for a new non-ASA account+const minBalanceNewAccount = parseCurrencyUnit(currency.units[0], "0.1");++// Minimum balance for a non-ASA account+let getMinBalance = (account) => {+  const minBalance = parseCurrencyUnit(currency.units[0], "0.1");+  const numberOfTokens = account.subAccounts+    ? account.subAccounts.filter((a) => a.type === "TokenAccount").length+    : 0;+  return minBalance.multipliedBy(1 + numberOfTokens);+};++// Spendable balance for a non-ASA account+let getSpendableBalance = (maxSpendable) => {+  maxSpendable = maxSpendable.minus(minFees);+  invariant(maxSpendable.gt(0), "spendable balance is too low");+  return maxSpendable;+};++// Ensure that, when the recipient corresponds to an empty account,+// the amount to send is greater or equal to the required minimum+// balance for such a recipient+let checkSendableToEmptyAccount = (amount, recipient) => {+  if (isAccountEmpty(recipient) && amount.lte(minBalanceNewAccount)) {+    invariant(+      amount.gt(minBalanceNewAccount),+      "not enough funds to send to new account"+    );+  }+};++// Extract asset ID from asset-type subaccount+let extractAssetId = (subaccount) => {+  if (subaccount.type !== "TokenAccount") {+    return null;+  }++  const assetIdRegex = /algorand\/asa\/(\d+)/g; // e.g, 'algorand/asa/312769'+  const match = assetIdRegex.exec(subaccount.token.id);+  return match !== null ? match[1] : null;+};++// Get list of ASAs associated with the account+let getAssets = (account) => {+  return account.subAccounts+    ? account.subAccounts.filter((a) => a.type === "TokenAccount")+    : [];+};++// Get list of ASAs IDs common between two accounts (intersection)+let getCommonAssetsIds = (senderAccount, recipientAccount) => {+  const senderAssetsIds = getAssets(senderAccount)+    .filter((a) => a.balance.gt(0))+    .map((a) => extractAssetId(a));++  const recipientAssetsIds = getAssets(recipientAccount).map((a) =>+    extractAssetId(a)+  );++  return senderAssetsIds.filter((assetId) =>+    recipientAssetsIds.includes(assetId)+  );+};++// Get Subaccount ID+// eslint-disable-next-line no-unused-vars+let getSubaccountId = (account, assetId) => {+  if (account.subAccounts == null) return null;++  account.subAccounts.forEach((subaccount) => {+    if (subaccount.id.endsWith(assetId)) {+      return subaccount.id; // e.g., libcore:1:algorand:fef9 . . . 4d7af:+algorand/asa/342836+    }+  });+};++const algorand: AppSpec<Transaction> = {+  name: "Algorand",+  currency,+  appQuery: {+    model: "nanoS",+    appName: "Algorand",+  },+  mutations: [+    {+      name: "move ~50%",+      maxRun: 2,+      transaction: ({ account, siblings, bridge, maxSpendable }) => {+        const spendableBalance = getSpendableBalance(maxSpendable);++        const sibling = pickSiblings(siblings, 4);+        const recipient = sibling.freshAddress;++        let transaction = bridge.createTransaction(account);++        let amount = spendableBalance+          .div(1.9 + 0.2 * Math.random())+          .integerValue();++        checkSendableToEmptyAccount(amount, sibling);++        const updates = [{ amount }, { recipient }];+        return {+          transaction,+          updates,+        };+      },+      test: ({ account, accountBeforeTransaction, operation }) => {+        expect(account.balance.toString()).toBe(+          accountBeforeTransaction.balance.minus(operation.value).toString()+        );+      },+    },+    {+      name: "send max",+      maxRun: 1,+      transaction: ({ account, siblings, bridge, maxSpendable }) => {+        const spendableBalance = getSpendableBalance(maxSpendable);+        const sibling = pickSiblings(siblings, 4);++        // Send the full spendable balance+        const amount = spendableBalance;++        checkSendableToEmptyAccount(amount, sibling);++        return {+          transaction: bridge.createTransaction(account),+          updates: [+            {+              recipient: pickSiblings(siblings, 30).freshAddress,+            },+            { useAllAmount: true },+          ],+        };+      },+      test: ({ account }) => {+        const minBalance = getMinBalance(account);

+// @flow+import expect from "expect";+import invariant from "invariant";+import type { Transaction } from "./types";+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";+import { isAccountEmpty } from "../../account";+import { pickSiblings } from "../../bot/specs";+import type { AppSpec } from "../../bot/types";++const currency = getCryptoCurrencyById("algorand");++// Minimum fees+const minFees = parseCurrencyUnit(currency.units[0], "0.001");++// Minimum balance required for a new non-ASA account+const minBalanceNewAccount = parseCurrencyUnit(currency.units[0], "0.1");++// Minimum balance for a non-ASA account+let getMinBalance = (account) => {+  const minBalance = parseCurrencyUnit(currency.units[0], "0.1");+  const numberOfTokens = account.subAccounts+    ? account.subAccounts.filter((a) => a.type === "TokenAccount").length+    : 0;+  return minBalance.multipliedBy(1 + numberOfTokens);+};++// Spendable balance for a non-ASA account+let getSpendableBalance = (maxSpendable) => {+  maxSpendable = maxSpendable.minus(minFees);+  invariant(maxSpendable.gt(0), "spendable balance is too low");+  return maxSpendable;+};++// Ensure that, when the recipient corresponds to an empty account,+// the amount to send is greater or equal to the required minimum+// balance for such a recipient+let checkSendableToEmptyAccount = (amount, recipient) => {+  if (isAccountEmpty(recipient) && amount.lte(minBalanceNewAccount)) {+    invariant(+      amount.gt(minBalanceNewAccount),+      "not enough funds to send to new account"+    );+  }+};++// Extract asset ID from asset-type subaccount+let extractAssetId = (subaccount) => {+  if (subaccount.type !== "TokenAccount") {+    return null;+  }++  const assetIdRegex = /algorand\/asa\/(\d+)/g; // e.g, 'algorand/asa/312769'+  const match = assetIdRegex.exec(subaccount.token.id);+  return match !== null ? match[1] : null;+};++// Get list of ASAs associated with the account+let getAssets = (account) => {+  return account.subAccounts+    ? account.subAccounts.filter((a) => a.type === "TokenAccount")+    : [];+};++// Get list of ASAs IDs common between two accounts (intersection)+let getCommonAssetsIds = (senderAccount, recipientAccount) => {+  const senderAssetsIds = getAssets(senderAccount)+    .filter((a) => a.balance.gt(0))+    .map((a) => extractAssetId(a));++  const recipientAssetsIds = getAssets(recipientAccount).map((a) =>+    extractAssetId(a)+  );++  return senderAssetsIds.filter((assetId) =>+    recipientAssetsIds.includes(assetId)+  );+};++// Get Subaccount ID+// eslint-disable-next-line no-unused-vars+let getSubaccountId = (account, assetId) => {+  if (account.subAccounts == null) return null;++  account.subAccounts.forEach((subaccount) => {+    if (subaccount.id.endsWith(assetId)) {+      return subaccount.id; // e.g., libcore:1:algorand:fef9 . . . 4d7af:+algorand/asa/342836

+// @flow+import expect from "expect";+import invariant from "invariant";+import type { Transaction } from "./types";+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";+import { isAccountEmpty } from "../../account";+import { pickSiblings } from "../../bot/specs";+import type { AppSpec } from "../../bot/types";++const currency = getCryptoCurrencyById("algorand");++// Minimum fees+const minFees = parseCurrencyUnit(currency.units[0], "0.001");++// Minimum balance required for a new non-ASA account+const minBalanceNewAccount = parseCurrencyUnit(currency.units[0], "0.1");++// Minimum balance for a non-ASA account+let getMinBalance = (account) => {+  const minBalance = parseCurrencyUnit(currency.units[0], "0.1");+  const numberOfTokens = account.subAccounts+    ? account.subAccounts.filter((a) => a.type === "TokenAccount").length+    : 0;+  return minBalance.multipliedBy(1 + numberOfTokens);+};++// Spendable balance for a non-ASA account+let getSpendableBalance = (maxSpendable) => {+  maxSpendable = maxSpendable.minus(minFees);+  invariant(maxSpendable.gt(0), "spendable balance is too low");+  return maxSpendable;+};++// Ensure that, when the recipient corresponds to an empty account,+// the amount to send is greater or equal to the required minimum+// balance for such a recipient+let checkSendableToEmptyAccount = (amount, recipient) => {+  if (isAccountEmpty(recipient) && amount.lte(minBalanceNewAccount)) {+    invariant(+      amount.gt(minBalanceNewAccount),+      "not enough funds to send to new account"+    );+  }+};++// Extract asset ID from asset-type subaccount+let extractAssetId = (subaccount) => {+  if (subaccount.type !== "TokenAccount") {+    return null;+  }++  const assetIdRegex = /algorand\/asa\/(\d+)/g; // e.g, 'algorand/asa/312769'+  const match = assetIdRegex.exec(subaccount.token.id);+  return match !== null ? match[1] : null;+};++// Get list of ASAs associated with the account+let getAssets = (account) => {+  return account.subAccounts+    ? account.subAccounts.filter((a) => a.type === "TokenAccount")+    : [];+};++// Get list of ASAs IDs common between two accounts (intersection)+let getCommonAssetsIds = (senderAccount, recipientAccount) => {+  const senderAssetsIds = getAssets(senderAccount)+    .filter((a) => a.balance.gt(0))+    .map((a) => extractAssetId(a));++  const recipientAssetsIds = getAssets(recipientAccount).map((a) =>+    extractAssetId(a)+  );++  return senderAssetsIds.filter((assetId) =>+    recipientAssetsIds.includes(assetId)+  );+};++// Get Subaccount ID+// eslint-disable-next-line no-unused-vars+let getSubaccountId = (account, assetId) => {+  if (account.subAccounts == null) return null;++  account.subAccounts.forEach((subaccount) => {+    if (subaccount.id.endsWith(assetId)) {+      return subaccount.id; // e.g., libcore:1:algorand:fef9 . . . 4d7af:+algorand/asa/342836+    }+  });+};++const algorand: AppSpec<Transaction> = {+  name: "Algorand",+  currency,+  appQuery: {+    model: "nanoS",+    appName: "Algorand",+  },+  mutations: [+    {+      name: "move ~50%",+      maxRun: 2,+      transaction: ({ account, siblings, bridge, maxSpendable }) => {+        const spendableBalance = getSpendableBalance(maxSpendable);++        const sibling = pickSiblings(siblings, 4);+        const recipient = sibling.freshAddress;++        let transaction = bridge.createTransaction(account);++        let amount = spendableBalance+          .div(1.9 + 0.2 * Math.random())+          .integerValue();++        checkSendableToEmptyAccount(amount, sibling);++        const updates = [{ amount }, { recipient }];+        return {+          transaction,+          updates,+        };+      },+      test: ({ account, accountBeforeTransaction, operation }) => {+        expect(account.balance.toString()).toBe(+          accountBeforeTransaction.balance.minus(operation.value).toString()+        );+      },+    },+    {+      name: "send max",+      maxRun: 1,+      transaction: ({ account, siblings, bridge, maxSpendable }) => {+        const spendableBalance = getSpendableBalance(maxSpendable);+        const sibling = pickSiblings(siblings, 4);++        // Send the full spendable balance+        const amount = spendableBalance;++        checkSendableToEmptyAccount(amount, sibling);++        return {+          transaction: bridge.createTransaction(account),+          updates: [+            {+              recipient: pickSiblings(siblings, 30).freshAddress,

+// @flow+import expect from "expect";+import invariant from "invariant";+import type { Transaction } from "./types";+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";+import { isAccountEmpty } from "../../account";+import { pickSiblings } from "../../bot/specs";+import type { AppSpec } from "../../bot/types";++const currency = getCryptoCurrencyById("algorand");++// Minimum fees+const minFees = parseCurrencyUnit(currency.units[0], "0.001");++// Minimum balance required for a new non-ASA account+const minBalanceNewAccount = parseCurrencyUnit(currency.units[0], "0.1");++// Minimum balance for a non-ASA account+let getMinBalance = (account) => {+  const minBalance = parseCurrencyUnit(currency.units[0], "0.1");+  const numberOfTokens = account.subAccounts+    ? account.subAccounts.filter((a) => a.type === "TokenAccount").length+    : 0;+  return minBalance.multipliedBy(1 + numberOfTokens);+};++// Spendable balance for a non-ASA account+let getSpendableBalance = (maxSpendable) => {+  maxSpendable = maxSpendable.minus(minFees);+  invariant(maxSpendable.gt(0), "spendable balance is too low");+  return maxSpendable;+};++// Ensure that, when the recipient corresponds to an empty account,+// the amount to send is greater or equal to the required minimum+// balance for such a recipient+let checkSendableToEmptyAccount = (amount, recipient) => {+  if (isAccountEmpty(recipient) && amount.lte(minBalanceNewAccount)) {+    invariant(+      amount.gt(minBalanceNewAccount),+      "not enough funds to send to new account"+    );+  }+};++// Extract asset ID from asset-type subaccount+let extractAssetId = (subaccount) => {+  if (subaccount.type !== "TokenAccount") {+    return null;+  }++  const assetIdRegex = /algorand\/asa\/(\d+)/g; // e.g, 'algorand/asa/312769'+  const match = assetIdRegex.exec(subaccount.token.id);+  return match !== null ? match[1] : null;+};++// Get list of ASAs associated with the account+let getAssets = (account) => {+  return account.subAccounts+    ? account.subAccounts.filter((a) => a.type === "TokenAccount")+    : [];+};++// Get list of ASAs IDs common between two accounts (intersection)+let getCommonAssetsIds = (senderAccount, recipientAccount) => {+  const senderAssetsIds = getAssets(senderAccount)+    .filter((a) => a.balance.gt(0))+    .map((a) => extractAssetId(a));++  const recipientAssetsIds = getAssets(recipientAccount).map((a) =>+    extractAssetId(a)+  );++  return senderAssetsIds.filter((assetId) =>+    recipientAssetsIds.includes(assetId)+  );+};++// Get Subaccount ID+// eslint-disable-next-line no-unused-vars

+// @flow+import { FeeNotLoaded } from "@ledgerhq/errors";+import type { Account } from "../../types";+import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";+import type { Core, CoreAccount } from "../../libcore/types";+import type { CoreAlgorandTransaction, Transaction } from "./types";++const setInfo = async (+  core,+  buildedTransaction,+  transaction,+  subAccount,+  account,+  isPartial+) => {+  const { amount, recipient, assetId, mode, useAllAmount } = transaction;+  if (subAccount || (assetId && mode === "optIn")) {+    let targetAssetId =+      subAccount && subAccount.type === "TokenAccount"+        ? subAccount.token.id.split("/")[2]+        : assetId?.split("/")[2] || assetId;++    if (targetAssetId === "" || isNaN(parseInt(targetAssetId))) {

+// @flow++import type {+  CryptoCurrency,+  TokenAccount,+  Account,+  SyncConfig,+} from "../../types";+import type { CoreAccount } from "../../libcore/types";+import { minimalOperationsBuilder } from "../../reconciliation";+import { buildASAOperation } from "./buildASAOperation";+import { BigNumber } from "bignumber.js";+import { findTokenById, listTokensForCryptoCurrency } from "../../currencies";++const OperationOrderKey = {+  date: 0,+};++async function buildAlgorandTokenAccount({+  parentAccountId,+  token,+  coreAccount,+  existingTokenAccount,+  balance,+}) {+  const id = parentAccountId + "+" + token.id;+  const getAllOperations = async () => {+    const query = await coreAccount.queryOperations();+    await query.complete();+    await query.addOrder(OperationOrderKey.date, false);+    const coreOperations = await query.execute();++    const operations = await minimalOperationsBuilder(+      (existingTokenAccount && existingTokenAccount.operations) || [],+      coreOperations,+      (coreOperation) =>+        buildASAOperation({+          coreOperation,+          accountId: id,+        })+    );++    return operations;+  };++  const operations = await getAllOperations();++  const tokenAccount: $Exact<TokenAccount> = {+    type: "TokenAccount",+    id,+    parentId: parentAccountId,+    starred: false,+    token,+    operationsCount: operations.length,+    operations,+    pendingOperations: [],+    balance,+    creationDate:+      operations.length > 0+        ? operations[operations.length - 1].date+        : new Date(),+  };++  return tokenAccount;+}++async function algorandBuildTokenAccounts({+  currency,+  coreAccount,+  accountId,+  existingAccount,+  syncConfig,+}: {+  currency: CryptoCurrency,+  coreAccount: CoreAccount,+  accountId: string,+  existingAccount: ?Account,+  syncConfig: SyncConfig,+}): Promise<?(TokenAccount[])> {+  const { blacklistedTokenIds = [] } = syncConfig;+  if (listTokensForCryptoCurrency(currency).length === 0) return undefined;+  const tokenAccounts = [];+  const algorandAccount = await coreAccount.asAlgorandAccount();+  const accountASA = await algorandAccount.getAssetsBalances();++  const existingAccountByTicker = {}; // used for fast lookup+  const existingAccountTickers = []; // used to keep track of ordering+  if (existingAccount && existingAccount.subAccounts) {+    for (const existingSubAccount of existingAccount.subAccounts) {+      if (existingSubAccount.type === "TokenAccount") {+        const { ticker, id } = existingSubAccount.token;+        if (!blacklistedTokenIds.includes(id)) {+          existingAccountTickers.push(ticker);+          existingAccountByTicker[ticker] = existingSubAccount;+        }+      }+    }+  }++  // filter by token existence+  accountASA.map(async (asa) => {

+// @flow+import { FeeNotLoaded } from "@ledgerhq/errors";+import type { Account } from "../../types";+import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";+import type { Core, CoreAccount } from "../../libcore/types";+import type { CoreAlgorandTransaction, Transaction } from "./types";++const setInfo = async (+  core,+  buildedTransaction,+  transaction,+  subAccount,+  account,+  isPartial+) => {+  const { amount, recipient, assetId, mode, useAllAmount } = transaction;+  if (subAccount || (assetId && mode === "optIn")) {+    let targetAssetId =+      subAccount && subAccount.type === "TokenAccount"+        ? subAccount.token.id.split("/")[2]+        : assetId?.split("/")[2] || assetId;

+/********************************************************************************

+// @flow+import { BigNumber } from "bignumber.js";+import {+  AmountRequired,+  InvalidAddressBecauseDestinationIsAlsoSource,+  NotEnoughBalance,+  FeeNotLoaded,+} from "@ledgerhq/errors";+import {+  AlgorandASANotOptInInRecipient,+  AlgorandNoAssetId,+} from "../../../errors";+import { validateRecipient } from "../../../bridge/shared";+import type { AccountBridge, CurrencyBridge, Account } from "../../../types";+import type { Transaction } from "../types";+import { AlgorandOperationTypeEnum } from "../types";+import { scanAccounts } from "../../../libcore/scanAccounts";+import { sync } from "../../../libcore/syncAccount";+import type { CacheRes } from "../../../cache";+import { makeLRUCache } from "../../../cache";+import { getMainAccount } from "../../../account";+import broadcast from "../libcore-broadcast";+import signOperation from "../libcore-signOperation";+import { getFeesForTransaction } from "../../../libcore/getFeesForTransaction";+import { withLibcore } from "../../../libcore/access";+import { getCoreAccount } from "../../../libcore/getCoreAccount";+import { libcoreAmountToBigNumber } from "../../../libcore/buildBigNumber";++const MAX_MEMO_SIZE = 32;++export const calculateFees: CacheRes<+  Array<{ a: Account, t: Transaction }>,+  { estimatedFees: BigNumber, estimatedGas: ?BigNumber }+> = makeLRUCache(+  async ({+    a,+    t,+  }): Promise<{ estimatedFees: BigNumber, estimatedGas: ?BigNumber }> => {+    return await getFeesForTransaction({+      account: a,+      transaction: t,+    });+  },+  ({ a, t }) =>+    `${a.id}_${t.amount.toString()}_${t.recipient}_${String(t.useAllAmount)}_${+      t.memo ? t.memo.toString() : ""+    }`+);++const getSpendableMaxForOptIn = async (account) =>+  await withLibcore(async (core) => {+    const { coreAccount } = await getCoreAccount(core, account);++    const algorandAccount = await coreAccount.asAlgorandAccount();+    const spendableBalanceBigInt = await algorandAccount.getSpendableBalance(+      AlgorandOperationTypeEnum.ASSET_OPT_IN+    );+    const spendableBalance = await libcoreAmountToBigNumber(+      spendableBalanceBigInt+    );++    return spendableBalance;+  });++const createTransaction = () => ({+  family: "algorand",+  amount: BigNumber(0),+  fees: null,+  recipient: "",+  useAllAmount: false,+  memo: null,+  mode: "send",+  assetId: null,+});++const updateTransaction = (t, patch) => {+  return { ...t, ...patch };+};++const recipientHasAsset = async (assetId, recipient, account) =>+  await withLibcore(async (core) => {+    const { coreAccount } = await getCoreAccount(core, account);++    const algorandAccount = await coreAccount.asAlgorandAccount();+    const hasAsset = await algorandAccount.hasAsset(recipient, assetId);++    return hasAsset;+  });+/*+ * Here are the list of the differents things we check+ * - Check if recipient is the same in case of send+ * - Check if recipient is valid+ * - Check if amounts are set+ * - Check if fees are loaded+ * - Check if is a send Max and set the amount+ * - Check if Token is already optin at the recipient+ * - Check if memo is too long+ */+const getTransactionStatus = async (a: Account, t) => {+  const errors = {};+  const warnings = {};+  const tokenAccount = !t.subAccountId+    ? null+    : a.subAccounts && a.subAccounts.find((ta) => ta.id === t.subAccountId);++  if (t.mode === "send" && a.freshAddress === t.recipient) {+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();+  } else {+    const { recipientError, recipientWarning } = await validateRecipient(+      a.currency,+      t.recipient+    );++    if (recipientError) {+      errors.recipient = recipientError;+    }++    if (recipientWarning) {+      warnings.recipient = recipientWarning;+    }+  }++  let estimatedFees = t.fees || BigNumber(0);+  let amount = t.amount;+  let totalSpent = estimatedFees;++  switch (t.mode) {+    case "send": {+      if (amount.lte(0) && !t.useAllAmount) {+        errors.amount = new AmountRequired();+      }++      if (!t.fees || !t.fees.gt(0)) {+        errors.fees = new FeeNotLoaded();+      }++      if (+        tokenAccount &&+        !(await recipientHasAsset(+          tokenAccount.id.split("/")[2],+          t.recipient,+          a+        ))+      ) {+        errors.recipient = new AlgorandASANotOptInInRecipient();+      }++      amount = t.useAllAmount+        ? tokenAccount+          ? tokenAccount.balance+          : a.spendableBalance.minus(estimatedFees)+        : amount;++      if (amount.lt(0)) {+        amount = BigNumber(0);+      }++      totalSpent = tokenAccount ? amount : amount.plus(estimatedFees);++      if (+        (amount.lte(0) && t.useAllAmount) || // if use all Amount sets an amount at 0+        (tokenAccount && a.spendableBalance.lt(estimatedFees)) || // if spendable balance lower than fees for token+        (!errors.recipient && !errors.amount && tokenAccount+          ? totalSpent.gt(tokenAccount.balance)+          : totalSpent.gt(a.spendableBalance)) // if spendable balance lower than total+      ) {+        errors.amount = new NotEnoughBalance();+      }+      break;+    }++    case "optIn": {+      if (!t.assetId) {+        errors.assetId = new AlgorandNoAssetId();+      }+      const spendableBalance = await getSpendableMaxForOptIn(a);+      if (spendableBalance.lt(estimatedFees)) {+        errors.amount = new NotEnoughBalance();+      }+      break;+    }++    case "claimReward": {+      if (a.spendableBalance.lt(totalSpent)) {+        errors.amount = new NotEnoughBalance();+      }+      break;+    }+  }++  if (t.memo && t.memo.length > MAX_MEMO_SIZE) {+    throw new Error("Memo is too long");+  }++  return Promise.resolve({+    errors,+    warnings,+    estimatedFees,+    amount,+    totalSpent,+  });+};++const sameFees = (a, b) => (!a || !b ? a === b : a.eq(b));++const prepareTransaction = async (a, t) => {+  let fees = t.fees;+  let amount = t.amount;+  let recipient = t.recipient;++  if (t.mode === "optIn" || t.mode === "claimReward") {+    recipient = a.freshAddress;+    amount = BigNumber(0);+  }++  if (recipient || t.mode !== "send") {+    const errors = (await validateRecipient(a.currency, recipient))+      .recipientError;+    if (!errors) {+      const res = await calculateFees({+        a,+        t,+      });++      fees = res.estimatedFees;+    }+  }++  if (+    !sameFees(t.fees, fees) ||+    !sameFees(t.amount, amount) ||+    t.recipient !== recipient+  ) {+    return { ...t, fees, amount, recipient };+  }++  return t;+};++const estimateMaxSpendable = async ({+  account,+  parentAccount,+  transaction,+}) => {+  const mainAccount = getMainAccount(account, parentAccount);+  const t = await prepareTransaction(mainAccount, {+    ...createTransaction(),+    subAccountId: account.type === "Account" ? null : account.id,+    recipient: "fakeAddressToBeDetermined",

+// @flow+import { BigNumber } from "bignumber.js";+import {+  AmountRequired,+  InvalidAddressBecauseDestinationIsAlsoSource,+  NotEnoughBalance,+  FeeNotLoaded,+} from "@ledgerhq/errors";+import {+  AlgorandASANotOptInInRecipient,+  AlgorandNoAssetId,+} from "../../../errors";+import { validateRecipient } from "../../../bridge/shared";+import type { AccountBridge, CurrencyBridge, Account } from "../../../types";+import type { Transaction } from "../types";+import { AlgorandOperationTypeEnum } from "../types";+import { scanAccounts } from "../../../libcore/scanAccounts";+import { sync } from "../../../libcore/syncAccount";+import type { CacheRes } from "../../../cache";+import { makeLRUCache } from "../../../cache";+import { getMainAccount } from "../../../account";+import broadcast from "../libcore-broadcast";+import signOperation from "../libcore-signOperation";+import { getFeesForTransaction } from "../../../libcore/getFeesForTransaction";+import { withLibcore } from "../../../libcore/access";+import { getCoreAccount } from "../../../libcore/getCoreAccount";+import { libcoreAmountToBigNumber } from "../../../libcore/buildBigNumber";++const MAX_MEMO_SIZE = 32;++export const calculateFees: CacheRes<+  Array<{ a: Account, t: Transaction }>,+  { estimatedFees: BigNumber, estimatedGas: ?BigNumber }+> = makeLRUCache(+  async ({+    a,+    t,+  }): Promise<{ estimatedFees: BigNumber, estimatedGas: ?BigNumber }> => {+    return await getFeesForTransaction({+      account: a,+      transaction: t,+    });+  },+  ({ a, t }) =>+    `${a.id}_${t.amount.toString()}_${t.recipient}_${String(t.useAllAmount)}_${+      t.memo ? t.memo.toString() : ""+    }`+);++const getSpendableMaxForOptIn = async (account) =>+  await withLibcore(async (core) => {+    const { coreAccount } = await getCoreAccount(core, account);++    const algorandAccount = await coreAccount.asAlgorandAccount();+    const spendableBalanceBigInt = await algorandAccount.getSpendableBalance(+      AlgorandOperationTypeEnum.ASSET_OPT_IN+    );+    const spendableBalance = await libcoreAmountToBigNumber(+      spendableBalanceBigInt+    );++    return spendableBalance;+  });++const createTransaction = () => ({+  family: "algorand",+  amount: BigNumber(0),+  fees: null,+  recipient: "",+  useAllAmount: false,+  memo: null,+  mode: "send",+  assetId: null,+});++const updateTransaction = (t, patch) => {+  return { ...t, ...patch };+};++const recipientHasAsset = async (assetId, recipient, account) =>+  await withLibcore(async (core) => {+    const { coreAccount } = await getCoreAccount(core, account);++    const algorandAccount = await coreAccount.asAlgorandAccount();+    const hasAsset = await algorandAccount.hasAsset(recipient, assetId);++    return hasAsset;+  });+/*+ * Here are the list of the differents things we check+ * - Check if recipient is the same in case of send+ * - Check if recipient is valid+ * - Check if amounts are set+ * - Check if fees are loaded+ * - Check if is a send Max and set the amount+ * - Check if Token is already optin at the recipient+ * - Check if memo is too long+ */+const getTransactionStatus = async (a: Account, t) => {+  const errors = {};+  const warnings = {};+  const tokenAccount = !t.subAccountId+    ? null+    : a.subAccounts && a.subAccounts.find((ta) => ta.id === t.subAccountId);++  if (t.mode === "send" && a.freshAddress === t.recipient) {+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();+  } else {+    const { recipientError, recipientWarning } = await validateRecipient(+      a.currency,+      t.recipient+    );++    if (recipientError) {+      errors.recipient = recipientError;+    }++    if (recipientWarning) {+      warnings.recipient = recipientWarning;+    }+  }++  let estimatedFees = t.fees || BigNumber(0);+  let amount = t.amount;+  let totalSpent = estimatedFees;++  switch (t.mode) {+    case "send": {+      if (amount.lte(0) && !t.useAllAmount) {+        errors.amount = new AmountRequired();+      }++      if (!t.fees || !t.fees.gt(0)) {+        errors.fees = new FeeNotLoaded();+      }++      if (+        tokenAccount &&+        !(await recipientHasAsset(+          tokenAccount.id.split("/")[2],+          t.recipient,+          a+        ))+      ) {+        errors.recipient = new AlgorandASANotOptInInRecipient();+      }++      amount = t.useAllAmount+        ? tokenAccount+          ? tokenAccount.balance+          : a.spendableBalance.minus(estimatedFees)+        : amount;++      if (amount.lt(0)) {+        amount = BigNumber(0);+      }++      totalSpent = tokenAccount ? amount : amount.plus(estimatedFees);++      if (+        (amount.lte(0) && t.useAllAmount) || // if use all Amount sets an amount at 0+        (tokenAccount && a.spendableBalance.lt(estimatedFees)) || // if spendable balance lower than fees for token+        (!errors.recipient && !errors.amount && tokenAccount+          ? totalSpent.gt(tokenAccount.balance)+          : totalSpent.gt(a.spendableBalance)) // if spendable balance lower than total+      ) {+        errors.amount = new NotEnoughBalance();+      }+      break;+    }++    case "optIn": {+      if (!t.assetId) {+        errors.assetId = new AlgorandNoAssetId();

+// @flow+import { BigNumber } from "bignumber.js";+import {+  AmountRequired,+  InvalidAddressBecauseDestinationIsAlsoSource,+  NotEnoughBalance,+  FeeNotLoaded,+} from "@ledgerhq/errors";+import {+  AlgorandASANotOptInInRecipient,+  AlgorandNoAssetId,+} from "../../../errors";+import { validateRecipient } from "../../../bridge/shared";+import type { AccountBridge, CurrencyBridge, Account } from "../../../types";+import type { Transaction } from "../types";+import { AlgorandOperationTypeEnum } from "../types";+import { scanAccounts } from "../../../libcore/scanAccounts";+import { sync } from "../../../libcore/syncAccount";+import type { CacheRes } from "../../../cache";+import { makeLRUCache } from "../../../cache";+import { getMainAccount } from "../../../account";+import broadcast from "../libcore-broadcast";+import signOperation from "../libcore-signOperation";+import { getFeesForTransaction } from "../../../libcore/getFeesForTransaction";+import { withLibcore } from "../../../libcore/access";+import { getCoreAccount } from "../../../libcore/getCoreAccount";+import { libcoreAmountToBigNumber } from "../../../libcore/buildBigNumber";++const MAX_MEMO_SIZE = 32;

+// @flow+import { BigNumber } from "bignumber.js";+import {+  AmountRequired,+  InvalidAddressBecauseDestinationIsAlsoSource,+  NotEnoughBalance,+  FeeNotLoaded,+} from "@ledgerhq/errors";+import {+  AlgorandASANotOptInInRecipient,+  AlgorandNoAssetId,+} from "../../../errors";+import { validateRecipient } from "../../../bridge/shared";+import type { AccountBridge, CurrencyBridge, Account } from "../../../types";+import type { Transaction } from "../types";+import { AlgorandOperationTypeEnum } from "../types";+import { scanAccounts } from "../../../libcore/scanAccounts";+import { sync } from "../../../libcore/syncAccount";+import type { CacheRes } from "../../../cache";+import { makeLRUCache } from "../../../cache";+import { getMainAccount } from "../../../account";+import broadcast from "../libcore-broadcast";+import signOperation from "../libcore-signOperation";+import { getFeesForTransaction } from "../../../libcore/getFeesForTransaction";+import { withLibcore } from "../../../libcore/access";+import { getCoreAccount } from "../../../libcore/getCoreAccount";+import { libcoreAmountToBigNumber } from "../../../libcore/buildBigNumber";++const MAX_MEMO_SIZE = 32;++export const calculateFees: CacheRes<+  Array<{ a: Account, t: Transaction }>,+  { estimatedFees: BigNumber, estimatedGas: ?BigNumber }+> = makeLRUCache(+  async ({+    a,+    t,+  }): Promise<{ estimatedFees: BigNumber, estimatedGas: ?BigNumber }> => {+    return await getFeesForTransaction({+      account: a,+      transaction: t,+    });+  },+  ({ a, t }) =>+    `${a.id}_${t.amount.toString()}_${t.recipient}_${String(t.useAllAmount)}_${+      t.memo ? t.memo.toString() : ""+    }`+);++const getSpendableMaxForOptIn = async (account) =>+  await withLibcore(async (core) => {+    const { coreAccount } = await getCoreAccount(core, account);++    const algorandAccount = await coreAccount.asAlgorandAccount();+    const spendableBalanceBigInt = await algorandAccount.getSpendableBalance(+      AlgorandOperationTypeEnum.ASSET_OPT_IN+    );+    const spendableBalance = await libcoreAmountToBigNumber(+      spendableBalanceBigInt+    );++    return spendableBalance;+  });++const createTransaction = () => ({+  family: "algorand",+  amount: BigNumber(0),+  fees: null,+  recipient: "",+  useAllAmount: false,+  memo: null,+  mode: "send",+  assetId: null,+});++const updateTransaction = (t, patch) => {+  return { ...t, ...patch };+};++const recipientHasAsset = async (assetId, recipient, account) =>+  await withLibcore(async (core) => {+    const { coreAccount } = await getCoreAccount(core, account);++    const algorandAccount = await coreAccount.asAlgorandAccount();+    const hasAsset = await algorandAccount.hasAsset(recipient, assetId);++    return hasAsset;+  });+/*+ * Here are the list of the differents things we check+ * - Check if recipient is the same in case of send+ * - Check if recipient is valid+ * - Check if amounts are set+ * - Check if fees are loaded+ * - Check if is a send Max and set the amount+ * - Check if Token is already optin at the recipient+ * - Check if memo is too long+ */+const getTransactionStatus = async (a: Account, t) => {+  const errors = {};+  const warnings = {};+  const tokenAccount = !t.subAccountId+    ? null+    : a.subAccounts && a.subAccounts.find((ta) => ta.id === t.subAccountId);++  if (t.mode === "send" && a.freshAddress === t.recipient) {+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();+  } else {+    const { recipientError, recipientWarning } = await validateRecipient(+      a.currency,+      t.recipient+    );++    if (recipientError) {+      errors.recipient = recipientError;+    }++    if (recipientWarning) {+      warnings.recipient = recipientWarning;+    }+  }++  let estimatedFees = t.fees || BigNumber(0);+  let amount = t.amount;+  let totalSpent = estimatedFees;++  switch (t.mode) {+    case "send": {+      if (amount.lte(0) && !t.useAllAmount) {+        errors.amount = new AmountRequired();+      }++      if (!t.fees || !t.fees.gt(0)) {+        errors.fees = new FeeNotLoaded();+      }++      if (+        tokenAccount &&+        !(await recipientHasAsset(+          tokenAccount.id.split("/")[2],

+// @flow++import { getAccountCurrency, getAccountName } from "@ledgerhq/live-common/lib/account";+import type { TFunction } from "react-i18next";+import type { AccountLike, Account } from "@ledgerhq/live-common/lib/types";+import React, { useCallback, useState, useMemo, useEffect } from "react";+import { withTranslation } from "react-i18next";+import { connect } from "react-redux";+import { createFilter } from "react-select";+import { createStructuredSelector } from "reselect";+import { shallowAccountsSelector } from "~/renderer/reducers/accounts";+import Select from "~/renderer/components/Select";+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/live-common/lib/types/currencies";+import type { SubAccount } from "@ledgerhq/live-common/lib/types/account";+import { MenuOption } from "~/renderer/components/PerCurrencySelectAccount/Option";+import { BigNumber } from "bignumber.js";++const mapStateToProps = createStructuredSelector({+  accounts: shallowAccountsSelector,+});++type Option = {+  matched: "boolean",+  account: Account,+  subAccount: SubAccount,+};+const getOptionValue = option => {+  return option.account ? option.account.id : null;+};++const defaultFilter = createFilter({+  stringify: ({ data: account }) => {+    const currency = getAccountCurrency(account);+    const name = getAccountName(account);+    return `${currency.ticker}|${currency.name}|${name}`;+  },+});+const filterOption = o => (candidate, input) => {+  const selfMatches = defaultFilter(candidate, input);+  if (selfMatches) return [selfMatches, true];+  return [false, false];+};++const AccountOption = React.memo(function AccountOption({+  account,+  subAccount,+  currency,+  isValue,+}: {+  account: Account,+  subAccount: SubAccount,+  currency: CryptoCurrency | TokenCurrency,+  isValue?: boolean,+}) {+  return <MenuOption isValue={isValue} account={account} subAccount={subAccount} />;+});++type OwnProps = {+  currency: TokenCurrency | CryptoCurrency,+  mandatoryTokens?: boolean,+  value: ?AccountLike,+  onChange: (account: ?AccountLike, tokenAccount: ?Account) => void,+};++type Props = OwnProps & {+  accounts: Account[],+  t: TFunction,+  onChange: (account: ?AccountLike, tokenAccount: ?Account) => void, // I have to add it twice else flow is unhappy, don't ask why+};++const getAccountsByCurrency = (accounts: Account[], currency: TokenCurrency | CryptoCurrency) =>+  accounts.filter((acc: Account) => acc.currency.id === currency.id);++// TODO: token account generation logic in live-common+const generateTokenAccount = (account: Account, currency: TokenCurrency) => ({+  type: "TokenAccount",+  id: account.id + "+" + currency.contractAddress,+  parentId: account.id,+  token: currency,+  balance: BigNumber(0),+  operationsCount: 0,+  creationDate: new Date(),+  operations: [],+  pendingOperations: [],+  starred: false,+});++const RawSelectAccount = ({+  accounts,+  onChange,+  t,+  currency,+  mandatoryTokens,+  ...props+}: Props) => {+  const availableAccounts = useMemo(() => {+    if (currency.type === "TokenCurrency") {+      const mainAccounts = getAccountsByCurrency(accounts, currency.parentCurrency);+      return mainAccounts.map((acc: Account) => {+        return {+          account: acc,+          subAccount:+            (acc.subAccounts &&+              acc.subAccounts.find(+                (subAcc: SubAccount) =>+                  subAcc.type === "TokenAccount" && subAcc.token.id === currency.id,+              )) ||+            generateTokenAccount(acc, currency),+        };+      });+    }+    return getAccountsByCurrency(accounts, currency).map((acc: Account) => ({+      account: acc,+      subAccount: null,+    }));+  }, [accounts, currency]);++  const [selectedValue, setSelectedValue] = useState();++  useEffect(() => {

+// @flow++import { getAccountCurrency, getAccountName } from "@ledgerhq/live-common/lib/account";+import type { TFunction } from "react-i18next";+import type { AccountLike, Account } from "@ledgerhq/live-common/lib/types";+import React, { useCallback, useState, useMemo, useEffect } from "react";+import { withTranslation } from "react-i18next";+import { connect } from "react-redux";+import { createFilter } from "react-select";+import { createStructuredSelector } from "reselect";+import { shallowAccountsSelector } from "~/renderer/reducers/accounts";+import Select from "~/renderer/components/Select";+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/live-common/lib/types/currencies";+import type { SubAccount } from "@ledgerhq/live-common/lib/types/account";+import { MenuOption } from "~/renderer/components/PerCurrencySelectAccount/Option";+import { BigNumber } from "bignumber.js";++const mapStateToProps = createStructuredSelector({+  accounts: shallowAccountsSelector,+});++type Option = {+  matched: "boolean",+  account: Account,+  subAccount: SubAccount,+};+const getOptionValue = option => {+  return option.account ? option.account.id : null;+};++const defaultFilter = createFilter({+  stringify: ({ data: account }) => {+    const currency = getAccountCurrency(account);+    const name = getAccountName(account);+    return `${currency.ticker}|${currency.name}|${name}`;+  },+});+const filterOption = o => (candidate, input) => {+  const selfMatches = defaultFilter(candidate, input);+  if (selfMatches) return [selfMatches, true];+  return [false, false];+};++const AccountOption = React.memo(function AccountOption({+  account,+  subAccount,+  currency,+  isValue,+}: {+  account: Account,+  subAccount: SubAccount,+  currency: CryptoCurrency | TokenCurrency,+  isValue?: boolean,+}) {+  return <MenuOption isValue={isValue} account={account} subAccount={subAccount} />;+});++type OwnProps = {+  currency: TokenCurrency | CryptoCurrency,+  mandatoryTokens?: boolean,+  value: ?AccountLike,+  onChange: (account: ?AccountLike, tokenAccount: ?Account) => void,+};++type Props = OwnProps & {+  accounts: Account[],+  t: TFunction,+  onChange: (account: ?AccountLike, tokenAccount: ?Account) => void, // I have to add it twice else flow is unhappy, don't ask why+};++const getAccountsByCurrency = (accounts: Account[], currency: TokenCurrency | CryptoCurrency) =>+  accounts.filter((acc: Account) => acc.currency.id === currency.id);++// TODO: token account generation logic in live-common+const generateTokenAccount = (account: Account, currency: TokenCurrency) => ({+  type: "TokenAccount",+  id: account.id + "+" + currency.contractAddress,+  parentId: account.id,+  token: currency,+  balance: BigNumber(0),+  operationsCount: 0,+  creationDate: new Date(),+  operations: [],+  pendingOperations: [],+  starred: false,+});++const RawSelectAccount = ({+  accounts,+  onChange,+  t,+  currency,+  mandatoryTokens,+  ...props+}: Props) => {+  const availableAccounts = useMemo(() => {+    if (currency.type === "TokenCurrency") {+      const mainAccounts = getAccountsByCurrency(accounts, currency.parentCurrency);+      return mainAccounts.map((acc: Account) => {