@ledgerhq/live-common 25.2.0-nightly.2 → 26.0.0

package/src/families/cosmos/cli-transaction.ts

@@ -4,12 +4,11 @@ import invariant from "invariant";
 import flatMap from "lodash/flatMap";
 import zipWith from "lodash/zipWith";
 import { BigNumber } from "bignumber.js";
-import { getValidators } from "./validators";
-import type { Transaction } from "../../generated/types";
 import { Transaction as CosmosTransaction } from "./types";
 import type { CosmosDelegationInfo } from "./types";
-import { getCryptoCurrencyById } from "../../currencies";
+import cosmosValidatorsManager from "./validators";
 import { AccountLike } from "@ledgerhq/types-live";
+
 const options = [
   {
     name: "mode",
@@ -32,7 +31,7 @@ const options = [
     desc: "add a memo to a transaction",
   },
   {
-    name: "cosmosSourceValidator",
+    name: "sourceValidator",
     type: String,
     desc: "for redelegate, add a source validator",
   },
@@ -53,11 +52,11 @@ const options = [
 function inferTransactions(
   transactions: Array<{
     account: AccountLike;
-    transaction: Transaction;
+    transaction: CosmosTransaction;
   }>,
   opts: Record<string, any>,
   { inferAmount }: any
-): Transaction[] {
+): CosmosTransaction[] {
   return flatMap(transactions, ({ transaction, account }) => {
     invariant(transaction.family === "cosmos", "cosmos family");
     const validatorsAddresses: string[] = opts["cosmosValidator"] || [];
@@ -82,7 +81,7 @@ function inferTransactions(
       fees: opts.fees ? inferAmount(account, opts.fees) : null,
       gas: opts.gasLimit ? new BigNumber(opts.gasLimit) : null,
       validators: validators,
-      cosmosSourceValidator: opts.cosmosSourceValidator,
+      sourceValidator: opts.sourceValidator,
     } as CosmosTransaction;
   });
 }
@@ -110,7 +109,7 @@ const cosmosValidators = {
   }: Partial<{
     format: string;
   }>): Observable<string> =>
-    from(getValidators(getCryptoCurrencyById("cosmos"))).pipe(
+    from(cosmosValidatorsManager.getValidators()).pipe(
       map((validators) => {
         const f =
           (format && cosmosValidatorsFormatters[format]) ||

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

@@ -12,7 +12,7 @@ import {
 import { MsgWithdrawDelegatorReward } from "cosmjs-types/cosmos/distribution/v1beta1/tx";
 import { SignMode } from "cosmjs-types/cosmos/tx/signing/v1beta1/signing";
 import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
-import { getAccount } from "./api/Cosmos";
+import { defaultCosmosAPI } from "./api/Cosmos";
 import BigNumber from "bignumber.js";
 
 export const buildTransaction = async (
@@ -99,7 +99,7 @@ export const buildTransaction = async (
 
     case "redelegate":
       if (
-        !transaction.cosmosSourceValidator ||
+        !transaction.sourceValidator ||
         !transaction.validators ||
         transaction.validators.length < 1 ||
         !transaction.validators[0].address ||
@@ -110,7 +110,7 @@ export const buildTransaction = async (
         msg.push({
           typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate",
           value: {
-            validatorSrcAddress: transaction.cosmosSourceValidator,
+            validatorSrcAddress: transaction.sourceValidator,
             delegatorAddress: account.freshAddress,
             validatorDstAddress: transaction.validators[0].address,
             amount: {
@@ -205,7 +205,7 @@ export const postBuildTransaction = async (
     ],
   ]);
 
-  const { sequence } = await getAccount(account.freshAddress);
+  const { sequence } = await defaultCosmosAPI.getAccount(account.freshAddress);
 
   const txBodyBytes = registry.encode(txBodyFields);
 

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

@@ -16,7 +16,7 @@ const createTransaction = (): Transaction => ({
   useAllAmount: false,
   networkInfo: null,
   memo: null,
-  cosmosSourceValidator: null,
+  sourceValidator: null,
   validators: [] as CosmosDelegationInfo[],
 });
 

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

@@ -15,9 +15,9 @@ import {
   NotEnoughDelegationBalance,
 } from "../../errors";
 import {
-  CosmosAccount,
+  CosmosLikeTransaction,
   StatusErrorMap,
-  Transaction,
+  CosmosAccount,
   TransactionStatus,
 } from "./types";
 import { BigNumber } from "bignumber.js";
@@ -28,265 +28,315 @@ import {
   getMaxEstimatedBalance,
 } from "./logic";
 import invariant from "invariant";
-import { isValidRecipent } from "./api/Cosmos";
-
-export const getTransactionStatus = async (
-  a: CosmosAccount,
-  t: Transaction
-): 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);
-  } else if (t.mode === "delegate") {
-    return await getDelegateTransactionStatus(a, t);
+import { CosmosAPI, defaultCosmosAPI } from "./api/Cosmos";
+import { OsmosisAPI } from "../osmosis/api/sdk";
+
+export class CosmosTransactionStatusManager {
+  protected _api: CosmosAPI = defaultCosmosAPI;
+  protected _validatorOperatorAddressPrefix = "cosmosvaloper";
+
+  constructor(options?: {
+    api?: CosmosAPI;
+    validatorOperatorAddressPrefix?: string;
+  }) {
+    if (options?.validatorOperatorAddressPrefix) {
+      this._validatorOperatorAddressPrefix =
+        options.validatorOperatorAddressPrefix;
+    }
+    if (options?.api) {
+      this._api = options.api;
+    }
   }
 
-  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;
+  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);
     }
-  } 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)
+
+    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(this._validatorOperatorAddressPrefix)
+      ) ||
+      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;
+    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 validatorAmount = t.validators.reduce(
+      (old, current) => old.plus(current.amount),
+      new BigNumber(0)
+    );
 
-  const estimatedFees = t.fees || new BigNumber(0);
+    if (t.mode !== "claimReward" && validatorAmount.lte(0)) {
+      errors.amount = new AmountRequired();
+    }
 
-  if (!t.fees) {
-    errors.fees = new FeeNotLoaded();
-  }
+    const estimatedFees = t.fees || new BigNumber(0);
 
-  let totalSpent = estimatedFees;
+    if (!t.fees) {
+      errors.fees = new FeeNotLoaded();
+    }
 
-  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();
+    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);
-  }
+    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,
-  });
-};
-
-const getDelegateTransactionStatus = async (
-  a: CosmosAccount,
-  t: Transaction
-): 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,
+    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(this._validatorOperatorAddressPrefix)
+      ) ||
+      t.validators.length === 0
+    )
+      errors.recipient = new InvalidAddress(undefined, {
+        currencyName: a.currency.name,
+      });
 
-  if (t.validators.length > COSMOS_MAX_DELEGATIONS) {
-    errors.validators = new CosmosTooManyValidators();
-  }
+    if (t.validators.length > COSMOS_MAX_DELEGATIONS) {
+      errors.validators = new CosmosTooManyValidators();
+    }
 
-  const estimatedFees = t.fees || new BigNumber(0);
+    const estimatedFees = t.fees || new BigNumber(0);
 
-  if (!t.fees || !t.fees.gt(0)) {
-    errors.fees = new FeeNotLoaded();
-  }
+    if (this._api instanceof OsmosisAPI) {
+      if (!t.fees) {
+        errors.fees = new FeeNotLoaded();
+      }
+    } else {
+      if (!t.fees || !t.fees.gt(0)) {
+        errors.fees = new FeeNotLoaded();
+      }
+    }
+    let amount;
+
+    // TODO, refactor this block. We should use cosmosResources for Osmosis
+    if (this._api instanceof OsmosisAPI) {
+      amount = t.useAllAmount
+        ? a.spendableBalance.minus(estimatedFees)
+        : new BigNumber(t.amount);
+    } else {
+      amount = t.useAllAmount
+        ? getMaxEstimatedBalance(a, estimatedFees)
+        : t.amount;
+    }
+    const totalSpent = amount.plus(estimatedFees);
 
-  const amount = t.useAllAmount
-    ? getMaxEstimatedBalance(a, estimatedFees)
-    : t.amount;
-  const totalSpent = amount.plus(estimatedFees);
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    }
 
-  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.recipient &&
-    !errors.amount &&
-    (amount.lt(0) || totalSpent.gt(a.spendableBalance))
-  ) {
-    errors.amount = new NotEnoughBalance();
-  }
+    if (!errors.amount && t.useAllAmount) {
+      warnings.amount = new CosmosDelegateAllFundsWarning();
+    }
 
-  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 {
+      if (!(await this._api.isValidRecipent(t.recipient))) {
+        errors.recipient = new InvalidAddress(undefined, {
+          currencyName: a.currency.name,
+        });
+      }
+    }
 
-  return Promise.resolve({
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-  });
-};
-
-const getSendTransactionStatus = async (
-  a: CosmosAccount,
-  t: Transaction
-): 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 {
-    if (!(await isValidRecipent(t.recipient))) {
-      errors.recipient = new InvalidAddress(undefined, {
-        currencyName: a.currency.name,
-      });
+    let amount = t.amount;
+
+    if (amount.lte(0) && !t.useAllAmount) {
+      errors.amount = new AmountRequired();
     }
-  }
 
-  let amount = t.amount;
+    const estimatedFees = t.fees || new BigNumber(0);
 
-  if (amount.lte(0) && !t.useAllAmount) {
-    errors.amount = new AmountRequired();
-  }
+    if (this._api instanceof OsmosisAPI) {
+      if (!t.fees) {
+        errors.fees = new FeeNotLoaded();
+      }
+    } else {
+      if (!t.fees || !t.fees.gt(0)) {
+        errors.fees = new FeeNotLoaded();
+      }
+    }
 
-  const estimatedFees = t.fees || new BigNumber(0);
+    amount = t.useAllAmount ? getMaxEstimatedBalance(a, estimatedFees) : amount;
+    const totalSpent = amount.plus(estimatedFees);
 
-  if (!t.fees || !t.fees.gt(0)) {
-    errors.fees = new FeeNotLoaded();
-  }
+    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();
+    }
 
-  amount = t.useAllAmount ? getMaxEstimatedBalance(a, estimatedFees) : amount;
-  const totalSpent = amount.plus(estimatedFees);
+    if (
+      a.cosmosResources &&
+      a.cosmosResources.delegations.length > 0 &&
+      t.useAllAmount
+    ) {
+      warnings.amount = new RecommendUndelegation();
+    }
 
-  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();
-  }
+    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.sourceValidator === t.validators[0].address)
+        return new InvalidAddressBecauseDestinationIsAlsoSource();
+    }
 
-  if (
-    a.cosmosResources &&
-    a.cosmosResources.delegations.length > 0 &&
-    t.useAllAmount
-  ) {
-    warnings.amount = new RecommendUndelegation();
-  }
+    return this.isDelegable(a, t.sourceValidator, t.validators[0].amount);
+  };
+
+  private isDelegable = (
+    a: CosmosAccount,
+    address: string | undefined | null,
+    amount: BigNumber
+  ) => {
+    const { cosmosResources } = a;
+    invariant(cosmosResources, "cosmosResources should exist");
 
-  return Promise.resolve({
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-  });
-};
-
-const redelegationStatusError = (a: CosmosAccount, 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();
-  }
+      cosmosResources &&
+      cosmosResources.delegations.some(
+        (delegation) =>
+          delegation.validatorAddress === address &&
+          delegation.amount.lt(amount)
+      )
+    ) {
+      return new NotEnoughDelegationBalance();
+    }
 
-  return isDelegable(a, t.cosmosSourceValidator, t.validators[0].amount);
-};
-
-const 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;
+  };
+}
 
-  return null;
-};
+const cosmosTransactionStatusManager = new CosmosTransactionStatusManager();
 
-export default getTransactionStatus;
+export default cosmosTransactionStatusManager.getTransactionStatus;

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

@@ -1,6 +1,6 @@
 import { CosmosAccount, Transaction } from "./types";
 import BigNumber from "bignumber.js";
-import { simulate } from "./api/Cosmos";
+import { defaultCosmosAPI } from "./api/Cosmos";
 import { getEnv } from "../../env";
 import { buildTransaction, postBuildTransaction } from "./js-buildTransaction";
 import { getMaxEstimatedBalance } from "./logic";
@@ -34,7 +34,7 @@ export const calculateFees: CacheRes<
         ? transaction.validators.map((v) => v.address).join("-")
         : ""
     }_${transaction.memo ? transaction.memo.toString() : ""}_${
-      transaction.cosmosSourceValidator ? transaction.cosmosSourceValidator : ""
+      transaction.sourceValidator ? transaction.sourceValidator : ""
     }`
 );
 
@@ -65,7 +65,7 @@ const getEstimatedFees = async (
       new Uint8Array(Buffer.from(account.seedIdentifier, "hex"))
     );
 
-    const gasUsed = await simulate(tx_bytes);
+    const gasUsed = await defaultCosmosAPI.simulate(tx_bytes);
 
     if (gasUsed.gt(0)) {
       gasQty = gasUsed