@ledgerhq/live-common 21.36.2 → 22.0.0

package/src/families/cosmos/bridge/libcore.ts

@@ -1,177 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
-import { scanAccounts } from "../../../libcore/scanAccounts";
-import { sync } from "../../../libcore/syncAccount";
-import type {
-  Account,
-  AccountBridge,
-  CurrencyBridge,
-  CryptoCurrency,
-  AccountLike,
-} from "../../../types";
-import type { CosmosValidatorItem, Transaction } from "../types";
-import getTransactionStatus from "../libcore-getTransactionStatus";
-import signOperation from "../libcore-signOperation";
-import broadcast from "../libcore-broadcast";
-import { getMainAccount } from "../../../account";
-import { validateRecipient } from "../../../bridge/shared";
-import {
-  setCosmosPreloadData,
-  asSafeCosmosPreloadData,
-} from "../preloadedData";
-import { getValidators, hydrateValidators } from "../validators";
-import { calculateFees, getMaxEstimatedBalance } from "../logic";
-import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
-const receive = makeAccountBridgeReceive();
-
-const createTransaction = (): Transaction => ({
-  family: "cosmos",
-  mode: "send",
-  amount: new BigNumber(0),
-  fees: null,
-  gas: null,
-  recipient: "",
-  useAllAmount: false,
-  networkInfo: null,
-  memo: null,
-  cosmosSourceValidator: null,
-  validators: [],
-});
-
-const updateTransaction = (t, patch) => {
-  if ("mode" in patch && patch.mode !== t.mode) {
-    return { ...t, ...patch, gas: null, fees: null };
-  }
-
-  if (
-    "validators" in patch &&
-    patch.validators.length !== t.validators.length
-  ) {
-    return { ...t, ...patch, gas: null, fees: null };
-  }
-
-  return { ...t, ...patch };
-};
-
-const isTransactionValidForEstimatedFees = async (a, t) => {
-  let errors: Error | undefined | null = null;
-
-  if (t.mode === "send" && (t.amount.gt(0) || t.useAllAmount)) {
-    errors = (await validateRecipient(a.currency, t.recipient)).recipientError;
-  } else {
-    errors =
-      t.validators.some(
-        (v) => !v.address || !v.address.includes("cosmosvaloper")
-      ) ||
-      (t.mode !== "claimReward" &&
-        t.validators
-          .reduce((old, current) => old.plus(current.amount), new BigNumber(0))
-          .eq(0));
-  }
-
-  return errors;
-};
-
-const sameFees = (a, b) => (!a || !b ? a === b : a.eq(b));
-
-const prepareTransaction = async (
-  a: Account,
-  t: Transaction
-): Promise<Transaction> => {
-  let memo = t.memo;
-  let fees = t.fees;
-  let gas = t.gas;
-
-  if (t.recipient || t.mode !== "send") {
-    const errors = await isTransactionValidForEstimatedFees(a, t);
-
-    if (!errors) {
-      let amount;
-
-      if (t.useAllAmount) {
-        amount = getMaxEstimatedBalance(a, new BigNumber(0));
-      }
-
-      if ((amount && amount.gt(0)) || !amount) {
-        const res = await calculateFees({
-          a,
-          t: { ...t, amount: amount || t.amount },
-        });
-        fees = res.estimatedFees;
-        gas = res.estimatedGas;
-      }
-    }
-  }
-
-  if (t.mode !== "send" && !memo) {
-    memo = "Ledger Live";
-  }
-
-  if (t.memo !== memo || !sameFees(t.fees, fees)) {
-    return { ...t, memo, fees, gas };
-  }
-
-  return t;
-};
-
-const currencyBridge: CurrencyBridge = {
-  preload: async (currency: CryptoCurrency) => {
-    const validators = await getValidators(currency);
-    setCosmosPreloadData({
-      validators,
-    });
-    return Promise.resolve({
-      validators,
-    });
-  },
-  hydrate: (data: { validators?: CosmosValidatorItem[] }) => {
-    if (!data || typeof data !== "object") return;
-    const { validators } = data;
-    if (
-      !validators ||
-      typeof validators !== "object" ||
-      !Array.isArray(validators)
-    )
-      return;
-    hydrateValidators(validators);
-    setCosmosPreloadData(asSafeCosmosPreloadData(data));
-  },
-  scanAccounts,
-};
-
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-  transaction,
-}: {
-  account: AccountLike;
-  parentAccount: Account;
-  transaction: Transaction;
-}): Promise<BigNumber> => {
-  const mainAccount = getMainAccount(account, parentAccount);
-  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;
-};
-
-const accountBridge: AccountBridge<Transaction> = {
-  createTransaction,
-  updateTransaction,
-  prepareTransaction,
-  getTransactionStatus,
-  estimateMaxSpendable,
-  sync,
-  receive,
-  signOperation,
-  broadcast,
-};
-export default {
-  currencyBridge,
-  accountBridge,
-};

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

@@ -1,24 +0,0 @@
-import type { Operation } from "../../types";
-import type { CosmosBroadcastResponse } from "./types";
-import { makeBroadcast } from "../../libcore/broadcast";
-import { CosmosBroadcastError } from "../../errors";
-import { patchOperationWithHash } from "../../operation";
-
-async function broadcast({
-  coreAccount,
-  signedOperation: { operation, signature },
-}): Promise<Operation> {
-  const cosmosLikeAccount = await coreAccount.asCosmosLikeAccount();
-  const res = await cosmosLikeAccount.broadcastRawTransaction(signature);
-  const parsed: CosmosBroadcastResponse = JSON.parse(res);
-
-  if (parsed.code && parsed.code > 0) {
-    throw new CosmosBroadcastError[parsed.code]();
-  }
-
-  return patchOperationWithHash(operation, parsed.txhash);
-}
-
-export default makeBroadcast({
-  broadcast,
-});

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

@@ -1,121 +0,0 @@
-import { $Shape } from "utility-types";
-import type { Operation, OperationType } from "../../types";
-import type { Core, CoreOperation } from "../../libcore/types";
-import { BigNumber } from "bignumber.js";
-import { CosmosMessage } from "./types";
-
-const translateExtraInfo = async (
-  core: Core,
-  msg: CosmosMessage,
-  type: OperationType
-) => {
-  let unwrapped: any;
-  let amount: BigNumber | undefined;
-  let address: string | undefined;
-  let cosmosSourceValidator: string;
-
-  switch (type) {
-    case "DELEGATE": {
-      unwrapped = await core.CosmosLikeMessage.unwrapMsgDelegate(msg);
-      const cosmosAmount = await unwrapped.getAmount();
-      amount = await cosmosAmount.getAmount();
-      address = await unwrapped.getValidatorAddress();
-      break;
-    }
-
-    case "UNDELEGATE": {
-      unwrapped = await core.CosmosLikeMessage.unwrapMsgUndelegate(msg);
-      const cosmosAmount = await unwrapped.getAmount();
-      amount = await cosmosAmount.getAmount();
-      address = await unwrapped.getValidatorAddress();
-      break;
-    }
-
-    case "REWARD": {
-      unwrapped =
-        await core.CosmosLikeMessage.unwrapMsgWithdrawDelegationReward(msg);
-      address = await unwrapped.getValidatorAddress();
-      amount = new BigNumber(0);
-      break;
-    }
-
-    case "REDELEGATE": {
-      unwrapped = await core.CosmosLikeMessage.unwrapMsgBeginRedelegate(msg);
-      const cosmosAmount = await unwrapped.getAmount();
-      amount = await cosmosAmount.getAmount();
-      address = await unwrapped.getValidatorDestinationAddress();
-      cosmosSourceValidator = await unwrapped.getValidatorSourceAddress();
-      return {
-        validators: [
-          {
-            address,
-            amount,
-          },
-        ],
-        cosmosSourceValidator,
-      };
-    }
-  }
-
-  const validator = {
-    address,
-    amount,
-  };
-
-  return {
-    validators: [validator],
-  };
-};
-
-async function cosmosBuildOperation({
-  core,
-  coreOperation,
-}: {
-  core: Core;
-  coreOperation: CoreOperation;
-}): Promise<Partial<Operation>> {
-  const cosmosLikeOperation = await coreOperation.asCosmosLikeOperation();
-  const cosmosLikeTransaction = await cosmosLikeOperation.getTransaction();
-  const hash = await cosmosLikeTransaction.getHash();
-  const memo = await cosmosLikeTransaction.getMemo();
-  const message = await cosmosLikeOperation.getMessage();
-  const out: $Shape<Operation> = {
-    hash,
-  };
-
-  switch (await message.getRawMessageType()) {
-    case "internal/MsgFees":
-      out.type = "FEES";
-      break;
-
-    case "cosmos-sdk/MsgDelegate":
-      out.type = "DELEGATE";
-      out.extra = await translateExtraInfo(core, message, out.type);
-      break;
-
-    case "cosmos-sdk/MsgUndelegate":
-      out.type = "UNDELEGATE";
-      out.extra = await translateExtraInfo(core, message, out.type);
-      break;
-
-    case "cosmos-sdk/MsgWithdrawDelegationReward":
-      out.type = "REWARD";
-      out.extra = await translateExtraInfo(core, message, out.type);
-      break;
-
-    case "cosmos-sdk/MsgBeginRedelegate":
-      out.type = "REDELEGATE";
-      out.extra = await translateExtraInfo(core, message, out.type);
-      break;
-  }
-
-  out.extra = { ...out.extra, id: await message.getIndex() };
-
-  if (memo) {
-    out.extra = { ...out.extra, memo };
-  }
-
-  return out;
-}
-
-export default cosmosBuildOperation;

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

@@ -1,212 +0,0 @@
-import axios, { AxiosRequestConfig } from "axios";
-import { retry } from "../../promise";
-import { FeeNotLoaded } from "@ledgerhq/errors";
-import type { Transaction, CoreCosmosLikeTransaction } from "./types";
-import type { Account, CryptoCurrency } from "../../types";
-import type { Core, CoreAccount, CoreCurrency } from "../../libcore/types";
-import getTransactionStatus from "./libcore-getTransactionStatus";
-import {
-  bigNumberToLibcoreAmount,
-  libcoreBigIntToBigNumber,
-} from "../../libcore/buildBigNumber";
-import { BigNumber } from "bignumber.js";
-import { cosmosCreateMessage } from "./message";
-import { getEnv } from "../../env";
-import { promiseAllBatched } from "../../promise";
-import { getMaxEstimatedBalance } from "./logic";
-import network from "../../network";
-
-const getBaseApiUrl = (currency: CryptoCurrency) => {
-  if (currency.id === "cosmos_testnet") {
-    return getEnv("API_COSMOS_TESTNET_BLOCKCHAIN_EXPLORER_API_ENDPOINT");
-  } else {
-    return getEnv("API_COSMOS_BLOCKCHAIN_EXPLORER_API_ENDPOINT");
-  }
-};
-
-const isStargate = (currency: CryptoCurrency) => {
-  if (currency.id === "cosmos_testnet") {
-    return getEnv("API_COSMOS_TESTNET_NODE") == "STARGATE_NODE";
-  } else {
-    return getEnv("API_COSMOS_NODE") == "STARGATE_NODE";
-  }
-};
-
-async function fetch_sequence(address: string, currency: CryptoCurrency) {
-  const namespace = "cosmos";
-  const version = "v1beta1";
-
-  if (isStargate(currency)) {
-    const url = `${getBaseApiUrl(
-      currency
-    )}/${namespace}/auth/${version}/accounts/${address}`;
-    const { data } = await network({
-      method: "GET",
-      url,
-    });
-    return data.account.sequence;
-  } else {
-    const url = `${getBaseApiUrl(currency)}/auth/accounts/${address}`;
-    const { data } = await network({
-      method: "GET",
-      url,
-    });
-    return data.result.value.sequence;
-  }
-}
-
-/// Return true if this address can be used to estimate gas.
-/// Stargate API will refuse to estimate gas for a sender that does not
-/// exist in the state, so we check the account endpoint for a non-error response
-async function canEstimateGas(account: Account, transaction: Transaction) {
-  const namespace = "cosmos";
-  const version = "v1beta1";
-
-  if (isStargate(account.currency)) {
-    const url = `${getBaseApiUrl(
-      account.currency
-    )}/${namespace}/auth/${version}/accounts/${account.freshAddress}`;
-    const request: AxiosRequestConfig = {
-      method: "GET",
-      url,
-      timeout: getEnv("GET_CALLS_TIMEOUT"),
-    };
-    const retriable = retry(() => axios(request), {
-      maxRetry: getEnv("GET_CALLS_RETRY"),
-    });
-    // FIXME: 1 - Stargate also refuses to estimate gas for a variety of other reasons,
-    // eg. insufficient amount (LL-4667), redelegating to same validator, maybe others...
-    // So getTransactionStatus called here as "pre-validation"
-    // FIXME: 2 - For redelegation getTransactionStatus doesn't check that
-    // the old and new validator exist, which also causes this to fail
-    const status = await getTransactionStatus(account, transaction, true);
-    return await retriable
-      .then((_response) => {
-        return !status.errors || Object.entries(status.errors).length === 0;
-      })
-      .catch(() => {
-        return false;
-      });
-  } else {
-    return true;
-  }
-}
-
-export async function cosmosBuildTransaction({
-  account,
-  core,
-  coreAccount,
-  coreCurrency,
-  transaction,
-  isCancelled,
-  isPartial, // is true if we just want to estimate fees and gas
-}: {
-  account: Account;
-  core: Core;
-  coreAccount: CoreAccount;
-  coreCurrency: CoreCurrency;
-  transaction: Transaction;
-  isPartial: boolean;
-  isCancelled: () => boolean;
-}): Promise<CoreCosmosLikeTransaction | null | undefined> {
-  const { gas, memo } = transaction;
-  const cosmosLikeAccount = await coreAccount.asCosmosLikeAccount();
-  if (isCancelled()) return;
-  const transactionBuilder = await cosmosLikeAccount.buildTransaction();
-  if (isCancelled()) return;
-  const accountCanEstimateGas = await canEstimateGas(account, transaction);
-  if (isCancelled()) return;
-  let messages = await cosmosCreateMessage(
-    account.freshAddress,
-    {
-      ...transaction,
-      amount: transaction.useAllAmount
-        ? getMaxEstimatedBalance(account, new BigNumber(0))
-        : transaction.amount,
-    },
-    core,
-    account.currency
-  );
-  const memoTransaction = memo || "";
-  await transactionBuilder.setMemo(memoTransaction);
-  // Gas
-  let estimatedGas: BigNumber;
-
-  if (isPartial && accountCanEstimateGas) {
-    const gasRequest = await core.CosmosGasLimitRequest.init(
-      memoTransaction,
-      messages,
-      // COSMOS_GAS_AMPLIFIER env use by JS implementation
-      // Set as 4 int in order to not break libcore implementation
-      // String(getEnv("COSMOS_GAS_AMPLIFIER"))
-      String(4)
-    );
-    estimatedGas = await libcoreBigIntToBigNumber(
-      // NOTE: With new cosmos code, this call might fail if the account hasn't been synchronized
-      // and missed a new transaction. This is because now the account sequence needs to be exact,
-      // and can't be a dummy 0 like pre-Stargate.
-      //
-      // LibCore internally calls for sequence number synchronization here, but this is a data race between the
-      // last time we read the sequence number and the instant we send the gas estimation request
-      await cosmosLikeAccount.estimateGas(gasRequest)
-    );
-  } else {
-    // 60000 is the default gas here.
-    estimatedGas = gas || new BigNumber(60000);
-  }
-
-  if (!estimatedGas.gt(0)) {
-    throw new FeeNotLoaded();
-  }
-
-  const gasAmount = await bigNumberToLibcoreAmount(
-    core,
-    coreCurrency,
-    estimatedGas
-  );
-  if (isCancelled()) return;
-  await transactionBuilder.setGas(gasAmount);
-  const gasPrice = getEnv("COSMOS_GAS_PRICE");
-  const feesBigNumber = estimatedGas
-    .multipliedBy(gasPrice)
-    .integerValue(BigNumber.ROUND_CEIL);
-  const feesAmount = await bigNumberToLibcoreAmount(
-    core,
-    coreCurrency,
-    feesBigNumber
-  );
-  if (isCancelled()) return;
-  await transactionBuilder.setFee(feesAmount);
-
-  if (transaction.useAllAmount && transaction.amount) {
-    messages = await cosmosCreateMessage(
-      account.freshAddress,
-      {
-        ...transaction,
-        amount: getMaxEstimatedBalance(account, feesBigNumber),
-      },
-      core,
-      account.currency
-    );
-  }
-
-  promiseAllBatched(
-    3,
-    messages,
-    async (message) => await transactionBuilder.addMessage(message)
-  );
-  // Signature information
-  const accNum = await cosmosLikeAccount.getAccountNumber();
-  await transactionBuilder.setAccountNumber(accNum);
-
-  if (accountCanEstimateGas) {
-    const seq = await fetch_sequence(account.freshAddress, account.currency);
-    await transactionBuilder.setSequence(seq);
-  } else {
-    await transactionBuilder.setSequence("0");
-  }
-
-  const tx = await transactionBuilder.build();
-  return tx;
-}
-export default cosmosBuildTransaction;

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

@@ -1,27 +0,0 @@
-import type { Account } from "../../types";
-import type { Core, CoreCurrency, CoreAccount } from "../../libcore/types";
-import type { Transaction } from "./types";
-import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
-import buildTransaction from "./libcore-buildTransaction";
-import BigNumber from "bignumber.js";
-
-async function cosmos(args: {
-  account: Account;
-  core: Core;
-  coreAccount: CoreAccount;
-  coreCurrency: CoreCurrency;
-  transaction: Transaction;
-  isPartial: boolean;
-  isCancelled: () => boolean;
-}): Promise<{ estimatedFees: BigNumber; estimatedGas: BigNumber } | undefined> {
-  const builded = await buildTransaction({ ...args, isPartial: true });
-  if (!builded) return;
-  const estimatedFees = await libcoreAmountToBigNumber(await builded.getFee());
-  const estimatedGas = await libcoreAmountToBigNumber(await builded.getGas());
-  return {
-    estimatedFees,
-    estimatedGas,
-  };
-}
-
-export default cosmos;