@ledgerhq/live-common 21.36.2 → 22.0.0

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

@@ -1,299 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import invariant from "invariant";
-import {
-  NotEnoughBalance,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  InvalidAddress,
-  AmountRequired,
-  RecommendUndelegation,
-  FeeNotLoaded,
-} from "@ledgerhq/errors";
-import {
-  CosmosRedelegationInProgress,
-  ClaimRewardsFeesWarning,
-  CosmosDelegateAllFundsWarning,
-  CosmosTooManyValidators,
-  NotEnoughDelegationBalance,
-} from "../../errors";
-import {
-  getMaxEstimatedBalance,
-  COSMOS_MAX_REDELEGATIONS,
-  COSMOS_MAX_UNBONDINGS,
-  COSMOS_MAX_DELEGATIONS,
-} from "./logic";
-import { validateRecipient } from "../../bridge/shared";
-import { Transaction, TransactionStatus, StatusErrorMap } from "./types";
-import { Account } from "../../types";
-
-const isDelegable = (
-  a: Account,
-  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 redelegationStatusError = (a: Account, t: Transaction) => {
-  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.cosmosSourceValidator &&
-          redelegation.completionDate > new Date()
-        );
-      })
-    )
-      return new CosmosRedelegationInProgress();
-    if (t.cosmosSourceValidator === t.validators[0].address)
-      return new InvalidAddressBecauseDestinationIsAlsoSource();
-  }
-
-  return isDelegable(a, t.cosmosSourceValidator, t.validators[0].amount);
-};
-
-const getSendTransactionStatus = async (
-  a: Account,
-  t: Transaction,
-  isPreValidation = false
-): Promise<TransactionStatus> => {
-  const errors: StatusErrorMap = {};
-  const warnings: StatusErrorMap = {};
-
-  if (a.freshAddress === t.recipient) {
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-  } else {
-    const { recipientError, recipientWarning } = await validateRecipient(
-      a.currency,
-      t.recipient
-    );
-
-    if (recipientError) {
-      errors.recipient = recipientError;
-    }
-
-    if (recipientWarning) {
-      warnings.recipient = recipientWarning;
-    }
-  }
-
-  let amount = t.amount;
-
-  if (amount.lte(0) && !t.useAllAmount) {
-    errors.amount = new AmountRequired();
-  }
-
-  const estimatedFees = t.fees || new BigNumber(0);
-
-  if (!isPreValidation && (!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,
-  });
-};
-
-const getDelegateTransactionStatus = async (
-  a: Account,
-  t: Transaction,
-  isPreValidation = false
-): Promise<TransactionStatus> => {
-  const errors: StatusErrorMap = {};
-  const warnings: StatusErrorMap = {};
-  if (
-    t.validators.some(
-      (v) => !v.address || !v.address.includes("cosmosvaloper")
-    ) ||
-    t.validators.length === 0
-  )
-    errors.recipient = new InvalidAddress(undefined, {
-      currencyName: a.currency.name,
-    });
-
-  if (t.validators.length > COSMOS_MAX_DELEGATIONS) {
-    errors.validators = new CosmosTooManyValidators();
-  }
-
-  let amount = t.validators.reduce(
-    (old, current) => old.plus(current.amount),
-    new BigNumber(0)
-  );
-
-  if (amount.eq(0)) {
-    errors.amount = new AmountRequired();
-  }
-
-  const estimatedFees = t.fees || new BigNumber(0);
-
-  if (!isPreValidation && !t.fees) {
-    errors.fees = new FeeNotLoaded();
-  }
-
-  let totalSpent = amount.plus(estimatedFees);
-
-  if (totalSpent.eq(a.spendableBalance)) {
-    warnings.delegate = new CosmosDelegateAllFundsWarning();
-  }
-
-  if (
-    !errors.recipient &&
-    !errors.amount &&
-    (amount.lt(0) || totalSpent.gt(a.spendableBalance))
-  ) {
-    errors.amount = new NotEnoughBalance();
-    amount = new BigNumber(0);
-    totalSpent = new BigNumber(0);
-  }
-
-  return Promise.resolve({
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-  });
-};
-
-const getTransactionStatus = async (
-  a: Account,
-  t: Transaction,
-  isPreValidation = false
-): Promise<TransactionStatus> => {
-  if (t.mode === "send") {
-    // We isolate the send transaction that it's a little bit different from the rest
-    return await getSendTransactionStatus(a, t, isPreValidation);
-  } else if (t.mode === "delegate") {
-    return await getDelegateTransactionStatus(a, t, isPreValidation);
-  }
-
-  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("cosmosvaloper")
-    ) ||
-    t.validators.length === 0
-  )
-    errors.recipient = new InvalidAddress(undefined, {
-      currencyName: a.currency.name,
-    });
-
-  if (t.mode === "redelegate") {
-    const redelegationError = 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 && 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 (!isPreValidation && !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,
-  });
-};
-
-export default getTransactionStatus;

package/src/families/cosmos/libcore-mergeOperations.ts

@@ -1,43 +0,0 @@
-import invariant from "invariant";
-import type { Operation } from "../../types";
-
-const mergeOperations = (operations: Operation[]): Operation => {
-  const feeOp = operations.find((op) => op.type === "FEES");
-  const otherOps = operations.filter((op) => op !== feeOp);
-
-  if (otherOps.length === 0) {
-    invariant(feeOp, "fee op is necessary if no other ops exists");
-    return feeOp as Operation;
-  }
-
-  const union: Operation = { ...otherOps[0] };
-  // remove the "-0" part
-  union.id = union.id.split("-").slice(0, 3).join("-");
-
-  if (feeOp) {
-    union.fee = feeOp.value;
-
-    if (union.type === "OUT") {
-      union.value = union.value.plus(feeOp.value);
-    } else {
-      union.value = feeOp.value;
-    }
-  }
-
-  const extra = { ...union.extra };
-  delete extra.id;
-
-  // accumulate validators
-  if (extra.validators) {
-    extra.validators = otherOps.reduce(
-      (validators, op) =>
-        validators.concat((op.extra && op.extra.validators) || []),
-      []
-    );
-  }
-
-  union.extra = extra;
-  return union;
-};
-
-export default mergeOperations;

package/src/families/cosmos/libcore-postBuildAccount.ts

@@ -1,177 +0,0 @@
-import type { Account } from "../../types";
-import type { CoreAccount } from "../../libcore/types";
-import type {
-  CosmosResources,
-  CoreCosmosLikeAccount,
-  CosmosUnbonding,
-  CosmosRedelegation,
-  CosmosDelegation,
-} from "./types";
-import { BigNumber } from "bignumber.js";
-import { log } from "@ledgerhq/logs";
-import {
-  libcoreAmountToBigNumber,
-  libcoreBigIntToBigNumber,
-} from "../../libcore/buildBigNumber";
-import { promiseAllBatched } from "../../promise";
-import { getMaxEstimatedBalance } from "./logic";
-
-const getValidatorStatus = async (
-  cosmosAccount: CoreCosmosLikeAccount,
-  address
-) => {
-  const status = ["unbonded", "unbonding", "bonded"];
-  const validatorInfo = await cosmosAccount.getValidatorInfo(address);
-  const rawStatus = await validatorInfo.getActiveStatus();
-
-  // Pre stargate
-  if (["0", "1", "2"].includes(rawStatus)) {
-    return status[parseInt(rawStatus)];
-  }
-
-  // Stargate
-  const stargateStatusMap = {
-    BOND_STATUS_UNBONDED: "unbonded",
-    BOND_STATUS_UNBONDING: "unbonding",
-    BOND_STATUS_BONDED: "bonded",
-  };
-  return stargateStatusMap[rawStatus] || "unbonded";
-};
-
-const getFlattenDelegation = async (
-  cosmosAccount: CoreCosmosLikeAccount
-): Promise<CosmosDelegation[]> => {
-  const delegations = await cosmosAccount.getDelegations();
-  const pendingRewards = await cosmosAccount.getPendingRewards();
-  return await promiseAllBatched(10, delegations, async (delegation) => {
-    const validatorAddress = await delegation.getValidatorAddress();
-    let reward;
-
-    for (let i = 0; i < pendingRewards.length; i++) {
-      if (
-        (await pendingRewards[i].getValidatorAddress()) === validatorAddress
-      ) {
-        reward = await pendingRewards[i].getRewardAmount();
-        break;
-      }
-    }
-
-    return {
-      amount: await libcoreAmountToBigNumber(
-        await delegation.getDelegatedAmount()
-      ),
-      validatorAddress,
-      pendingRewards: reward
-        ? await libcoreAmountToBigNumber(reward)
-        : new BigNumber(0),
-      status: await getValidatorStatus(cosmosAccount, validatorAddress),
-    };
-  });
-};
-
-const getFlattenRedelegations = async (
-  cosmosAccount: CoreCosmosLikeAccount
-): Promise<CosmosRedelegation[]> => {
-  const redelegations = await cosmosAccount.getRedelegations();
-  const toFlatten = await promiseAllBatched(
-    3,
-    redelegations,
-    async (redelegation) =>
-      await promiseAllBatched(
-        3,
-        await redelegation.getEntries(),
-        async (entry) => ({
-          validatorSrcAddress: await redelegation.getSrcValidatorAddress(),
-          validatorDstAddress: await redelegation.getDstValidatorAddress(),
-          amount: await libcoreBigIntToBigNumber(
-            await entry.getInitialBalance()
-          ),
-          completionDate: await entry.getCompletionTime(),
-        })
-      )
-  );
-  return toFlatten.reduce((old, current) => [...old, ...current], []);
-};
-
-const getFlattenUnbonding = async (
-  cosmosAccount: CoreCosmosLikeAccount
-): Promise<CosmosUnbonding[]> => {
-  const unbondings = await cosmosAccount.getUnbondings();
-  const toFlatten = await promiseAllBatched(
-    3,
-    unbondings,
-    async (unbonding) =>
-      await promiseAllBatched(
-        3,
-        await unbonding.getEntries(),
-        async (entry) => ({
-          validatorAddress: await unbonding.getValidatorAddress(),
-          amount: await libcoreBigIntToBigNumber(
-            await entry.getInitialBalance()
-          ),
-          completionDate: await entry.getCompletionTime(),
-        })
-      )
-  );
-  return toFlatten.reduce((old, current) => [...old, ...current], []);
-};
-
-const filterDelegation = (delegations) => {
-  return delegations.filter((delegation) => delegation.amount.gt(0));
-};
-
-const getCosmosResources = async (
-  account: Account,
-  coreAccount
-): Promise<CosmosResources> => {
-  const cosmosAccount = await coreAccount.asCosmosLikeAccount();
-  const flattenDelegation = await getFlattenDelegation(cosmosAccount);
-  const flattenUnbonding = await getFlattenUnbonding(cosmosAccount);
-  const flattenRedelegation = await getFlattenRedelegations(cosmosAccount);
-  const res = {
-    delegations: filterDelegation(flattenDelegation),
-    redelegations: flattenRedelegation,
-    unbondings: flattenUnbonding,
-    delegatedBalance: flattenDelegation.reduce(
-      (old, current) => old.plus(current.amount),
-      new BigNumber(0)
-    ),
-    pendingRewardsBalance: flattenDelegation.reduce(
-      (old, current) => old.plus(current.pendingRewards),
-      new BigNumber(0)
-    ),
-    unbondingBalance: flattenUnbonding.reduce(
-      (old, current) => old.plus(current.amount),
-      new BigNumber(0)
-    ),
-    withdrawAddress: "",
-  };
-  return res;
-};
-
-const postBuildAccount = async ({
-  account,
-  coreAccount,
-}: {
-  account: Account;
-  coreAccount: CoreAccount;
-}): Promise<Account> => {
-  log("cosmos/post-buildAccount", "getCosmosResources");
-  account.cosmosResources = await getCosmosResources(account, coreAccount);
-  log("cosmos/post-buildAccount", "getCosmosResources DONE");
-  account.spendableBalance = getMaxEstimatedBalance(account, new BigNumber(0));
-
-  if (account.spendableBalance.lt(0)) {
-    account.spendableBalance = new BigNumber(0);
-  }
-
-  if (!account.used) {
-    const cosmosAccount = await coreAccount.asCosmosLikeAccount();
-    const seq = await cosmosAccount.getSequence();
-    account.used = seq != "";
-  }
-
-  return account;
-};
-
-export default postBuildAccount;

package/src/families/cosmos/libcore-signOperation.ts

@@ -1,96 +0,0 @@
-import CosmosApp from "@ledgerhq/hw-app-cosmos";
-import { makeSignOperation } from "../../libcore/signOperation";
-import buildTransaction from "./libcore-buildTransaction";
-import type { Transaction, CoreCosmosLikeTransaction } from "./types";
-import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
-import { OperationType } from "../../types";
-
-async function signTransaction({
-  account,
-  transport,
-  transaction,
-  coreTransaction,
-  isCancelled,
-  onDeviceSignatureGranted,
-  onDeviceSignatureRequested,
-}) {
-  const { freshAddressPath, spendableBalance, id, freshAddress } = account;
-  const hwApp = new CosmosApp(transport);
-  const serialized = await coreTransaction.serializeForSignature();
-  onDeviceSignatureRequested();
-  const { signature } = await hwApp.sign(freshAddressPath, serialized);
-  onDeviceSignatureGranted();
-
-  if (signature) {
-    await coreTransaction.setDERSignature(signature.toString("hex"));
-  } else {
-    throw new Error("Cosmos: no Signature Found");
-  }
-
-  if (isCancelled()) return;
-  // Serialize the transaction to be broadcast
-  // @param mode The supported broadcast modes include
-  //        "block"(return after tx commit), (https://docs.cosmos.network/master/basics/tx-lifecycle.html#commit)
-  //        "sync"(return afer CheckTx), (https://docs.cosmos.network/master/basics/tx-lifecycle.html#types-of-checks) and
-  //        "async"(return right away).
-  const hex = await coreTransaction.serializeForBroadcast("sync");
-  if (isCancelled()) return;
-  const feesRaw = await coreTransaction.getFee();
-  if (isCancelled()) return;
-  const fee = await libcoreAmountToBigNumber(feesRaw);
-  if (isCancelled()) return;
-  const recipients = [transaction.recipient];
-  if (isCancelled()) return;
-  const senders = [freshAddress];
-  if (isCancelled()) return;
-  const type: OperationType =
-    transaction.mode === "undelegate"
-      ? "UNDELEGATE"
-      : transaction.mode === "delegate"
-      ? "DELEGATE"
-      : transaction.mode === "redelegate"
-      ? "REDELEGATE"
-      : ["claimReward", "claimRewardCompound"].includes(transaction.mode)
-      ? "REWARD"
-      : "OUT";
-  const extra = {};
-
-  if (transaction.mode === "redelegate") {
-    Object.assign(extra, {
-      cosmosSourceValidator: transaction.cosmosSourceValidator,
-    });
-  }
-
-  if (transaction.mode !== "send") {
-    Object.assign(extra, {
-      validators: transaction.validators,
-    });
-  }
-
-  const op = {
-    id: `${id}--${type}`,
-    hash: "",
-    type,
-    value: transaction.useAllAmount
-      ? spendableBalance
-      : transaction.amount.plus(fee),
-    fee,
-    blockHash: null,
-    blockHeight: null,
-    senders,
-    recipients,
-    accountId: id,
-    date: new Date(),
-    extra,
-  };
-  return {
-    operation: op,
-    expirationDate: null,
-    signature: hex,
-  };
-}
-
-export default makeSignOperation<Transaction, CoreCosmosLikeTransaction>({
-  buildTransaction,
-  signTransaction,
-});