@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

package/src/families/cosmos/datasets/__snapshots__/desmos.integration.test.ts.snap

@@ -10,7 +10,6 @@ exports[`desmos currency bridge scanAccounts desmos seed 1 1`] = `
     "freshAddressPath": "44'/118'/0'/0/0",
     "id": "js:2:desmos:desmos1gyauvl44q2apn3u3aujm36q8zrj74vrypqn8c3:",
     "index": 0,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "6748191",
@@ -27,7 +26,6 @@ exports[`desmos currency bridge scanAccounts desmos seed 1 1`] = `
     "freshAddressPath": "44'/118'/1'/0/0",
     "id": "js:2:desmos:desmos1v2mp0m7k96dm9qv60fkspcqlzpkzrwneka7amk:",
     "index": 1,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "0",

package/src/families/cosmos/datasets/__snapshots__/injective.integration.test.ts.snap

@@ -10,7 +10,6 @@ exports[`injective currency bridge scanAccounts injective seed 1 1`] = `
     "freshAddressPath": "44'/60'/0'/0/0",
     "id": "js:2:injective:inj1hn46zvx43mxq47vsecvw84k5chjhuhwp6d62dt:",
     "index": 0,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03f8e9b05b4de510b0b7d970060eac6a0f76d3c4eb07e11418c0747bc593c91c7d",
     "spendableBalance": "506664000000016",
@@ -27,7 +26,6 @@ exports[`injective currency bridge scanAccounts injective seed 1 1`] = `
     "freshAddressPath": "44'/60'/1'/0/0",
     "id": "js:2:injective:inj1604wce9t0u8vne0zrj4t2rspjsg28dymyljzrm:",
     "index": 1,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03f8e9b05b4de510b0b7d970060eac6a0f76d3c4eb07e11418c0747bc593c91c7d",
     "spendableBalance": "0",

package/src/families/cosmos/datasets/__snapshots__/onomy.integration.test.ts.snap

@@ -10,7 +10,6 @@ exports[`onomy currency bridge scanAccounts onomy seed 1 1`] = `
     "freshAddressPath": "44'/118'/0'/0/0",
     "id": "js:2:onomy:onomy1gyauvl44q2apn3u3aujm36q8zrj74vry0e2p7v:",
     "index": 0,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "2056240423338275653",
@@ -27,7 +26,6 @@ exports[`onomy currency bridge scanAccounts onomy seed 1 1`] = `
     "freshAddressPath": "44'/118'/1'/0/0",
     "id": "js:2:onomy:onomy1v2mp0m7k96dm9qv60fkspcqlzpkzrwnecy8mat:",
     "index": 1,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "0",

package/src/families/cosmos/datasets/__snapshots__/osmosis.integration.test.ts.snap

@@ -10,7 +10,6 @@ exports[`osmo currency bridge scanAccounts osmo seed 1 1`] = `
     "freshAddressPath": "44'/118'/0'/0/0",
     "id": "js:2:osmo:osmo17gmcxyc5ccd5kwqqatpgfdgh380w2hc77zm0zw:",
     "index": 0,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "02dc75cfe8137450ae2259dc7f29fd8767951956cc943adb4387e91c37a058a9f0",
     "spendableBalance": "124344",
@@ -27,7 +26,6 @@ exports[`osmo currency bridge scanAccounts osmo seed 1 1`] = `
     "freshAddressPath": "44'/118'/1'/0/0",
     "id": "js:2:osmo:osmo19h8cennrkf09sjxqt36lmk93fzyrcwrfxw784y:",
     "index": 1,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "02dc75cfe8137450ae2259dc7f29fd8767951956cc943adb4387e91c37a058a9f0",
     "spendableBalance": "0",

package/src/families/cosmos/datasets/__snapshots__/persistence.integration.test.ts.snap

@@ -10,7 +10,6 @@ exports[`persistence currency bridge scanAccounts persistence seed 1 1`] = `
     "freshAddressPath": "44'/118'/0'/0/0",
     "id": "js:2:persistence:persistence1gyauvl44q2apn3u3aujm36q8zrj74vrym5cypd:",
     "index": 0,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "1202564",
@@ -27,7 +26,6 @@ exports[`persistence currency bridge scanAccounts persistence seed 1 1`] = `
     "freshAddressPath": "44'/118'/1'/0/0",
     "id": "js:2:persistence:persistence1v2mp0m7k96dm9qv60fkspcqlzpkzrwnevf47z2:",
     "index": 1,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "230000",
@@ -44,7 +42,6 @@ exports[`persistence currency bridge scanAccounts persistence seed 1 1`] = `
     "freshAddressPath": "44'/118'/2'/0/0",
     "id": "js:2:persistence:persistence17r56udl09ssv88x85cxftx7su0rgv4v27ej3p0:",
     "index": 2,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "0",

package/src/families/cosmos/datasets/__snapshots__/quicksilver.integration.test.ts.snap

@@ -10,7 +10,6 @@ exports[`quicksilver currency bridge scanAccounts quicksilver seed 1 1`] = `
     "freshAddressPath": "44'/118'/0'/0/0",
     "id": "js:2:quicksilver:quick1gyauvl44q2apn3u3aujm36q8zrj74vry7uw9km:",
     "index": 0,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "2273041",
@@ -27,7 +26,6 @@ exports[`quicksilver currency bridge scanAccounts quicksilver seed 1 1`] = `
     "freshAddressPath": "44'/118'/1'/0/0",
     "id": "js:2:quicksilver:quick1v2mp0m7k96dm9qv60fkspcqlzpkzrwnefprl4u:",
     "index": 1,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "0",

package/src/families/cosmos/datasets/__snapshots__/seiNetwork.integration.test.ts.snap

@@ -10,7 +10,6 @@ exports[`sei_network currency bridge scanAccounts sei_network seed 1 1`] = `
     "freshAddressPath": "44'/118'/0'/0/0",
     "id": "js:2:sei_network:sei1gyauvl44q2apn3u3aujm36q8zrj74vryc50pfg:",
     "index": 0,
-    "nfts": undefined,
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "128991",
     "swapHistory": [],
@@ -26,7 +25,6 @@ exports[`sei_network currency bridge scanAccounts sei_network seed 1 1`] = `
     "freshAddressPath": "44'/118'/1'/0/0",
     "id": "js:2:sei_network:sei1v2mp0m7k96dm9qv60fkspcqlzpkzrwne0fzm20:",
     "index": 1,
-    "nfts": undefined,
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "0",
     "swapHistory": [],

package/src/families/cosmos/datasets/__snapshots__/stargaze.integration.test.ts.snap

@@ -10,7 +10,6 @@ exports[`stargaze currency bridge scanAccounts stargaze seed 1 1`] = `
     "freshAddressPath": "44'/118'/0'/0/0",
     "id": "js:2:stargaze:stars1gyauvl44q2apn3u3aujm36q8zrj74vrypyf2yc:",
     "index": 0,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "2000000",
@@ -27,7 +26,6 @@ exports[`stargaze currency bridge scanAccounts stargaze seed 1 1`] = `
     "freshAddressPath": "44'/118'/1'/0/0",
     "id": "js:2:stargaze:stars1v2mp0m7k96dm9qv60fkspcqlzpkzrwnekeys8l:",
     "index": 1,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "0",

package/src/families/cosmos/datasets/__snapshots__/umee.integration.test.ts.snap

@@ -10,7 +10,6 @@ exports[`umee currency bridge scanAccounts umee seed 1 1`] = `
     "freshAddressPath": "44'/118'/0'/0/0",
     "id": "js:2:umee:umee1gyauvl44q2apn3u3aujm36q8zrj74vry8wrgtm:",
     "index": 0,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "7090969",
@@ -27,7 +26,6 @@ exports[`umee currency bridge scanAccounts umee seed 1 1`] = `
     "freshAddressPath": "44'/118'/1'/0/0",
     "id": "js:2:umee:umee1v2mp0m7k96dm9qv60fkspcqlzpkzrwnesnwjgu:",
     "index": 1,
-    "nfts": undefined,
     "pendingOperations": [],
     "seedIdentifier": "03d5e0ebb3f1ae2afe87e5d5a24b5029a59cc12f8fd1056840091b2f0b97e54e83",
     "spendableBalance": "0",

package/src/families/cosmos/estimateMaxSpendable.ts

@@ -0,0 +1,26 @@
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+import type { CosmosAccount, Transaction } from "./types";
+import getTransactionStatus from "./getTransactionStatus";
+import { prepareTransaction } from "./prepareTransaction";
+import { createTransaction } from "./createTransaction";
+import { getMainAccount } from "../../account";
+
+export const estimateMaxSpendable: AccountBridge<
+  Transaction,
+  CosmosAccount
+>["estimateMaxSpendable"] = async ({ account, parentAccount, transaction }) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+
+  const t = await prepareTransaction(mainAccount, {
+    ...createTransaction(account),
+    ...transaction,
+    recipient: transaction?.recipient || getAbandonSeedAddress(mainAccount.currency.id),
+    useAllAmount: true,
+  });
+
+  const { amount } = await getTransactionStatus(mainAccount, t);
+  return amount;
+};
+
+export default estimateMaxSpendable;

package/src/families/cosmos/getTransactionStatus.ts

@@ -0,0 +1,317 @@
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+  RecommendUndelegation,
+} from "@ledgerhq/errors";
+import {
+  ClaimRewardsFeesWarning,
+  CosmosDelegateAllFundsWarning,
+  CosmosRedelegationInProgress,
+  CosmosTooManyValidators,
+  NotEnoughDelegationBalance,
+} from "../../errors";
+import {
+  CosmosLikeTransaction,
+  StatusErrorMap,
+  CosmosAccount,
+  TransactionStatus,
+  Transaction,
+} from "./types";
+import { BigNumber } from "bignumber.js";
+import {
+  COSMOS_MAX_DELEGATIONS,
+  COSMOS_MAX_REDELEGATIONS,
+  COSMOS_MAX_UNBONDINGS,
+  getMaxEstimatedBalance,
+} from "./logic";
+import invariant from "invariant";
+import * as bech32 from "bech32";
+import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import cryptoFactory from "./chain/chain";
+import { AccountBridge } from "@ledgerhq/types-live";
+
+export class CosmosTransactionStatusManager {
+  getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
+    account: CosmosAccount,
+    transaction: CosmosLikeTransaction,
+  ) => {
+    if (transaction.mode === "send") {
+      // We isolate the send transaction that it's a little bit different from the rest
+      return await this.getSendTransactionStatus(account, transaction);
+    } else if (transaction.mode === "delegate") {
+      return await this.getDelegateTransactionStatus(account, transaction);
+    }
+
+    const errors: StatusErrorMap = {};
+    const warnings: StatusErrorMap = {};
+    // here we only treat about all other mode than delegate and send
+    if (
+      transaction.validators.some(
+        v => !v.address || !v.address.includes(cryptoFactory(account.currency.id).validatorPrefix),
+      ) ||
+      transaction.validators.length === 0
+    )
+      errors.recipient = new InvalidAddress(undefined, {
+        currencyName: account.currency.name,
+      });
+
+    if (transaction.mode === "redelegate") {
+      const redelegationError = this.redelegationStatusError(account, transaction);
+
+      if (redelegationError) {
+        // Note : note sure if I have to put this error on this field
+        errors.redelegation = redelegationError;
+      }
+    } else if (transaction.mode === "undelegate") {
+      invariant(
+        account.cosmosResources &&
+          account.cosmosResources.unbondings.length < COSMOS_MAX_UNBONDINGS,
+        "unbondings should not have more than 6 entries",
+      );
+      if (transaction.validators.length === 0)
+        errors.recipient = new InvalidAddress(undefined, {
+          currencyName: account.currency.name,
+        });
+      const [first] = transaction.validators;
+      const unbondingError = first && this.isDelegable(account, first.address, first.amount);
+
+      if (unbondingError) {
+        errors.unbonding = unbondingError;
+      }
+    }
+
+    const validatorAmount = transaction.validators.reduce(
+      (old, current) => old.plus(current.amount),
+      new BigNumber(0),
+    );
+
+    if (transaction.mode !== "claimReward" && validatorAmount.lte(0)) {
+      errors.amount = new AmountRequired();
+    }
+
+    const estimatedFees = transaction.fees || new BigNumber(0);
+
+    if (!transaction.fees) {
+      errors.fees = new FeeNotLoaded();
+    }
+
+    let totalSpent = estimatedFees;
+
+    if (["claimReward", "claimRewardCompound"].includes(transaction.mode)) {
+      const { cosmosResources } = account;
+      invariant(cosmosResources, "cosmosResources should exist");
+      const claimReward =
+        transaction.validators.length && cosmosResources
+          ? cosmosResources.delegations.find(
+              delegation => delegation.validatorAddress === transaction.validators[0].address,
+            )
+          : null;
+
+      if (claimReward && estimatedFees.gt(claimReward.pendingRewards)) {
+        warnings.claimReward = new ClaimRewardsFeesWarning();
+      }
+    }
+
+    if (
+      !errors.recipient &&
+      !errors.amount &&
+      (validatorAmount.lt(0) || totalSpent.gt(account.spendableBalance))
+    ) {
+      errors.amount = new NotEnoughBalance();
+      totalSpent = new BigNumber(0);
+    }
+
+    return Promise.resolve({
+      errors,
+      warnings,
+      estimatedFees,
+      amount: new BigNumber(0),
+      totalSpent,
+    });
+  };
+
+  private getDelegateTransactionStatus = async (
+    account: CosmosAccount,
+    transaction: CosmosLikeTransaction,
+  ): Promise<TransactionStatus> => {
+    const errors: StatusErrorMap = {};
+    const warnings: StatusErrorMap = {};
+    if (
+      transaction.validators.some(
+        v => !v.address || !v.address.includes(cryptoFactory(account.currency.id).validatorPrefix),
+      ) ||
+      transaction.validators.length === 0
+    )
+      errors.recipient = new InvalidAddress(undefined, {
+        currencyName: account.currency.name,
+      });
+
+    if (transaction.validators.length > COSMOS_MAX_DELEGATIONS) {
+      errors.validators = new CosmosTooManyValidators();
+    }
+
+    const estimatedFees = transaction.fees || new BigNumber(0);
+
+    if (!transaction.fees || !transaction.fees.gt(0)) {
+      errors.fees = new FeeNotLoaded();
+    }
+    const amount = transaction.useAllAmount
+      ? getMaxEstimatedBalance(account, estimatedFees)
+      : transaction.amount;
+    const totalSpent = amount.plus(estimatedFees);
+
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    }
+
+    if (
+      !errors.recipient &&
+      !errors.amount &&
+      (amount.lt(0) || totalSpent.gt(account.spendableBalance))
+    ) {
+      errors.amount = new NotEnoughBalance();
+    }
+
+    if (!errors.amount && transaction.useAllAmount) {
+      warnings.amount = new CosmosDelegateAllFundsWarning();
+    }
+
+    return Promise.resolve({
+      errors,
+      warnings,
+      estimatedFees,
+      amount,
+      totalSpent,
+    });
+  };
+
+  private getSendTransactionStatus = async (
+    account: CosmosAccount,
+    transaction: CosmosLikeTransaction,
+  ): Promise<TransactionStatus> => {
+    const errors: StatusErrorMap = {};
+    const warnings: StatusErrorMap = {};
+
+    if (!transaction.recipient) {
+      errors.recipient = new RecipientRequired("");
+    } else if (account.freshAddress === transaction.recipient) {
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+    } else {
+      let isValid = true;
+      try {
+        bech32.decode(transaction.recipient);
+      } catch (e) {
+        isValid = false;
+      }
+      const currency = findCryptoCurrencyById(account.currency.name.toLowerCase());
+      let prefix = "";
+      if (currency) {
+        prefix = cryptoFactory(currency.id as string).prefix;
+      }
+      isValid = isValid && transaction.recipient.startsWith(prefix);
+      if (!isValid) {
+        errors.recipient = new InvalidAddress(undefined, {
+          currencyName: account.currency.name,
+        });
+      }
+    }
+
+    let amount = transaction.amount;
+
+    if (amount.lte(0) && !transaction.useAllAmount) {
+      errors.amount = new AmountRequired();
+    }
+
+    const estimatedFees = transaction.fees || new BigNumber(0);
+    if (!transaction.fees || !transaction.fees.gt(0)) {
+      errors.fees = new FeeNotLoaded();
+    }
+
+    amount = transaction.useAllAmount ? getMaxEstimatedBalance(account, estimatedFees) : amount;
+    const totalSpent = amount.plus(estimatedFees);
+
+    if (
+      (amount.lte(0) && transaction.useAllAmount) || // if use all Amount sets an amount at 0
+      (!errors.recipient && !errors.amount && totalSpent.gt(account.spendableBalance)) // if spendable balance lower than total
+    ) {
+      errors.amount = new NotEnoughBalance();
+    }
+
+    if (account.cosmosResources?.delegations.length > 0 && transaction.useAllAmount) {
+      warnings.amount = new RecommendUndelegation();
+    }
+    return Promise.resolve({
+      errors,
+      warnings,
+      estimatedFees,
+      amount,
+      totalSpent,
+    });
+  };
+
+  private redelegationStatusError = (
+    account: CosmosAccount,
+    transaction: CosmosLikeTransaction,
+  ) => {
+    if (account.cosmosResources) {
+      const redelegations = account.cosmosResources.redelegations;
+      invariant(
+        redelegations.length < COSMOS_MAX_REDELEGATIONS,
+        "redelegation should not have more than 6 entries",
+      );
+
+      if (
+        redelegations.some(redelegation => {
+          const dstValidator = redelegation.validatorDstAddress;
+          return (
+            dstValidator === transaction.sourceValidator && redelegation.completionDate > new Date()
+          );
+        })
+      ) {
+        return new CosmosRedelegationInProgress();
+      }
+
+      if (transaction.validators.length > 0) {
+        if (transaction.sourceValidator === transaction.validators[0].address) {
+          return new InvalidAddressBecauseDestinationIsAlsoSource();
+        } else {
+          return this.isDelegable(
+            account,
+            transaction.sourceValidator,
+            transaction.validators[0].amount,
+          );
+        }
+      }
+    }
+
+    return null;
+  };
+
+  private isDelegable = (
+    account: CosmosAccount,
+    address: string | undefined | null,
+    amount: BigNumber,
+  ) => {
+    const { cosmosResources } = account;
+    invariant(cosmosResources, "cosmosResources should exist");
+
+    if (
+      cosmosResources &&
+      cosmosResources.delegations.some(
+        delegation => delegation.validatorAddress === address && delegation.amount.lt(amount),
+      )
+    ) {
+      return new NotEnoughDelegationBalance();
+    }
+
+    return null;
+  };
+}
+
+const cosmosTransactionStatusManager = new CosmosTransactionStatusManager();
+
+export default cosmosTransactionStatusManager.getTransactionStatus;

package/src/families/cosmos/prepareTransaction.ts

@@ -0,0 +1,140 @@
+import { CacheRes, makeLRUCache } from "@ledgerhq/live-network/cache";
+import { log } from "@ledgerhq/logs";
+import type { Account, AccountBridge } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { getEnv } from "@ledgerhq/live-env";
+import { CosmosAPI } from "./api/Cosmos";
+import cryptoFactory from "./chain/chain";
+import { txToMessages, buildTransaction } from "./buildTransaction";
+import { getMaxEstimatedBalance } from "./logic";
+import { CosmosAccount, Transaction } from "./types";
+
+export const calculateFees: CacheRes<
+  Array<{
+    account: Account;
+    transaction: Transaction;
+  }>,
+  {
+    gasWanted: BigNumber;
+    gasWantedFees: BigNumber;
+  }
+> = makeLRUCache(
+  async ({
+    account,
+    transaction,
+  }): Promise<{
+    gasWanted: BigNumber;
+    gasWantedFees: BigNumber;
+  }> => {
+    return await getEstimatedFees(account as CosmosAccount, transaction);
+  },
+  ({ account, transaction }) =>
+    `${account.id}_${account.currency.id}_${transaction.amount.toFixed()}_${
+      transaction.recipient
+    }_${String(transaction.useAllAmount)}_${transaction.mode}_${
+      transaction.validators
+        ? transaction.validators.map(v => `${v.address}-${v.amount}`).join("_")
+        : ""
+    }_${transaction.memo ? transaction.memo.toString() : ""}_${
+      transaction.sourceValidator ? transaction.sourceValidator : ""
+    }`,
+  {
+    ttl: 1000 * 10, // 10 sec
+  },
+);
+
+export const getEstimatedFees = async (
+  account: CosmosAccount,
+  transaction: Transaction,
+): Promise<{
+  gasWanted: BigNumber;
+  gasWantedFees: BigNumber;
+}> => {
+  const chainInstance = cryptoFactory(account.currency.id);
+  let gasUsed = new BigNumber(chainInstance.defaultGas);
+
+  const cosmosAPI = new CosmosAPI(account.currency.id);
+  const { protoMsgs } = txToMessages(account, transaction);
+  const { sequence, pubKey, pubKeyType } = await cosmosAPI.getAccount(account.freshAddress);
+
+  const unsignedTx = buildTransaction({
+    protoMsgs,
+    gasLimit: undefined,
+    feeAmount: [
+      {
+        denom: account.currency.units[1].code,
+        amount: "1", // Amount should just not be 0 as it would impact the simulation by requiring less gas
+      },
+    ],
+    memo: transaction.memo || "",
+    pubKey,
+    pubKeyType,
+    sequence,
+    // Signature isn't verified during simulation, but size matters (:wink::wink:)
+    // and content not being 0 as well as it would require less gas
+    signature: Uint8Array.from(Buffer.alloc(65).fill(1)),
+  });
+
+  try {
+    gasUsed = await cosmosAPI.simulate(Array.from(unsignedTx));
+  } catch (e) {
+    log("debug", "failed to estimate gas usage during tx simulation", {
+      e,
+    });
+  }
+
+  const gasWanted = gasUsed
+    .times(getEnv("COSMOS_GAS_AMPLIFIER"))
+    .integerValue(BigNumber.ROUND_CEIL);
+
+  const gasWantedFees = gasWanted
+    .times(chainInstance.minGasPrice)
+    .integerValue(BigNumber.ROUND_CEIL);
+
+  return { gasWanted, gasWantedFees };
+};
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  let { memo, amount } = transaction;
+
+  if (transaction.mode !== "send" && !transaction.memo) {
+    memo = "Ledger Live";
+  }
+
+  const { gasWanted, gasWantedFees } = await calculateFees({
+    account,
+    transaction: {
+      ...transaction,
+      amount: transaction.useAllAmount
+        ? account.spendableBalance.minus(new BigNumber(2500))
+        : amount,
+      memo,
+    },
+  });
+
+  if (transaction.useAllAmount) {
+    amount = getMaxEstimatedBalance(account as CosmosAccount, gasWantedFees);
+  }
+
+  if (
+    transaction.memo !== memo ||
+    !gasWantedFees.eq(transaction.fees || new BigNumber(0)) ||
+    !gasWanted.eq(transaction.gas || new BigNumber(0)) ||
+    !amount.eq(transaction.amount)
+  ) {
+    return {
+      ...transaction,
+      memo,
+      fees: gasWantedFees,
+      gas: gasWanted,
+      amount,
+    };
+  }
+
+  return transaction;
+};
+
+export default prepareTransaction;