@ledgerhq/live-common 21.22.0 → 21.24.0

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

@@ -1,13 +1,15 @@
 // from https://github.com/LedgerHQ/xpub-scan/blob/master/src/actions/deriveAddresses.ts
 
 import * as bjs from "bitcoinjs-lib";
-import * as bip32 from "bip32";
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import { toOutputScript } from "bitcoinjs-lib/src/address";
 import bs58check from "bs58check";
 import { DerivationModes } from "../types";
 import { ICrypto } from "./types";
+import bs58 from "bs58";
+import bech32 from "bech32";
+import BIP32 from "./bip32";
 
 export function fallbackValidateAddress(address: string): boolean {
   try {
@@ -41,7 +43,18 @@ class Base implements ICrypto {
 
   protected getPubkeyAt(xpub: string, account: number, index: number): Buffer {
     if (!Base.bech32Cache[xpub]) {
-      Base.bech32Cache[xpub] = bip32.fromBase58(xpub, this.network);
+      const buffer: Buffer = bs58.decode(xpub);
+      const depth: number = buffer[4];
+      const i: number = buffer.readUInt32BE(9);
+      const chainCode: Buffer = buffer.slice(13, 45);
+      const publicKey: Buffer = buffer.slice(45, 78);
+      Base.bech32Cache[xpub] = new BIP32(
+        publicKey,
+        chainCode,
+        this.network,
+        depth,
+        i
+      );
     }
     if (Base.publickeyCache[`${xpub}-${account}-${index}`]) {
       return Base.publickeyCache[`${xpub}-${account}-${index}`];
@@ -62,33 +75,32 @@ class Base implements ICrypto {
 
   // derive legacy address at account and index positions
   getLegacyAddress(xpub: string, account: number, index: number): string {
-    const { address } = bjs.payments.p2pkh({
-      pubkey: this.getPubkeyAt(xpub, account, index),
-      network: this.network,
-    });
-
-    return String(address);
+    const publicKeyBuffer: Buffer = this.getPubkeyAt(xpub, account, index);
+    const publicKeyHash160: Buffer = bjs.crypto.hash160(publicKeyBuffer);
+    return bjs.address.toBase58Check(publicKeyHash160, this.network.pubKeyHash);
   }
 
   // derive native SegWit at account and index positions
   getNativeSegWitAddress(xpub: string, account: number, index: number): string {
-    const { address } = bjs.payments.p2wpkh({
-      pubkey: this.getPubkeyAt(xpub, account, index),
-      network: this.network,
-    });
-
-    return String(address);
+    const publicKeyBuffer: Buffer = this.getPubkeyAt(xpub, account, index);
+    const publicKeyHash160: Buffer = bjs.crypto.hash160(publicKeyBuffer);
+    const words: number[] = bech32.toWords(publicKeyHash160);
+    words.unshift(0x00);
+    return bech32.encode(this.network.bech32, words);
   }
 
   // derive SegWit at account and index positions
   getSegWitAddress(xpub: string, account: number, index: number): string {
-    const { address } = bjs.payments.p2sh({
-      redeem: bjs.payments.p2wpkh({
-        pubkey: this.getPubkeyAt(xpub, account, index),
-        network: this.network,
-      }),
-    });
-    return String(address);
+    const publicKeyBuffer: Buffer = this.getPubkeyAt(xpub, account, index);
+    const redeemOutput: Buffer = bjs.script.compile([
+      0,
+      bjs.crypto.hash160(publicKeyBuffer),
+    ]);
+    const publicKeyHash160: Buffer = bjs.crypto.hash160(redeemOutput);
+    const payload: Buffer = Buffer.allocUnsafe(21);
+    payload.writeUInt8(this.network.scriptHash, 0);
+    publicKeyHash160.copy(payload, 1);
+    return bs58check.encode(payload);
   }
 
   // get address given an address type

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

@@ -0,0 +1,36 @@
+import ecc from "tiny-secp256k1";
+import createHmac from "create-hmac";
+
+// the BIP32 class is inspired from https://github.com/bitcoinjs/bip32/blob/master/src/bip32.js
+class BIP32 {
+  publicKey: any;
+  chainCode: any;
+  network: any;
+  depth: number;
+  index: number;
+  constructor(
+    publicKey: any,
+    chainCode: any,
+    network: any,
+    depth = 0,
+    index = 0
+  ) {
+    this.publicKey = publicKey;
+    this.chainCode = chainCode;
+    this.network = network;
+    this.depth = depth;
+    this.index = index;
+  }
+  derive(index: number) {
+    const data = Buffer.allocUnsafe(37);
+    this.publicKey.copy(data, 0);
+    data.writeUInt32BE(index, 33);
+    const I = createHmac("sha512", this.chainCode).update(data).digest();
+    const IL = I.slice(0, 32);
+    const IR = I.slice(32);
+    const Ki = ecc.pointAddScalar(this.publicKey, IL, true);
+    return new BIP32(Ki, IR, this.network, this.depth + 1, index);
+  }
+}
+
+export default BIP32;

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

@@ -6,150 +6,7 @@ import bs58check from "bs58check";
 import createBlakeHash from "blake-hash";
 import RIPEMD160 from "ripemd160";
 import bs58 from "bs58";
-import ecc from "tiny-secp256k1";
-import createHash from "create-hash";
-import createHmac from "create-hmac";
-
-// the BIP32 class is inspired from https://github.com/bitcoinjs/bip32/blob/master/src/bip32.js
-class BIP32 {
-  privateKey: any;
-  publicKey: any;
-  chainCode: any;
-  network: any;
-  depth: number;
-  index: number;
-  ParentFingerprint: number;
-  lowR: boolean;
-  constructor(
-    privateKey,
-    publicKey,
-    chainCode,
-    network,
-    depth = 0,
-    index = 0,
-    ParentFingerprint = 0x00000000
-  ) {
-    this.privateKey = privateKey;
-    this.publicKey = publicKey;
-    this.chainCode = chainCode;
-    this.network = network;
-    this.depth = depth;
-    this.index = index;
-    this.ParentFingerprint = ParentFingerprint;
-    this.lowR = false;
-  }
-  pk() {
-    if (this.publicKey === undefined)
-      this.publicKey = ecc.pointFromScalar(this.privateKey, true);
-    return this.publicKey;
-  }
-  isNeutered() {
-    return this.privateKey === undefined;
-  }
-  neutered() {
-    return new BIP32(
-      undefined,
-      this.pk(),
-      this.chainCode,
-      this.network,
-      this.depth,
-      this.index,
-      this.ParentFingerprint
-    );
-  }
-  hmacSHA512(key, data) {
-    return createHmac("sha512", key).update(data).digest();
-  }
-  hash160(buffer) {
-    const sha256Hash = createHash("sha256").update(buffer).digest();
-    return createHash("rmd160").update(sha256Hash).digest();
-  }
-  fingerprint() {
-    return this.hash160(this.pk()).slice(0, 4);
-  }
-
-  toBase58() {
-    const network = this.network;
-    const version = !this.isNeutered()
-      ? network.bip32.private
-      : network.bip32.public;
-    const buffer = Buffer.allocUnsafe(78);
-    // 4 bytes: version bytes
-    buffer.writeUInt32BE(version, 0);
-    // 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ....
-    buffer.writeUInt8(this.depth, 4);
-    // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
-    buffer.writeUInt32BE(this.ParentFingerprint, 5);
-    // 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
-    // This is encoded in big endian. (0x00000000 if master key)
-    buffer.writeUInt32BE(this.index, 9);
-    // 32 bytes: the chain code
-    this.chainCode.copy(buffer, 13);
-    // 33 bytes: the public key or private key data
-    if (!this.isNeutered()) {
-      // 0x00 + k for private keys
-      buffer.writeUInt8(0, 45);
-      this.privateKey.copy(buffer, 46);
-      // 33 bytes: the public key
-    } else {
-      // X9.62 encoding for public keys
-      this.pk().copy(buffer, 45);
-    }
-    return bs58check.encode(buffer);
-  }
-  // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions
-  derive(index) {
-    const isHardened = index >= 0x80000000;
-    const data = Buffer.allocUnsafe(37);
-    // Hardened child
-    if (isHardened) {
-      data[0] = 0x00;
-      this.privateKey.copy(data, 1);
-      data.writeUInt32BE(index, 33);
-    } else {
-      this.pk().copy(data, 0);
-      data.writeUInt32BE(index, 33);
-    }
-    const I = this.hmacSHA512(this.chainCode, data);
-    const IL = I.slice(0, 32);
-    const IR = I.slice(32);
-    // if parse256(IL) >= n, proceed with the next value for i
-    if (!ecc.isPrivate(IL)) return this.derive(index + 1);
-    // Private parent key -> private child key
-    let hd;
-    if (!this.isNeutered()) {
-      // ki = parse256(IL) + kpar (mod n)
-      const ki = ecc.privateAdd(this.privateKey, IL);
-      // In case ki == 0, proceed with the next value for i
-      if (ki == null) return this.derive(index + 1);
-      hd = new BIP32(
-        ki,
-        undefined,
-        IR,
-        this.network,
-        this.depth + 1,
-        index,
-        this.fingerprint().readUInt32BE(0)
-      );
-    } else {
-      // Ki = point(parse256(IL)) + Kpar
-      //    = G*IL + Kpar
-      const Ki = ecc.pointAddScalar(this.pk(), IL, true);
-      // In case Ki is the point at infinity, proceed with the next value for i
-      if (Ki === null) return this.derive(index + 1);
-      hd = new BIP32(
-        undefined,
-        Ki,
-        IR,
-        this.network,
-        this.depth + 1,
-        index,
-        this.fingerprint().readUInt32BE(0)
-      );
-    }
-    return hd;
-  }
-}
+import BIP32 from "./bip32";
 
 class Decred extends Base {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -227,20 +84,11 @@ class Decred extends Base {
       buffer = bs58check.decode(xpub);
     }
     const depth = buffer[4];
-    const parentFingerprint = buffer.readUInt32BE(5);
     const i = buffer.readUInt32BE(9);
     const chainCode = buffer.slice(13, 45);
     const X = buffer.slice(45, 78);
-    const hd = new BIP32(
-      undefined,
-      X,
-      chainCode,
-      this.network,
-      depth,
-      i,
-      parentFingerprint
-    );
-    const publicKey = hd.derive(account).derive(index).pk();
+    const hd = new BIP32(X, chainCode, this.network, depth, i);
+    const publicKey = hd.derive(account).derive(index).publicKey;
     const address = Decred.getAddressFromPk(publicKey);
     Base.addressCache[`${derivationMode}-${xpub}-${account}-${index}`] =
       address;

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

@@ -1,4 +1,5 @@
 import { findLast, filter, uniqBy, findIndex, has } from "lodash";
+import Base from "../crypto/base";
 import { Input, IStorage, Output, TX, Address } from "./types";
 
 // a mock storage class that just use js objects
@@ -12,12 +13,14 @@ class BitcoinLikeStorage implements IStorage {
   // accounting
   unspentUtxos: { [key: string]: Output[] } = {};
 
+  addressCache: { [key: string]: string } = {};
+
   // only needed to handle the case when the input
   // is seen before the output (typically explorer
   // returning unordered tx within the same block)
   spentUtxos: { [key: string]: Input[] } = {};
 
-  async getLastTx(txFilter: {
+  getLastTx(txFilter: {
     account?: number;
     index?: number;
     address?: string;
@@ -38,18 +41,18 @@ class BitcoinLikeStorage implements IStorage {
     return tx;
   }
 
-  async getTx(address: string, hash: string) {
+  getTx(address: string, hash: string) {
     const index = `${address}-${hash}`;
     return this.txs[this.primaryIndex[index]];
   }
 
   // TODO: only expose unspentUtxos
-  async getAddressUnspentUtxos(address: Address) {
+  getAddressUnspentUtxos(address: Address) {
     const indexAddress = address.address;
     return this.unspentUtxos[indexAddress];
   }
 
-  async appendTxs(txs: TX[]) {
+  appendTxs(txs: TX[]) {
     const lastLength = this.txs.length;
 
     txs.forEach((tx) => {
@@ -97,10 +100,7 @@ class BitcoinLikeStorage implements IStorage {
     return this.txs.length - lastLength;
   }
 
-  async getUniquesAddresses(addressesFilter: {
-    account?: number;
-    index?: number;
-  }) {
+  getUniquesAddresses(addressesFilter: { account?: number; index?: number }) {
     // TODO: to speed up, create more useful indexes in appendTxs
     return uniqBy(
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -114,7 +114,7 @@ class BitcoinLikeStorage implements IStorage {
     );
   }
 
-  async removeTxs(txsFilter: { account: number; index: number }) {
+  removeTxs(txsFilter: { account: number; index: number }) {
     const newTxs: TX[] = [];
     this.primaryIndex = {};
 
@@ -137,7 +137,7 @@ class BitcoinLikeStorage implements IStorage {
 
   // We are a bit ugly because we can't rely undo unspentUTXO
   // So we clean the address and rebuild without the pendings
-  async removePendingTxs(txsFilter: { account: number; index: number }) {
+  removePendingTxs(txsFilter: { account: number; index: number }) {
     const newTxs: TX[] = [];
     const txsToReAdd: TX[] = [];
     this.primaryIndex = {};
@@ -161,7 +161,14 @@ class BitcoinLikeStorage implements IStorage {
     });
 
     this.txs = newTxs;
-    await this.appendTxs(txsToReAdd);
+    this.appendTxs(txsToReAdd);
+  }
+
+  addAddress(key: string, address: string): void {
+    if (!this.addressCache) {
+      this.addressCache = {};
+    }
+    this.addressCache[key] = address;
   }
 
   exportSync() {
@@ -169,6 +176,7 @@ class BitcoinLikeStorage implements IStorage {
       txs: this.txs,
       primaryIndex: this.primaryIndex,
       unspentUtxos: this.unspentUtxos,
+      addressCache: this.addressCache,
     };
   }
 
@@ -176,10 +184,13 @@ class BitcoinLikeStorage implements IStorage {
     txs: TX[];
     primaryIndex: { [key: string]: number };
     unspentUtxos: { [key: string]: Output[] };
+    addressCache: { [key: string]: string };
   }) {
     this.txs = data.txs;
     this.primaryIndex = data.primaryIndex;
     this.unspentUtxos = data.unspentUtxos;
+    this.addressCache = data.addressCache;
+    Base.addressCache = { ...Base.addressCache, ...this.addressCache };
   }
 
   async export() {
@@ -190,6 +201,7 @@ class BitcoinLikeStorage implements IStorage {
     txs: TX[];
     primaryIndex: { [key: string]: number };
     unspentUtxos: { [key: string]: Output[] };
+    addressCache: { [key: string]: string };
   }) {
     return this.loadSync(data);
   }

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

@@ -43,24 +43,22 @@ export interface Address {
 }
 
 export interface IStorage {
-  appendTxs(txs: TX[]): Promise<number>;
-  getAddressUnspentUtxos(address: Address): Promise<Output[]>;
+  appendTxs(txs: TX[]): number;
+  getAddressUnspentUtxos(address: Address): Output[];
   getLastTx(txFilter: {
     account?: number;
     index?: number;
     address?: string;
     confirmed?: boolean;
-  }): Promise<TX | undefined>;
-  getTx(address: string, hash: string): Promise<TX | undefined>;
+  }): TX | undefined;
+  getTx(address: string, hash: string): TX | undefined;
   getUniquesAddresses(addressesFilter: {
     account?: number;
     index?: number;
-  }): Promise<Address[]>;
-  removeTxs(txsFilter: { account: number; index: number }): Promise<void>;
-  removePendingTxs(txsFilter: {
-    account: number;
-    index: number;
-  }): Promise<void>;
+  }): Address[];
+  removeTxs(txsFilter: { account: number; index: number }): void;
+  removePendingTxs(txsFilter: { account: number; index: number }): void;
+  addAddress(key: string, address: string): void;
   export(): Promise<unknown>;
   load(data: unknown): Promise<void>;
   exportSync(): unknown;

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

@@ -66,6 +66,10 @@ class Xpub extends EventEmitter {
       index
     );
 
+    this.storage.addAddress(
+      `${this.derivationMode}-${this.xpub}-${account}-${index}`,
+      address
+    );
     await this.whenSynced("address", address);
 
     const data = {
@@ -87,13 +91,13 @@ class Xpub extends EventEmitter {
 
       // in case pendings have changed we clean them out
       // TODO perf : bad : looping in the tx array
-      const hasPendings = !!(await this.storage.getLastTx({
+      const hasPendings = !!this.storage.getLastTx({
         confirmed: false,
         account,
         index,
-      }));
+      });
       if (hasPendings) {
-        await this.storage.removePendingTxs({ account, index });
+        this.storage.removePendingTxs({ account, index });
       }
       total = await this.fetchHydrateAndStoreNewTxs(address, account, index);
     } catch (e) {
@@ -103,7 +107,7 @@ class Xpub extends EventEmitter {
 
     this.emitSynced({ ...data, total });
 
-    const lastTx = await this.storage.getLastTx({
+    const lastTx = this.storage.getLastTx({
       account,
       index,
     });
@@ -200,7 +204,7 @@ class Xpub extends EventEmitter {
   async getAddressBalance(address: Address) {
     await this.whenSynced("address", address.address);
 
-    const unspentUtxos = await this.storage.getAddressUnspentUtxos(address);
+    const unspentUtxos = this.storage.getAddressUnspentUtxos(address);
 
     return unspentUtxos.reduce(
       (total, { value }) => total.plus(value),
@@ -419,7 +423,7 @@ class Xpub extends EventEmitter {
     let txs: TX[] = [];
     let inserted = 0;
     do {
-      const lastTx = await this.storage.getLastTx({
+      const lastTx = this.storage.getLastTx({
         account,
         index,
         confirmed: true,
@@ -433,14 +437,14 @@ class Xpub extends EventEmitter {
       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
+      inserted += 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);
+    inserted += this.storage.appendTxs(pendingTxs);
     return inserted;
   }
 
   async checkAddressReorg(account: number, index: number) {
-    const lastTx = await this.storage.getLastTx({
+    const lastTx = this.storage.getLastTx({
       account,
       index,
       confirmed: true,
@@ -462,7 +466,7 @@ class Xpub extends EventEmitter {
     // TODO: delete only everything for this (address, block)
     // but need to think if its possible with current storage implem
 
-    await this.storage.removeTxs({
+    this.storage.removeTxs({
       account,
       index,
     });

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

@@ -109,7 +109,11 @@ const getTransactionStatus = async (
           .lt(thresholdWarning)
       ) {
         if (isAccountDelegating(account)) {
-          warnings.amount = new RecommendUndelegation();
+          if (t.useAllAmount) {
+            errors.amount = new RecommendUndelegation();
+          } else {
+            warnings.amount = new RecommendUndelegation();
+          }
         }
       }
     }
@@ -178,11 +182,14 @@ const prepareTransaction = async (
     },
   });
 
+  const t: Transaction = { ...transaction, taquitoError: null };
+
+  let amount = transaction.amount;
   if (transaction.useAllAmount) {
     // taquito does not accept 0, so we do 1
     // only failing case is when the account precisely has fees + 1. which is
     // unlikely
-    transaction.amount = new BigNumber(1);
+    amount = new BigNumber(1);
   }
 
   try {
@@ -192,7 +199,7 @@ const prepareTransaction = async (
         out = await tezos.estimate.transfer({
           mutez: true,
           to: transaction.recipient,
-          amount: transaction.amount.toNumber(),
+          amount: amount.toNumber(),
         });
         break;
       case "delegate":
@@ -210,7 +217,7 @@ const prepareTransaction = async (
         throw new Error("unsupported mode=" + transaction.mode);
     }
 
-    if (transaction.useAllAmount) {
+    if (t.useAllAmount) {
       const totalFees = out.suggestedFeeMutez + out.burnFeeMutez;
       const maxAmount = account.balance
         .minus(totalFees + (tezosResources.revealed ? 0 : DEFAULT_FEE.REVEAL))
@@ -224,41 +231,59 @@ const prepareTransaction = async (
         return gasBuffer * MINIMAL_FEE_PER_GAS_MUTEZ + opSize;
       };
       const incr = increasedFee(gasBuffer, Number(out.opSize));
-      transaction.fees = new BigNumber(out.suggestedFeeMutez + incr);
-      transaction.gasLimit = new BigNumber(out.gasLimit + gasBuffer);
-      transaction.amount = new BigNumber(maxAmount - incr);
+      t.fees = new BigNumber(out.suggestedFeeMutez + incr);
+      t.gasLimit = new BigNumber(out.gasLimit + gasBuffer);
+      t.amount = new BigNumber(maxAmount - incr);
     } else {
-      transaction.fees = new BigNumber(out.suggestedFeeMutez);
-      transaction.gasLimit = new BigNumber(out.gasLimit);
-      transaction.storageLimit = new BigNumber(out.storageLimit);
+      t.fees = new BigNumber(out.suggestedFeeMutez);
+      t.gasLimit = new BigNumber(out.gasLimit);
+      t.storageLimit = new BigNumber(out.storageLimit);
     }
 
-    transaction.storageLimit = new BigNumber(out.storageLimit);
-    transaction.estimatedFees = transaction.fees;
+    t.storageLimit = new BigNumber(out.storageLimit);
+    t.estimatedFees = t.fees;
     if (!tezosResources.revealed) {
-      transaction.estimatedFees = transaction.estimatedFees.plus(
-        DEFAULT_FEE.REVEAL
-      );
+      t.estimatedFees = t.estimatedFees.plus(DEFAULT_FEE.REVEAL);
     }
   } catch (e) {
     if (typeof e !== "object" || !e) throw e;
     if ("id" in e) {
-      transaction.taquitoError = (e as { id: string }).id;
+      t.taquitoError = (e as { id: string }).id;
     } else if ("status" in e) {
       // in case of http 400, log & ignore (more case to handle)
       log(
         "taquito-network-error",
         String((e as { message: string }).message || ""),
-        { transaction }
+        { transaction: t }
       );
     } else {
       throw e;
     }
   }
 
-  return transaction;
+  // nothing changed
+  if (
+    bnEq(t.fees, transaction.fees) &&
+    bnEq(t.fees, transaction.fees) &&
+    bnEq(t.gasLimit, transaction.gasLimit) &&
+    bnEq(t.amount, transaction.amount) &&
+    bnEq(t.storageLimit, transaction.storageLimit) &&
+    bnEq(t.estimatedFees, transaction.estimatedFees) &&
+    t.taquitoError === transaction.taquitoError
+  ) {
+    return transaction;
+  }
+
+  return t;
 };
 
+function bnEq(
+  a: BigNumber | null | undefined,
+  b: BigNumber | null | undefined
+): boolean {
+  return !a && !b ? true : !a || !b ? false : a.eq(b);
+}
+
 const estimateMaxSpendable = async ({
   account,
   parentAccount,

package/src/families/tezos/signOperation.ts

@@ -8,6 +8,8 @@ import type { Account, SignOperationEvent } from "../../types";
 import { withDevice } from "../../hw/deviceAccess";
 import { getEnv } from "../../env";
 import { FeeNotLoaded } from "@ledgerhq/errors";
+import { upperModulo } from "../../modulo";
+import BigNumber from "bignumber.js";
 
 export const signOperation = ({
   account,
@@ -53,6 +55,16 @@ export const signOperation = ({
           storageLimit: transaction.storageLimit?.toNumber() || 0,
           gasLimit: transaction.gasLimit?.toNumber() || 0,
         };
+
+        if (["delegate", "undelegate"].includes(transaction.mode)) {
+          // https://ledgerhq.atlassian.net/browse/LL-8821
+          params.gasLimit = upperModulo(
+            transaction.gasLimit || new BigNumber(0),
+            new BigNumber(136),
+            new BigNumber(1000)
+          ).toNumber();
+        }
+
         switch (transaction.mode) {
           case "send":
             res = await tezos.contract.transfer({

package/src/families/tezos/synchronisation.ts

@@ -226,7 +226,7 @@ const txToOp =
     }
 
     return {
-      id: encodeOperationId(accountId, hash, type),
+      id: encodeOperationId(accountId, hash + String(tx.id), type),
       hash,
       type,
       value,