@ledgerhq/live-common 21.16.0 → 21.16.4

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

@@ -1,6 +1,9 @@
-import { bech32m, bech32, BechLib } from "bech32";
+import * as bech32 from "bech32";
+import { bech32m } from "../../../../families/bitcoin/bech32m";
 import * as utils from "../../../../families/bitcoin/wallet-btc/utils";
 import { Currency } from "../../../../families/bitcoin/wallet-btc/crypto/types";
+import cryptoFactory from "../../../../families/bitcoin/wallet-btc/crypto/factory";
+import { DerivationModes } from "../../../../families/bitcoin/wallet-btc";
 
 function validateAddrs(
   addresses: string[],
@@ -16,7 +19,8 @@ function toBech32(
   data: Buffer,
   version: number,
   prefix: string,
-  bech32variant: BechLib
+  //bech32variant: BechLib // FIXME Restore this
+  bech32variant: any
 ): string {
   const words = bech32.toWords(data);
   words.unshift(version);
@@ -208,3 +212,106 @@ describe("Unit tests for various utils functions", () => {
     validateAddrs(["S6NMcEfYbavHrP3Uo1wbEUvKhAbKeMugaa"], "stealthcoin", false);
   });
 });
+
+describe("Unit tests for maxTxSize", () => {
+  const btc = cryptoFactory("bitcoin_testnet");
+  it("Empty tx non-segwit", () => {
+    const s = utils.maxTxSizeCeil(0, [], false, btc, DerivationModes.LEGACY);
+    expect(s).toEqual(10);
+  });
+  it("Empty tx segwit", () => {
+    const s = utils.maxTxSizeCeil(
+      0,
+      [],
+      false,
+      btc,
+      DerivationModes.NATIVE_SEGWIT
+    );
+    expect(s).toEqual(11);
+  });
+  it("1 p2wpkh input 1 p2wpkh output", () => {});
+
+  const tr = "tb1pdedptfps5k6hmzars9ks93ejsujh28kw5dhe06gutt9svap40j8qql2dw2";
+  const sh = "2Mv9bnjkBUr1GfCybJc7XmnJ5VG4SAT3shT";
+  const pkh = "mkQiYQGCkCC7Wus3vfhfTDjgJzQK554evn";
+  const wpkh = "tb1qhff3j7euu6t3lv8s5gsy9t5x82wuhfw5z863gj";
+  const p2tr = DerivationModes.TAPROOT;
+  const p2sh = DerivationModes.SEGWIT;
+  const p2pkh = DerivationModes.LEGACY;
+  const p2wpkh = DerivationModes.NATIVE_SEGWIT;
+
+  test.each([
+    // In 148 out 34
+    [0, [], false, p2pkh, 10],
+    [0, [], true, p2pkh, 44],
+    [0, [pkh], false, p2pkh, 44],
+    [0, [pkh], true, p2pkh, 78],
+    [1, [pkh], true, p2pkh, 226],
+    [2, [pkh], true, p2pkh, 374],
+    [1, [wpkh], true, p2pkh, 223],
+    [1, [sh], true, p2pkh, 224],
+    [1, [tr], true, p2pkh, 235],
+
+    // In 68 out 31
+    [0, [], false, p2wpkh, 11],
+    [0, [], true, p2wpkh, 42],
+    [1, [], false, p2wpkh, 79],
+    [1, [], true, p2wpkh, 110],
+    [2, [], true, p2wpkh, 178],
+
+    // In 90 out 32, scriptSig 22
+    [0, [], false, p2sh, 11],
+    [0, [], true, p2sh, 43],
+    [1, [], false, p2sh, 101],
+    [1, [sh], false, p2sh, 133],
+    [2, [sh], false, p2sh, 223],
+
+    // Fixed 10.5 In 57.75 out 43
+    [0, [], false, p2tr, 11],
+    [0, [], true, p2tr, 54],
+    [1, [], true, p2tr, Math.ceil(53.5 + 57.75 * 1)],
+    [2, [], true, p2tr, Math.ceil(53.5 + 57.75 * 2)],
+    [3, [], true, p2tr, Math.ceil(53.5 + 57.75 * 3)],
+
+    // 0xfc=252 inputs
+    [247, [], true, p2tr, Math.ceil(53.5 + 57.75 * 247)],
+    [248, [], true, p2tr, Math.ceil(53.5 + 57.75 * 248)],
+    [249, [], true, p2tr, Math.ceil(53.5 + 57.75 * 249)],
+    [250, [], true, p2tr, Math.ceil(53.5 + 57.75 * 250)],
+    [251, [], true, p2tr, Math.ceil(53.5 + 57.75 * 251)],
+    [252, [], true, p2tr, Math.ceil(53.5 + 57.75 * 252)],
+    // 0xfd=253 inputs will add 2 bytes for >= 0xfd
+    [253, [], true, p2tr, Math.ceil(53.5 + 57.75 * 253 + 2)],
+    [
+      256 * 256 - 1,
+      [],
+      true,
+      p2tr,
+      Math.ceil(53.5 + 57.75 * (256 * 256 - 1) + 2),
+    ],
+    // 0xffff inputs will add 4 bytes
+    [256 * 256, [], true, p2tr, Math.ceil(53.5 + 57.75 * (256 * 256) + 4)],
+
+    // test address with witness version 16 and witness program [0x01, 0x02] => tb1sqypqyuzpgh
+    [
+      2,
+      [tr, sh, pkh, wpkh, "tb1sqypqyuzpgh"],
+      false,
+      p2wpkh,
+      Math.ceil(10.5 + 68 * 2 + 43 + 32 + 34 + 31 + 13),
+    ],
+  ])(
+    "%i, %s, %s, %s => %i",
+    (inputCount, outputAddrs, useChange, derivationMode, exp) => {
+      const s = utils.maxTxSizeCeil(
+        inputCount,
+        outputAddrs,
+        useChange,
+        btc,
+        derivationMode
+      );
+      //const s = utils.estimateTxSize(inputCount, outputAddrs.length + (useChange ? 1 : 0), btc, derivationMode);
+      expect(s).toEqual(exp);
+    }
+  );
+});

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

@@ -57,9 +57,10 @@ describe("testing estimateMaxSpendable", () => {
     expect(maxSpendable.toNumber()).toEqual(
       balance -
         feesPerByte *
-          utils.estimateTxSize(
+          utils.maxTxSizeCeil(
             2,
-            1,
+            [],
+            true,
             account.xpub.crypto,
             account.xpub.derivationMode
           )

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

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

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

@@ -3,7 +3,10 @@ import * as bip39 from "bip39";
 import * as bitcoin from "bitcoinjs-lib";
 import coininfo from "coininfo";
 import BigNumber from "bignumber.js";
-import { DerivationModes } from "../../../../families/bitcoin/wallet-btc/types";
+import {
+  DerivationModes,
+  OutputInfo,
+} from "../../../../families/bitcoin/wallet-btc/types";
 import Xpub from "../../../../families/bitcoin/wallet-btc/xpub";
 import BitcoinLikeExplorer from "../../../../families/bitcoin/wallet-btc/explorer";
 import Crypto from "../../../../families/bitcoin/wallet-btc/crypto/bitcoin";
@@ -42,6 +45,17 @@ describe("testing xpub legacy transactions", () => {
     xpub,
   };
 
+  function outputs(amount: number): OutputInfo[] {
+    return [
+      {
+        address: "mwXTtHo8Yy3aNKUUZLkBDrTcKT9qG9TqLb",
+        isChange: false,
+        script: Buffer.from([]),
+        value: new BigNumber(amount),
+      },
+    ];
+  }
+
   it("merge output strategy should be correct", async () => {
     // Initialize the xpub with 2 txs. So that it has 2 utxo
     dataset.xpub.storage.appendTxs([
@@ -134,17 +148,15 @@ describe("testing xpub legacy transactions", () => {
     );
     let res = await utxoPickingStrategy.selectUnspentUtxosToUse(
       dataset.xpub,
-      new BigNumber(10000),
-      0,
-      1
+      outputs(10000),
+      0
     );
     expect(res.unspentUtxos.length).toEqual(1); // only 1 utxo is enough
     expect(Number(res.unspentUtxos[0].value)).toEqual(300000000); // use cheaper utxo first
     res = await utxoPickingStrategy.selectUnspentUtxosToUse(
       dataset.xpub,
-      new BigNumber(500000000),
-      0,
-      1
+      outputs(500000000),
+      0
     );
     expect(res.unspentUtxos.length).toEqual(2); // need 2 utxo
     expect(
@@ -161,17 +173,15 @@ describe("testing xpub legacy transactions", () => {
     );
     let res = await utxoPickingStrategy.selectUnspentUtxosToUse(
       dataset.xpub,
-      new BigNumber(10000),
-      0,
-      1
+      outputs(10000),
+      0
     );
     expect(res.unspentUtxos.length).toEqual(1); // only 1 utxo is enough
     expect(Number(res.unspentUtxos[0].value)).toEqual(5000000000); // use old utxo first
     res = await utxoPickingStrategy.selectUnspentUtxosToUse(
       dataset.xpub,
-      new BigNumber(5200000000),
-      0,
-      1
+      outputs(5200000000),
+      0
     );
     expect(res.unspentUtxos.length).toEqual(2); // need 2 utxo
     expect(
@@ -323,45 +333,40 @@ describe("testing xpub legacy transactions", () => {
     );
     let res = await utxoPickingStrategy.selectUnspentUtxosToUse(
       dataset.xpub,
-      new BigNumber(10000),
-      10,
-      1
+      outputs(10000),
+      10
     );
     expect(res.unspentUtxos.length).toEqual(1);
     expect(Number(res.unspentUtxos[0].value)).toEqual(100000000);
 
     res = await utxoPickingStrategy.selectUnspentUtxosToUse(
       dataset.xpub,
-      new BigNumber(290000000),
-      10,
-      1
+      outputs(290000000),
+      10
     );
     expect(res.unspentUtxos.length).toEqual(1);
     expect(Number(res.unspentUtxos[0].value)).toEqual(300000000);
 
     res = await utxoPickingStrategy.selectUnspentUtxosToUse(
       dataset.xpub,
-      new BigNumber(500000000),
-      10,
-      1
+      outputs(500000000),
+      10
     );
     expect(res.unspentUtxos.length).toEqual(1);
     expect(Number(res.unspentUtxos[0].value)).toEqual(600000000);
 
     res = await utxoPickingStrategy.selectUnspentUtxosToUse(
       dataset.xpub,
-      new BigNumber(800000000),
-      10,
-      1
+      outputs(800000000),
+      10
     );
     expect(res.unspentUtxos.length).toEqual(1);
     expect(Number(res.unspentUtxos[0].value)).toEqual(5000000000);
 
     res = await utxoPickingStrategy.selectUnspentUtxosToUse(
       dataset.xpub,
-      new BigNumber(5000000000),
-      10,
-      1
+      outputs(5000000000),
+      10
     );
     expect(res.unspentUtxos.length).toEqual(2);
     expect(
@@ -370,9 +375,8 @@ describe("testing xpub legacy transactions", () => {
 
     res = await utxoPickingStrategy.selectUnspentUtxosToUse(
       dataset.xpub,
-      new BigNumber(5600000000),
-      10,
-      1
+      outputs(5600000000),
+      10
     );
     expect(res.unspentUtxos.length).toEqual(3);
     expect(

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

@@ -178,9 +178,10 @@ describe.skip("testing xpub segwit transactions", () => {
     await xpubs[1].xpub.sync();
 
     expectedFee1 =
-      utils.estimateTxSize(
+      utils.maxTxSizeCeil(
         inputs.length,
-        outputs.length,
+        outputs.map((o) => o.address),
+        false,
         crypto,
         DerivationModes.SEGWIT
       ) * 100;

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

@@ -167,9 +167,10 @@ describe.skip("testing xpub native segwit transactions", () => {
     await xpubs[1].xpub.sync();
 
     expectedFee1 =
-      utils.estimateTxSize(
+      utils.maxTxSizeCeil(
         inputs.length,
-        outputs.length,
+        outputs.map((o) => o.address),
+        false,
         crypto,
         DerivationModes.NATIVE_SEGWIT
       ) * 100;

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

@@ -148,9 +148,10 @@ describe.skip("testing xpub legacy transactions", () => {
     }
 
     expectedFee1 =
-      utils.estimateTxSize(
+      utils.maxTxSizeCeil(
         inputs.length,
-        outputs.length,
+        outputs.map((o) => o.address),
+        false,
         crypto,
         DerivationModes.LEGACY
       ) * 100;
@@ -280,9 +281,10 @@ describe.skip("testing xpub legacy transactions", () => {
     await xpubs[1].xpub.sync();
 
     expectedFee2 =
-      utils.estimateTxSize(
+      utils.maxTxSizeCeil(
         inputs.length,
-        outputs.length,
+        outputs.map((o) => o.address),
+        false,
         crypto,
         DerivationModes.LEGACY
       ) * 100;

package/src/account/formatters.ts

@@ -12,6 +12,15 @@ import { formatCurrencyUnit } from "../currencies";
 import { getOperationAmountNumber } from "../operation";
 import { getTagDerivationMode } from "../derivation";
 import byFamily from "../generated/account";
+import { nftsByCollections } from "../nft";
+
+const styling = {
+  bold: (str: string) => `\x1b[1m${str}\x1b[22m`,
+  underline: (str: string) => `\x1b[4m${str}\x1b[24m`,
+  cyan: (str: string) => `\x1b[36m${str}\x1b[37m`,
+  magenta: (str: string) => `\x1b[35m${str}\x1b[37m`,
+  reverse: (str: string) => `\x1b[7m${str}\x1b[27m`,
+};
 
 const isSignificantAccount = (acc) =>
   acc.balance.gt(10 ** (getAccountUnit(acc).magnitude - 6));
@@ -80,6 +89,7 @@ const cliFormat = (account, level?: string) => {
     derivationMode,
     index,
     operations,
+    nfts,
   } = account;
   const tag = getTagDerivationMode(account.currency, derivationMode);
   const balance = formatCurrencyUnit(account.unit, account.balance, {
@@ -122,6 +132,39 @@ const cliFormat = (account, level?: string) => {
         maybeDisplaySumOfOpsIssue(ta.operations, ta.balance, getAccountUnit(ta))
     )
     .join("\n");
+
+  if (nfts?.length) {
+    const NFTCollections = nftsByCollections(nfts);
+
+    str += "\n";
+    str += `NFT Collections (${NFTCollections.length}) `;
+    str += "\n";
+
+    str += NFTCollections.map(
+      // nfts are set to any because there not just NFT, we added a metadata prop on the fly
+      // in the first step of the Rxjs flow to avoid having some async code here
+      ({ contract, nfts }: { contract: string; nfts: any[] }) => {
+        const tokenName = nfts?.[0]?.metadata?.tokenName;
+        const { bold, magenta, cyan, reverse } = styling;
+
+        return (
+          `${bold(tokenName ?? "Unknown Collection Name")} (${magenta(
+            contract
+          )}): ` +
+          nfts
+            .map((t) =>
+              t?.metadata?.nftName
+                ? `\n  ${t.amount}x ${reverse(
+                    ` ${t?.metadata?.nftName} `
+                  )} ${cyan("#" + t.tokenId)}`
+                : `\n  ${t.amount}x ${cyan("#" + t.tokenId)}`
+            )
+            .join()
+        );
+      }
+    ).join("\n");
+  }
+
   if (level === "basic") return str;
   str += "\nOPERATIONS (" + operations.length + ")";
   str += operations

package/src/apps/polyfill.ts

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

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

@@ -2671,6 +2671,7 @@ Array [
   "ethereum/erc20/ethereum_cell_network",
   "ethereum/erc20/ethereum_dark",
   "ethereum/erc20/ethereum_money",
+  "ethereum/erc20/ethereum_name_service",
   "ethereum/erc20/ethereum_pro",
   "ethereum/erc20/ethereum_push_notification_service",
   "ethereum/erc20/ethereum_stake",
@@ -2994,7 +2995,6 @@ Array [
   "ethereum/erc20/golden_goose",
   "ethereum/erc20/golden_ratio_coin",
   "ethereum/erc20/golden_token",
-  "ethereum/erc20/goldenratio",
   "ethereum/erc20/goldenugget_token",
   "ethereum/erc20/golder_coin",
   "ethereum/erc20/goldextoken",
@@ -3018,6 +3018,7 @@ Array [
   "ethereum/erc20/grandpa_fan",
   "ethereum/erc20/grap",
   "ethereum/erc20/grapefruit",
+  "ethereum/erc20/graph_token",
   "ethereum/erc20/graphlinq",
   "ethereum/erc20/graviton",
   "ethereum/erc20/grearn's_token",
@@ -3889,6 +3890,7 @@ Array [
   "ethereum/erc20/par_stablecoin",
   "ethereum/erc20/paralink_network",
   "ethereum/erc20/parallelchain_token",
+  "ethereum/erc20/paraswap",
   "ethereum/erc20/pareto",
   "ethereum/erc20/paribus",
   "ethereum/erc20/parsec_finance",

package/src/currencies/support.ts

@@ -9,6 +9,7 @@ import {
   hasCryptoCurrencyId,
 } from "@ledgerhq/cryptoassets";
 import { getEnv } from "../env";
+
 // set by user side effect to precise which currencies are considered supported (typically by live)
 let userSupportedCurrencies: CryptoCurrency[] = [];
 let userSupportedFiats: FiatCurrency[] = [];

package/src/families/bitcoin/bech32m.ts

@@ -0,0 +1,197 @@
+// Ported from https://github.com/bitcoinjs/bech32/tree/605655d6b37a782345549cd1388db688a96ad56f
+// until we can use bech32 2.0.0
+// We can't directly use bech32 2.0.0 because many of our dependencies are still using bech32 ^1.1.3
+// which conflict on mobile (root cause of https://ledgerhq.atlassian.net/browse/LL-7930)
+// FIXME Remove that file and use bech32 2.0.0 when all dependencies also uses it.
+
+const ENCODING_CONST = 0x2bc830a3;
+const ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+const ALPHABET_MAP: { [key: string]: number } = {};
+for (let z = 0; z < ALPHABET.length; z++) {
+  const x = ALPHABET.charAt(z);
+  ALPHABET_MAP[x] = z;
+}
+
+function prefixChk(prefix) {
+  let chk = 1;
+  for (let i = 0; i < prefix.length; ++i) {
+    const c = prefix.charCodeAt(i);
+    if (c < 33 || c > 126) return "Invalid prefix (" + prefix + ")";
+    chk = polymodStep(chk) ^ (c >> 5);
+  }
+  chk = polymodStep(chk);
+  for (let i = 0; i < prefix.length; ++i) {
+    const v = prefix.charCodeAt(i);
+    chk = polymodStep(chk) ^ (v & 0x1f);
+  }
+  return chk;
+}
+
+function polymodStep(pre: number): number {
+  const b = pre >> 25;
+  return (
+    ((pre & 0x1ffffff) << 5) ^
+    (-((b >> 0) & 1) & 0x3b6a57b2) ^
+    (-((b >> 1) & 1) & 0x26508e6d) ^
+    (-((b >> 2) & 1) & 0x1ea119fa) ^
+    (-((b >> 3) & 1) & 0x3d4233dd) ^
+    (-((b >> 4) & 1) & 0x2a1462b3)
+  );
+}
+
+function encode(
+  prefix: string,
+  words: ArrayLike<number>,
+  LIMIT?: number
+): string {
+  LIMIT = LIMIT || 90;
+  if (prefix.length + 7 + words.length > LIMIT)
+    throw new TypeError("Exceeds length limit");
+
+  prefix = prefix.toLowerCase();
+
+  // determine chk mod
+  let chk = prefixChk(prefix);
+  if (typeof chk === "string") throw new Error(chk);
+
+  let result = prefix + "1";
+  for (let i = 0; i < words.length; ++i) {
+    const x = words[i];
+    if (x >> 5 !== 0) throw new Error("Non 5-bit word");
+
+    chk = polymodStep(chk) ^ x;
+    result += ALPHABET.charAt(x);
+  }
+
+  for (let i = 0; i < 6; ++i) {
+    chk = polymodStep(chk);
+  }
+  chk ^= ENCODING_CONST;
+
+  for (let i = 0; i < 6; ++i) {
+    const v = (chk >> ((5 - i) * 5)) & 0x1f;
+    result += ALPHABET.charAt(v);
+  }
+
+  return result;
+}
+
+function __decode(str: string, LIMIT?: number) {
+  LIMIT = LIMIT || 90;
+  if (str.length < 8) return str + " too short";
+  if (str.length > LIMIT) return "Exceeds length limit";
+
+  // don't allow mixed case
+  const lowered = str.toLowerCase();
+  const uppered = str.toUpperCase();
+  if (str !== lowered && str !== uppered) return "Mixed-case string " + str;
+  str = lowered;
+
+  const split = str.lastIndexOf("1");
+  if (split === -1) return "No separator character for " + str;
+  if (split === 0) return "Missing prefix for " + str;
+
+  const prefix = str.slice(0, split);
+  const wordChars = str.slice(split + 1);
+  if (wordChars.length < 6) return "Data too short";
+
+  let chk = prefixChk(prefix);
+  if (typeof chk === "string") return chk;
+
+  const words: number[] = [];
+  for (let i = 0; i < wordChars.length; ++i) {
+    const c = wordChars.charAt(i);
+    const v = ALPHABET_MAP[c];
+    if (v === undefined) return "Unknown character " + c;
+    chk = polymodStep(chk) ^ v;
+
+    // not in the checksum?
+    if (i + 6 >= wordChars.length) continue;
+    words.push(v);
+  }
+
+  if (chk !== ENCODING_CONST) return "Invalid checksum for " + str;
+  return { prefix, words };
+}
+
+function decodeUnsafe(str: string, LIMIT?: number) {
+  const res = __decode(str, LIMIT);
+  if (typeof res === "object") return res;
+}
+
+function decode(str: string, LIMIT?: number) {
+  const res = __decode(str, LIMIT);
+  if (typeof res === "object") return res;
+
+  throw new Error(res);
+}
+
+function convert(
+  data: ArrayLike<number>,
+  inBits: number,
+  outBits: number,
+  pad: true
+): number[];
+function convert(
+  data: ArrayLike<number>,
+  inBits: number,
+  outBits: number,
+  pad: false
+): number[] | string;
+function convert(
+  data: ArrayLike<number>,
+  inBits: number,
+  outBits: number,
+  pad: boolean
+): number[] | string {
+  let value = 0;
+  let bits = 0;
+  const maxV = (1 << outBits) - 1;
+
+  const result: number[] = [];
+  for (let i = 0; i < data.length; ++i) {
+    value = (value << inBits) | data[i];
+    bits += inBits;
+
+    while (bits >= outBits) {
+      bits -= outBits;
+      result.push((value >> bits) & maxV);
+    }
+  }
+
+  if (pad) {
+    if (bits > 0) {
+      result.push((value << (outBits - bits)) & maxV);
+    }
+  } else {
+    if (bits >= inBits) return "Excess padding";
+    if ((value << (outBits - bits)) & maxV) return "Non-zero padding";
+  }
+
+  return result;
+}
+
+function toWords(bytes: ArrayLike<number>): number[] {
+  return convert(bytes, 8, 5, true);
+}
+
+function fromWordsUnsafe(words: ArrayLike<number>): number[] | undefined {
+  const res = convert(words, 5, 8, false);
+  if (Array.isArray(res)) return res;
+}
+
+function fromWords(words: ArrayLike<number>): number[] {
+  const res = convert(words, 5, 8, false);
+  if (Array.isArray(res)) return res;
+
+  throw new Error(res);
+}
+
+export const bech32m = {
+  decodeUnsafe,
+  decode,
+  encode,
+  toWords,
+  fromWordsUnsafe,
+  fromWords,
+};

package/src/families/bitcoin/datasets/bitcoin.ts

@@ -28,6 +28,10 @@ const networkInfo: NetworkInfoRaw = {
   },
 };
 const dataset: CurrenciesData<Transaction> = {
+  FIXME_ignoreAccountFields: [
+    "bitcoinResources.walletAccount", // it is not "stable"
+    "bitcoinResources.utxos", // TODO: fix ordering
+  ],
   scanAccounts: [scanAccounts1],
   accounts: [
     {