@ledgerhq/live-common 21.13.2 → 21.14.0

package/src/families/bitcoin/wallet-btc/crypto/zen.ts

@@ -102,6 +102,11 @@ class Zen implements ICrypto {
       (res[1] === 0x89 || res[1] === 0x96)
     );
   }
+
+  // eslint-disable-next-line class-methods-use-this
+  isTaprootAddress(address: string): boolean {
+    return false;
+  }
 }
 
 export default Zen;

package/src/families/bitcoin/wallet-btc/explorer/index.ts

@@ -285,12 +285,7 @@ class BitcoinLikeExplorer extends EventEmitter implements IExplorer {
 
     // faster than mapping
     res.txs.forEach((tx) => {
-      if (!tx.block) {
-        return;
-      }
-
       this.hydrateTx(address, tx);
-
       hydratedTxs.push(tx);
     });
 

package/src/families/bitcoin/wallet-btc/index.ts

@@ -11,7 +11,7 @@ import { TX, Input, Output } from "./storage/types";
 import { CoinSelect } from "./pickingstrategies/CoinSelect";
 import { DeepFirst } from "./pickingstrategies/DeepFirst";
 import { Merge } from "./pickingstrategies/Merge";
-import { isValidAddress } from "./utils";
+import { isValidAddress, isTaprootAddress } from "./utils";
 
 import type { Account as WalletAccount } from "./account";
 import type { Account as LiveAccount } from "./../../../types";
@@ -32,16 +32,16 @@ export {
   DeepFirst,
   Merge,
   isValidAddress,
+  isTaprootAddress,
   Currency,
 };
 
 let wallet: BitcoinLikeWallet | null = null;
 
 export const getWalletAccount = (account: LiveAccount): WalletAccount => {
-  if (account.id.startsWith("libcore")) throw new AccountNeedResync();
   const walletAccount = account.bitcoinResources?.walletAccount;
-  if (!walletAccount) {
-    throw new Error("bitcoin wallet account expected");
+  if (account.id.startsWith("libcore") || !walletAccount) {
+    throw new AccountNeedResync();
   }
   return walletAccount;
 };

package/src/families/bitcoin/wallet-btc/utils.ts

@@ -156,3 +156,13 @@ export function isValidAddress(address: string, currency?: Currency) {
   const crypto = cryptoFactory(currency);
   return crypto.validateAddress(address);
 }
+
+export function isTaprootAddress(address: string, currency?: Currency) {
+  if (currency === "bitcoin") {
+    return cryptoFactory("bitcoin").isTaprootAddress(address);
+  } else if (currency === "bitcoin_testnet") {
+    return cryptoFactory("bitcoin_testnet").isTaprootAddress(address);
+  } else {
+    return false;
+  }
+}

package/src/families/bitcoin/wallet-btc/xpub.ts

@@ -1,6 +1,6 @@
 import { maxBy, range, some } from "lodash";
 import BigNumber from "bignumber.js";
-import { Address, IStorage } from "./storage/types";
+import { TX, Address, IStorage } from "./storage/types";
 import EventEmitter from "./utils/eventemitter";
 import { IExplorer } from "./explorer/types";
 import { ICrypto } from "./crypto/types";
@@ -20,9 +20,9 @@ class Xpub extends EventEmitter {
 
   derivationMode: string;
 
-  freshAddress: { [key: string]: string } = {};
+  freshAddress: string;
 
-  freshAddressIndex: { [key: string]: number } = {};
+  freshAddressIndex: number;
 
   // https://github.com/bitcoinjs/bitcoinjs-lib/blob/27a840aac4a12338f1e40c54f3759bbd7a559944/src/bufferutils.js#L24
   // only works with number so we need to be sure to pass correct numbers
@@ -54,6 +54,8 @@ class Xpub extends EventEmitter {
     this.crypto = crypto;
     this.xpub = xpub;
     this.derivationMode = derivationMode;
+    this.freshAddress = "";
+    this.freshAddressIndex = 0;
   }
 
   async syncAddress(account: number, index: number) {
@@ -78,9 +80,7 @@ class Xpub extends EventEmitter {
 
     // TODO handle eventual reorg case using lastBlock
 
-    let added = 0;
     let total = 0;
-
     try {
       // TODO perf: bad : looping in the tx array
       await this.checkAddressReorg(account, index);
@@ -95,20 +95,7 @@ class Xpub extends EventEmitter {
       if (hasPendings) {
         await this.storage.removePendingTxs({ account, index });
       }
-
-      // eslint-disable-next-line no-cond-assign,no-await-in-loop
-      while (
-        (added = await this.fetchHydrateAndStoreNewTxs(address, account, index))
-      ) {
-        total += added;
-      }
-
-      const pendingTxs = await this.explorer.getPendings({
-        address,
-        account,
-        index,
-      });
-      await this.storage.appendTxs(pendingTxs);
+      total = await this.fetchHydrateAndStoreNewTxs(address, account, index);
     } catch (e) {
       this.emitSyncedFailed(data);
       throw e;
@@ -120,11 +107,8 @@ class Xpub extends EventEmitter {
       account,
       index,
     });
-    if (lastTx) {
-      this.freshAddressIndex[account] = Math.max(
-        this.freshAddressIndex[account],
-        index + 1
-      );
+    if (account === 0 && lastTx) {
+      this.freshAddressIndex = Math.max(this.freshAddressIndex, index + 1);
     }
     return !!lastTx;
   }
@@ -137,13 +121,6 @@ class Xpub extends EventEmitter {
   }
 
   async syncAccount(account: number) {
-    this.freshAddressIndex[account] = 0;
-    this.freshAddress[account] = this.crypto.getAddress(
-      this.derivationMode,
-      this.xpub,
-      account,
-      0
-    );
     await this.whenSynced("account", account.toString());
 
     this.emitSyncing({
@@ -174,26 +151,19 @@ class Xpub extends EventEmitter {
       account,
       index,
     });
-    this.freshAddress[account] = this.crypto.getAddress(
-      this.derivationMode,
-      this.xpub,
-      account,
-      this.freshAddressIndex[account]
-    );
     return index;
   }
 
   // TODO : test fail case + incremental
   async sync() {
     await this.whenSynced("all");
-
     this.emitSyncing({ type: "all" });
-
+    this.freshAddressIndex = 0;
     let account = 0;
-
     try {
       // eslint-disable-next-line no-await-in-loop
-      while (await this.syncAccount(account)) {
+      while (account < 2 && (await this.syncAccount(account))) {
+        // account=0 for receive address; account=1 for change address. No need to handle account>1
         account += 1;
       }
     } catch (e) {
@@ -202,7 +172,12 @@ class Xpub extends EventEmitter {
     }
 
     this.emitSynced({ type: "all", account });
-
+    this.freshAddress = this.crypto.getAddress(
+      this.derivationMode,
+      this.xpub,
+      0,
+      this.freshAddressIndex
+    );
     return account;
   }
 
@@ -440,18 +415,27 @@ class Xpub extends EventEmitter {
     account: number,
     index: number
   ) {
-    const lastTx = await this.storage.getLastTx({
-      account,
-      index,
-      confirmed: true,
-    });
+    let pendingTxs: TX[] = [];
+    let txs: TX[] = [];
+    let inserted = 0;
+    do {
+      const lastTx = await this.storage.getLastTx({
+        account,
+        index,
+        confirmed: true,
+      });
 
-    const txs = await this.explorer.getAddressTxsSinceLastTxBlock(
-      this.txsSyncArraySize,
-      { address, account, index },
-      lastTx
-    );
-    const inserted = await this.storage.appendTxs(txs);
+      txs = await this.explorer.getAddressTxsSinceLastTxBlock(
+        this.txsSyncArraySize,
+        { address, account, index },
+        lastTx
+      );
+      if (pendingTxs.length === 0) {
+        pendingTxs = txs.filter((tx) => !tx.block);
+      }
+      inserted += await this.storage.appendTxs(txs.filter((tx) => tx.block)); // only insert not pending tx
+    } while (txs.length - pendingTxs.length >= this.txsSyncArraySize); // check whether page is full, if not, it is the last page
+    inserted += await this.storage.appendTxs(pendingTxs);
     return inserted;
   }
 

package/src/families/elrond/js-getTransactionStatus.ts

@@ -32,6 +32,10 @@ const getTransactionStatus = async (
   }
 
   const estimatedFees = t.fees || new BigNumber(0);
+  if (estimatedFees.gt(a.balance)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
   const totalSpent = useAllAmount
     ? a.balance
     : new BigNumber(t.amount).plus(estimatedFees);

package/src/families/elrond/js-signOperation.ts

@@ -15,7 +15,9 @@ const buildOptimisticOperation = (
   fee: BigNumber
 ): Operation => {
   const type = "OUT";
-  const value = new BigNumber(transaction.amount);
+  const value = transaction.useAllAmount
+    ? account.balance.minus(fee)
+    : new BigNumber(transaction.amount);
   const operation: Operation = {
     id: encodeOperationId(account.id, "", type),
     hash: "",

package/src/families/ethereum/specs.ts

@@ -445,8 +445,55 @@ const bsc: AppSpec<Transaction> = {
   ]),
 };
 
+const polygon: AppSpec<Transaction> = {
+  name: "Polygon",
+  currency: getCryptoCurrencyById("polygon"),
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Polygon",
+  },
+  testTimeout: 2 * 60 * 1000,
+  transactionCheck: ({ maxSpendable }) => {
+    invariant(
+      maxSpendable.gt(
+        parseCurrencyUnit(getCryptoCurrencyById("polygon").units[0], "0.005")
+      ),
+      "balance is too low"
+    );
+  },
+  mutations: ethereumBasicMutations({ maxAccount: 8 }).concat([
+    {
+      name: "move some ERC20",
+      maxRun: 1,
+      // @ts-expect-error rxjs stuff
+      transaction: ({ account, siblings, bridge }) => {
+        const erc20Account = sample(
+          (account.subAccounts || []).filter((a) => a.balance.gt(0))
+        );
+        invariant(erc20Account, "no erc20 account");
+        const sibling = pickSiblings(siblings, 3);
+        const recipient = sibling.freshAddress;
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            { recipient, subAccountId: erc20Account.id },
+            Math.random() < 0.5
+              ? { useAllAmount: true }
+              : {
+                  amount: erc20Account.balance
+                    .times(Math.random())
+                    .integerValue(),
+                },
+          ],
+        };
+      },
+    },
+  ]),
+};
+
 export default {
   bsc,
+  polygon,
   ethereum,
   ethereumClassic,
   ethereumRopsten,