@ledgerhq/live-common 21.13.1 → 21.14.1

package/src/__tests__/derivation.ts

@@ -6,7 +6,7 @@ import {
 describe("derivation", () => {
   test("getPreferredNewAccountScheme should return a list of schemes for a given currency", () => {
     const testData = [
-      ["bitcoin", ["native_segwit", "segwit", ""]],
+      ["bitcoin", ["native_segwit", "taproot", "segwit", ""]],
       ["ethereum", null],
       ["cosmos", null],
       ["litecoin", ["native_segwit", "segwit", ""]],

package/src/__tests__/families/bitcoin/wallet-btc/wallet.integration.test.ts

@@ -63,7 +63,7 @@ describe("testing wallet", () => {
       fromAccount: account,
       txInfo,
     });
-    expect(tx).toEqual("66ad13fd62ca677ae4d169ec5fe84be2f846562a");
+    expect(tx).toEqual("d6154bba4915d07453bb09d4fa02d62e975b4475");
   });
 
   it("should allow to build a transaction splitting outputs", async () => {
@@ -87,7 +87,7 @@ describe("testing wallet", () => {
       fromAccount: account,
       txInfo,
     });
-    expect(tx).toEqual("23ab414d38fe836e22619d6ee84fdebafa6b5168");
+    expect(tx).toEqual("d922a70d6a66b96cdaba4565270a21f97eb23a6d");
   });
 
   it("should throw during sync if there is an error in explorer", async () => {

package/src/apps/polyfill.ts

@@ -48,6 +48,7 @@ export const whitelistDependencies = ["Decred", "Decred Testnet"];
   ["Compound", "Ethereum"],
   ["Opensea", "Ethereum"],
   ["StakeDAO", "Ethereum"],
+  ["Yearn", "Ethereum"],
 ].forEach(([name, dep]) => declareDep(name, dep));
 export const getDependencies = (appName: string): string[] =>
   directDep[appName] || [];

package/src/currencies/__snapshots__/sortByMarketcap.test.ts.snap

@@ -722,7 +722,6 @@ Array [
   "ethereum/erc20/wholeearthcoin",
   "ethereum/erc20/datx",
   "ethereum/erc20/mileverse",
-  "ethereum/erc20/cr_coin",
   "ethereum/erc20/biocrypt",
   "ethereum/erc20/bittwatt",
   "ethereum/erc20/ono_token",
@@ -2186,6 +2185,7 @@ Array [
   "ethereum/erc20/cpollo",
   "ethereum/erc20/cprop",
   "ethereum/erc20/cr7coin",
+  "ethereum/erc20/cr_coin",
   "ethereum/erc20/crafty_token",
   "ethereum/erc20/crb",
   "ethereum/erc20/cream",
@@ -3626,6 +3626,7 @@ Array [
   "ethereum/erc20/monftertoken",
   "ethereum/erc20/monkeycoin",
   "ethereum/erc20/monnos_token",
+  "ethereum/erc20/mononoke_inu",
   "ethereum/erc20/moon_juice",
   "ethereum/erc20/moon_yfi",
   "ethereum/erc20/moona239_coins",
@@ -4271,6 +4272,7 @@ Array [
   "ethereum/erc20/safeswap",
   "ethereum/erc20/saitama_inu",
   "ethereum/erc20/saito",
+  "ethereum/erc20/saja",
   "ethereum/erc20/sake",
   "ethereum/erc20/saketoken",
   "ethereum/erc20/sakhalin_husky",
@@ -4496,6 +4498,7 @@ Array [
   "ethereum/erc20/spurt_plus",
   "ethereum/erc20/squirrel_finance",
   "ethereum/erc20/srh",
+  "ethereum/erc20/ssv_token",
   "ethereum/erc20/sta",
   "ethereum/erc20/stabilize_token",
   "ethereum/erc20/stabinol_token",
@@ -4855,6 +4858,7 @@ Array [
   "ethereum/erc20/tryfinance",
   "ethereum/erc20/tsla.finance",
   "ethereum/erc20/tsuki_inu",
+  "ethereum/erc20/tsuzuki_inu",
   "ethereum/erc20/ttx_nft",
   "ethereum/erc20/tugz",
   "ethereum/erc20/tune",
@@ -5090,6 +5094,7 @@ Array [
   "ethereum/erc20/wild_credit",
   "ethereum/erc20/wilder",
   "ethereum/erc20/windbellows",
+  "ethereum/erc20/winry_inu",
   "ethereum/erc20/wise_token",
   "ethereum/erc20/witch_token",
   "ethereum/erc20/wiva",
@@ -5777,7 +5782,9 @@ Array [
   "bsc/bep20/easy_v2",
   "bsc/bep20/elite_swap_binance_token",
   "bsc/bep20/ellipsis",
+  "bsc/bep20/empire_token",
   "bsc/bep20/empiricus_token",
+  "bsc/bep20/ev_direct_currency",
   "bsc/bep20/exeedme",
   "bsc/bep20/extend_finance",
   "bsc/bep20/faracrystal",
@@ -5922,6 +5929,7 @@ Array [
   "bsc/bep20/seedifyfund",
   "bsc/bep20/seven_up_token",
   "bsc/bep20/shard",
+  "bsc/bep20/shiba_inu",
   "bsc/bep20/shield_protocol",
   "bsc/bep20/shirtum",
   "bsc/bep20/smart_advertising_transaction_token",
@@ -5951,6 +5959,7 @@ Array [
   "bsc/bep20/tenet",
   "bsc/bep20/the_force_token",
   "bsc/bep20/thugs",
+  "bsc/bep20/tiki",
   "bsc/bep20/titanswap",
   "bsc/bep20/tixl_token",
   "bsc/bep20/tokenpocket_token",

package/src/derivation.ts

@@ -470,7 +470,7 @@ export const getDerivationModesForCurrency = (
 
   // taproot logic. FIXME should move per family
   if (currency.family === "bitcoin") {
-    if (currency.id === "bitcoin_testnet") {
+    if (currency.id === "bitcoin" || currency.id === "bitcoin_testnet") {
       all.push("taproot");
     }
   }

package/src/env.ts

@@ -67,7 +67,7 @@ const envDefinitions = {
   },
   API_RIPPLE_WS: {
     parser: stringParser,
-    def: "wss://xrplcluster.com",
+    def: "wss://xrplcluster.com/ledgerlive",
     desc: "XRP Ledger full history open WebSocket endpoint",
   },
   API_FILECOIN_ENDPOINT: {

package/src/families/bitcoin/cache.ts

@@ -4,6 +4,7 @@ import type { Account, CryptoCurrency } from "./../../types";
 import type { Transaction } from "./types";
 import getFeesForTransaction from "./js-getFeesForTransaction";
 import { isValidRecipient } from "./logic";
+import { Currency, isTaprootAddress } from "./wallet-btc";
 
 const getCacheKeyForCalculateFees = ({
   a,
@@ -41,6 +42,7 @@ export const calculateFees = makeLRUCache(
     maxAge: 5 * 60 * 1000, // 5 minutes
   }
 );
+
 export const validateRecipient: (
   arg0: CryptoCurrency,
   arg1: string | null | undefined
@@ -74,3 +76,13 @@ export const validateRecipient: (
   },
   (currency, recipient) => `${currency.id}_${recipient || ""}`
 );
+
+export const isTaprootRecipient: (
+  arg0: CryptoCurrency,
+  arg1: string
+) => Promise<boolean> = makeLRUCache(
+  async (currency, recipient) => {
+    return isTaprootAddress(recipient, <Currency>currency.id);
+  },
+  (currency, recipient) => `${currency.id}_${recipient || ""}`
+);

package/src/families/bitcoin/errors.ts

@@ -0,0 +1,5 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const TaprootNotActivated = createCustomErrorClass(
+  "TaprootNotActivated"
+);

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

@@ -9,7 +9,8 @@ import {
 } from "@ledgerhq/errors";
 import type { Account, TransactionStatus } from "./../../types";
 import type { Transaction } from "./types";
-import { calculateFees, validateRecipient } from "./cache";
+import { calculateFees, validateRecipient, isTaprootRecipient } from "./cache";
+import { TaprootNotActivated } from "./errors";
 
 const getTransactionStatus = async (
   a: Account,
@@ -31,6 +32,19 @@ const getTransactionStatus = async (
     warnings.recipient = recipientWarning;
   }
 
+  // Safeguard before Taproot activation
+  if (
+    t.recipient &&
+    !errors.recipient &&
+    a.currency.id === "bitcoin" &&
+    a.blockHeight <= 709632
+  ) {
+    const isTaproot = await isTaprootRecipient(a.currency, t.recipient);
+    if (isTaproot) {
+      errors.recipient = new TaprootNotActivated();
+    }
+  }
+
   let txInputs;
   let txOutputs;
   let estimatedFees = new BigNumber(0);

package/src/families/bitcoin/js-synchronisation.ts

@@ -342,8 +342,8 @@ const getAccountShape: GetAccountShape = async (info) => {
     spendableBalance: balance,
     operations,
     operationsCount: operations.length,
-    freshAddress: walletAccount.xpub.freshAddress[0],
-    freshAddressPath: `${accountPath}/0/${walletAccount.xpub.freshAddressIndex[0]}`,
+    freshAddress: walletAccount.xpub.freshAddress,
+    freshAddressPath: `${accountPath}/0/${walletAccount.xpub.freshAddressIndex}`,
     blockHeight,
     bitcoinResources: {
       utxos,

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

@@ -27,6 +27,9 @@ export function fallbackValidateAddress(address: string): boolean {
 class Base implements ICrypto {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   network: any;
+  protected static publickeyCache = {}; // xpub + account + index to publicKey
+  protected static addressCache = {}; // derivationMode + xpub + account + index to address
+  protected static bech32Cache = {}; // xpub to bech32 interface
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor({ network }: { network: any }) {
@@ -37,9 +40,26 @@ class Base implements ICrypto {
   }
 
   protected getPubkeyAt(xpub: string, account: number, index: number): Buffer {
-    return bip32.fromBase58(xpub, this.network).derive(account).derive(index)
-      .publicKey;
+    if (!Base.bech32Cache[xpub]) {
+      Base.bech32Cache[xpub] = bip32.fromBase58(xpub, this.network);
+    }
+    if (Base.publickeyCache[`${xpub}-${account}-${index}`]) {
+      return Base.publickeyCache[`${xpub}-${account}-${index}`];
+    }
+    if (Base.publickeyCache[`${xpub}-${account}`]) {
+      const publicKey =
+        Base.publickeyCache[`${xpub}-${account}`].derive(index).publicKey;
+      Base.publickeyCache[`${xpub}-${account}-${index}`] = publicKey;
+      return publicKey;
+    }
+    Base.publickeyCache[`${xpub}-${account}`] =
+      Base.bech32Cache[xpub].derive(account);
+    const publicKey =
+      Base.publickeyCache[`${xpub}-${account}`].derive(index).publicKey;
+    Base.publickeyCache[`${xpub}-${account}-${index}`] = publicKey;
+    return publicKey;
   }
+
   // derive legacy address at account and index positions
   getLegacyAddress(xpub: string, account: number, index: number): string {
     const { address } = bjs.payments.p2pkh({
@@ -78,16 +98,26 @@ class Base implements ICrypto {
     account: number,
     index: number
   ): string {
+    if (Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`]) {
+      return Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`];
+    }
     switch (derivationMode) {
       case DerivationModes.LEGACY:
-        return this.getLegacyAddress(xpub, account, index);
+        Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`] =
+          this.getLegacyAddress(xpub, account, index);
+        break;
       case DerivationModes.SEGWIT:
-        return this.getSegWitAddress(xpub, account, index);
+        Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`] =
+          this.getSegWitAddress(xpub, account, index);
+        break;
       case DerivationModes.NATIVE_SEGWIT:
-        return this.getNativeSegWitAddress(xpub, account, index);
+        Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`] =
+          this.getNativeSegWitAddress(xpub, account, index);
+        break;
       default:
         throw new Error(`Invalid derivation Mode: ${derivationMode}`);
     }
+    return Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`];
   }
 
   // infer address type from its syntax
@@ -119,6 +149,11 @@ class Base implements ICrypto {
       (res[0] === this.network.pubKeyHash || res[0] === this.network.scriptHash)
     );
   }
+
+  // eslint-disable-next-line
+  isTaprootAddress(address: string): boolean {
+    return false;
+  }
 }
 
 export default Base;

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

@@ -124,9 +124,16 @@ class Bitcoin extends Base {
     account: number,
     index: number
   ): string {
+    if (Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`]) {
+      return Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`];
+    }
     switch (derivationMode) {
       case DerivationModes.TAPROOT:
-        return this.getTaprootAddress(xpub, account, index);
+        Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`] =
+          this.getTaprootAddress(xpub, account, index);
+        return Base.addressCache[
+          `${derivationMode}-${xpub}-${account}-${index}`
+        ];
       default:
         return super.getAddress(derivationMode, xpub, account, index);
     }
@@ -202,6 +209,19 @@ class Bitcoin extends Base {
     // Create address
     return toBech32(outputSchnorrKey, 1, this.network.bech32);
   }
+
+  isTaprootAddress(address: string): boolean {
+    // This prefix check is to avoid returning false in cases where a valid base58 address also happens
+    // to be a valid bech32(m) string (but invalid segwit address).
+    if (address.toLowerCase().startsWith(`${this.network.bech32}1`)) {
+      try {
+        bjs.address.fromBech32(address);
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  }
 }
 
 export default Bitcoin;

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

@@ -70,6 +70,11 @@ class BitcoinCash implements ICrypto {
   validateAddress(address: string): boolean {
     return bchaddr.isValidAddress(address);
   }
+
+  // eslint-disable-next-line
+  isTaprootAddress(address: string): boolean {
+    return false;
+  }
 }
 
 export default BitcoinCash;

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

@@ -11,6 +11,7 @@ export interface ICrypto {
 
   toOutputScript(address: string): Buffer;
   validateAddress(address: string): boolean;
+  isTaprootAddress(address: string): boolean;
 }
 
 export type Currency =

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

@@ -74,6 +74,11 @@ class ZCash implements ICrypto {
   validateAddress(address: string): boolean {
     return zec.Address.isValid(address, "livenet");
   }
+
+  // eslint-disable-next-line
+  isTaprootAddress(address: string): boolean {
+    return false;
+  }
 }
 
 export default ZCash;

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
+  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

@@ -83,12 +83,12 @@ export function byteSize(count: number) {
     return 1;
   }
   if (count <= 0xffff) {
-    return 2;
+    return 3;
   }
   if (count <= 0xffffffff) {
-    return 4;
+    return 5;
   }
-  return 8;
+  return 9;
 }
 
 // refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/api_impl/BitcoinLikeTransactionApi.cpp#L217
@@ -106,10 +106,14 @@ export function estimateTxSize(
   fixedSize += byteSize(inputCount); // Number of inputs
   fixedSize += byteSize(outputCount); // Number of outputs
   fixedSize += 4; // Timelock
+  if (derivationMode !== DerivationModes.LEGACY) {
+    fixedSize += 0.5; // Segwit marker & segwit flag
+  }
   // refer to https://medium.com/coinmonks/on-bitcoin-transaction-sizes-part-2-9445373d17f4
   // and https://bitcoin.stackexchange.com/questions/96017/what-are-the-sizes-of-single-sig-and-2-of-3-multisig-taproot-inputs
+  // and https://bitcoinops.org/en/tools/calc-size/
   if (derivationMode === DerivationModes.TAPROOT) {
-    txSize = fixedSize + 57.5 * inputCount + 43 * outputCount;
+    txSize = fixedSize + 57.75 * inputCount + 43 * outputCount;
     return Math.ceil(txSize);
   }
   const isSegwit =
@@ -120,12 +124,12 @@ export function estimateTxSize(
     // P2SH: 32 PrevTxHash + 4 Index + 23 scriptPubKey + 4 sequence
     const isNativeSegwit = derivationMode === DerivationModes.NATIVE_SEGWIT;
     const inputSize = isNativeSegwit ? 41 : 63;
-    const noWitness = fixedSize + inputSize * inputCount + 34 * outputCount;
+    const noWitness = fixedSize + inputSize * inputCount + 43 * outputCount; //43 is the biggest output(taproot output) size, we use the biggest one for safety
     // Include flag and marker size (one byte each)
     const witnessSize = noWitness + 108 * inputCount + 2;
     txSize = (noWitness * 3 + witnessSize) / 4;
   } else {
-    txSize = fixedSize + 148 * inputCount + 34 * outputCount;
+    txSize = fixedSize + 148 * inputCount + 43 * outputCount;
   }
   return Math.ceil(txSize); // We don't allow floating value
 }
@@ -156,3 +160,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/wallet.ts

@@ -263,7 +263,7 @@ class BitcoinLikeWallet {
       return [
         btc.splitTransaction(
           i.txHex,
-          segwit,
+          true,
           false, // FIXME hasTimestamp needed for LL-7539
           hasExtraData,
           additionals

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;
   }