@ledgerhq/live-common 25.2.0-next.0 → 25.2.0-next.1

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

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

@@ -1,5 +1,5 @@
 import type { CosmosAccount, Transaction } from "./types";
-import { getAccount, getChainId } from "./api/Cosmos";
+import { defaultCosmosAPI } from "./api/Cosmos";
 import { Observable } from "rxjs";
 import { withDevice } from "../../hw/deviceAccess";
 import { encodeOperationId } from "../../operation";
@@ -33,11 +33,11 @@ const signOperation = ({
       async function main() {
         const hwApp = new Cosmos(transport);
 
-        const { accountNumber, sequence } = await getAccount(
+        const { accountNumber, sequence } = await defaultCosmosAPI.getAccount(
           account.freshAddress
         );
 
-        const chainId = await getChainId();
+        const chainId = await defaultCosmosAPI.getChainId();
 
         o.next({ type: "device-signature-requested" });
 
@@ -138,7 +138,7 @@ const signOperation = ({
 
         if (transaction.mode === "redelegate") {
           Object.assign(extra, {
-            cosmosSourceValidator: transaction.cosmosSourceValidator,
+            sourceValidator: transaction.sourceValidator,
           });
         }
 

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

@@ -6,7 +6,7 @@ import {
   mergeOps,
 } from "../../bridge/jsHelpers";
 import { encodeAccountId } from "../../account";
-import { getAccountInfo } from "./api/Cosmos";
+import { defaultCosmosAPI } from "./api/Cosmos";
 import { pubkeyToAddress, decodeBech32Pubkey } from "@cosmjs/amino";
 import { encodeOperationId } from "../../operation";
 import { CosmosDelegationInfo } from "./types";
@@ -122,7 +122,7 @@ const txToOps = (info: any, id: string, txs: any): Operation[] => {
                 address: attributes.destination_validator,
                 amount: attributes.amount.replace(currency.units[1].code, ""),
               });
-              op.extra.cosmosSourceValidator = attributes.source_validator;
+              op.extra.sourceValidator = attributes.source_validator;
             }
             break;
 
@@ -184,7 +184,7 @@ export const getAccountShape: GetAccountShape = async (info) => {
     redelegations,
     unbondings,
     withdrawAddress,
-  } = await getAccountInfo(xpubOrAddress, currency);
+  } = await defaultCosmosAPI.getAccountInfo(xpubOrAddress, currency);
 
   const oldOperations = initialAccount?.operations || [];
   const newOperations = txToOps(info, accountId, txs);

package/src/families/cosmos/logic.ts

@@ -215,7 +215,7 @@ export async function canClaimRewards(
       useAllAmount: false,
       networkInfo: null,
       memo: null,
-      cosmosSourceValidator: null,
+      sourceValidator: null,
       validators: [
         {
           address: delegation.validatorAddress,

package/src/families/cosmos/mock.ts

@@ -197,7 +197,7 @@ function addRedelegationOperation(
       address: toDelegation.validatorAddress,
       amount,
     },
-    cosmosSourceValidator: fromDelegation.validatorAddress,
+    sourceValidator: fromDelegation.validatorAddress,
   };
   const delegations = cosmosResources.delegations
     .filter(