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

package/src/families/cosmos/js-createTransaction.ts

@@ -1,23 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { CosmosDelegationInfo, Transaction } from "./types";
-
-/**
- * Create an empty transaction
- *
- * @returns {Transaction}
- */
-const createTransaction = (): Transaction => ({
-  family: "cosmos",
-  mode: "send",
-  amount: new BigNumber(0),
-  fees: null,
-  gas: null,
-  recipient: "",
-  useAllAmount: false,
-  networkInfo: null,
-  memo: null,
-  sourceValidator: null,
-  validators: [] as CosmosDelegationInfo[],
-});
-
-export default createTransaction;

package/src/families/cosmos/js-estimateMaxSpendable.ts

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

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

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

@@ -1,141 +0,0 @@
-import { CacheRes, makeLRUCache } from "@ledgerhq/live-network/cache";
-import { log } from "@ledgerhq/logs";
-import type { Account } 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 "./js-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 = async (
-  account: Account,
-  transaction: Transaction,
-): Promise<Transaction> => {
-  let memo = transaction.memo;
-  let amount = transaction.amount;
-
-  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;

package/src/families/cosmos/js-prepareTransaction.unit.test.ts

@@ -1,154 +0,0 @@
-import network from "@ledgerhq/live-network/network";
-import { CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
-import BigNumber from "bignumber.js";
-import * as jsPrepareTransaction from "./js-prepareTransaction";
-import { calculateFees, getEstimatedFees } from "./js-prepareTransaction";
-import { CosmosAccount, Transaction } from "./types";
-import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import { liveConfig } from "../../config/sharedConfig";
-
-jest.mock("@ledgerhq/live-network/network");
-
-const account = {
-  id: "accountId",
-  currency: { id: "cosmos", units: [{}, { code: "atom" }] },
-  spendableBalance: new BigNumber("1000000000"),
-  seedIdentifier: "seedIdentifier",
-} as CosmosAccount;
-const transaction = {
-  mode: "send",
-  recipient: "cosmosrecipientaddress",
-  amount: new BigNumber("1000000"),
-  memo: "test memo",
-  useAllAmount: false,
-} as unknown as Transaction;
-
-LiveConfig.setConfig(liveConfig);
-
-describe("getEstimatedFees", () => {
-  it("should return gas higher than estimate", async () => {
-    const gasSimulationMock = 42000;
-    // @ts-expect-error method is mocked
-    network.mockResolvedValue({
-      data: {
-        gas_info: {
-          gas_used: gasSimulationMock,
-        },
-      },
-    });
-    const { gasWanted } = await getEstimatedFees(account, transaction);
-    expect(gasWanted.gt(new BigNumber(gasSimulationMock))).toEqual(true);
-  });
-
-  it("should calculate fees for a transaction", async () => {
-    // @ts-expect-error method is mocked
-    network.mockResolvedValue({
-      data: {
-        gas_info: {
-          gas_used: 42000,
-        },
-      },
-    });
-    const { gasWantedFees, gasWanted } = await getEstimatedFees(account, transaction);
-    expect(gasWantedFees.gt(0)).toEqual(true);
-    expect(gasWanted.gt(0)).toEqual(true);
-  });
-});
-
-describe("calculateFees", () => {
-  let getEstimatedFeesSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    getEstimatedFeesSpy = jest.spyOn(jsPrepareTransaction, "getEstimatedFees").mockImplementation();
-  });
-
-  afterEach(() => {
-    // Reset LRU cache
-    calculateFees.reset();
-    // Reset spy
-    jest.resetAllMocks();
-  });
-
-  it("should not estimate fees again if account and transaction didn't change", async () => {
-    await calculateFees({ account, transaction });
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(1);
-  });
-
-  it("should estimate fees again if account id changed", async () => {
-    await calculateFees({ account, transaction });
-    account.id = "i changed hehe";
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(2);
-  });
-
-  it("should estimate fees again if account currency changed", async () => {
-    await calculateFees({ account, transaction });
-    account.currency.id = "i am a currency that changed hehe" as CryptoCurrencyId;
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(2);
-  });
-
-  it("should estimate fees again if transaction amount changed", async () => {
-    await calculateFees({ account, transaction });
-    transaction.amount = new BigNumber(9000);
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(2);
-  });
-
-  it("should estimate fees again if transaction recipient changed", async () => {
-    await calculateFees({ account, transaction });
-    transaction.recipient = "tasse";
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(2);
-  });
-
-  it("should estimate fees again if transaction useAllAmount prop changed", async () => {
-    await calculateFees({ account, transaction });
-    transaction.useAllAmount = true;
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(2);
-  });
-
-  it("should estimate fees again if transaction mode changed", async () => {
-    await calculateFees({ account, transaction });
-    transaction.mode = "delegate";
-    transaction.validators = [{ address: "toto", amount: new BigNumber(1) }];
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(2);
-  });
-
-  it("should estimate fees again if transaction validator address changed", async () => {
-    transaction.mode = "delegate";
-    transaction.validators = [{ address: "toto", amount: new BigNumber(1) }];
-    await calculateFees({ account, transaction });
-    transaction.mode = "delegate";
-    transaction.validators = [{ address: "totoleretour", amount: new BigNumber(1) }];
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(2);
-  });
-
-  it("should estimate fees again if transaction validator amount changed", async () => {
-    transaction.mode = "delegate";
-    transaction.validators = [{ address: "toto", amount: new BigNumber(1) }];
-    await calculateFees({ account, transaction });
-    transaction.mode = "delegate";
-    transaction.validators = [{ address: "toto", amount: new BigNumber(2) }];
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(2);
-  });
-
-  it("should estimate fees again if transaction memo changed", async () => {
-    await calculateFees({ account, transaction });
-    transaction.memo = "yikes";
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(2);
-  });
-
-  it("should estimate fees again if transaction sourceValidator changed", async () => {
-    await calculateFees({ account, transaction });
-    transaction.sourceValidator = "source";
-    await calculateFees({ account, transaction });
-    expect(getEstimatedFeesSpy).toHaveBeenCalledTimes(2);
-  });
-});