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

package/src/families/crypto_org/js-broadcast.ts

@@ -1,31 +0,0 @@
-import type { Operation, SignedOperation, Account } from "@ledgerhq/types-live";
-import { patchOperationWithHash } from "../../operation";
-import { broadcastTransaction } from "./api";
-import { CryptoOrgErrorBroadcasting } from "./errors";
-
-function isBroadcastTxFailure(result) {
-  return !!result.code;
-}
-
-/**
- * Broadcast the signed transaction
- */
-const broadcast = async ({
-  account,
-  signedOperation: { signature, operation },
-}: {
-  account: Account;
-  signedOperation: SignedOperation;
-}): Promise<Operation> => {
-  const broadcastResponse = await broadcastTransaction(signature, account.currency.id);
-
-  if (isBroadcastTxFailure(broadcastResponse)) {
-    throw new CryptoOrgErrorBroadcasting(
-      `broadcasting failed with error code ${broadcastResponse.code}`,
-    );
-  }
-
-  return patchOperationWithHash(operation, broadcastResponse.transactionHash);
-};
-
-export default broadcast;

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

@@ -1,57 +0,0 @@
-import type { Transaction } from "./types";
-import type { Account } from "@ledgerhq/types-live";
-import { Units, utils } from "@crypto-org-chain/chain-jslib";
-import { SIGN_MODE } from "@crypto-org-chain/chain-jslib/lib/dist/transaction/types";
-import { getAccountParams } from "./api/sdk";
-import { getCroSdk } from "./logic";
-
-const getTransactionAmount = (a: Account, t: Transaction) => {
-  const croSdk = getCroSdk(a.currency.id);
-
-  switch (t.mode) {
-    case "send":
-      if (t.useAllAmount) {
-        const balanceMinusFee = a.balance.minus(t.fees || 0);
-        return new croSdk.Coin(balanceMinusFee.toString(), Units.BASE);
-      } else {
-        return new croSdk.Coin(t.amount.toString(), Units.BASE);
-      }
-
-    default:
-      throw new Error("Unknown mode in transaction");
-  }
-};
-
-/**
- *
- * @param {Account} a
- * @param {Transaction} t
- */
-export const buildTransaction = async (a: Account, t: Transaction, publicKey: string) => {
-  const croSdk = getCroSdk(a.currency.id);
-  const address = a.freshAddress;
-  const { accountNumber, sequence } = await getAccountParams(address, a.currency.id);
-  const rawTx = new croSdk.RawTransaction();
-  rawTx.setFee(new croSdk.Coin((t.fees || 0).toString(), Units.BASE));
-
-  const msgSend = new croSdk.bank.MsgSend({
-    fromAddress: address,
-    toAddress: t.recipient,
-    amount: getTransactionAmount(a, t),
-  });
-
-  const { memo } = t;
-  const memoTransaction = memo || "";
-  rawTx.setMemo(memoTransaction);
-
-  const signableTx = rawTx
-    .appendMessage(msgSend)
-    .addSigner({
-      publicKey: utils.Bytes.fromHexString(publicKey),
-      accountNumber: new utils.Big(accountNumber),
-      accountSequence: new utils.Big(sequence),
-      signMode: SIGN_MODE.LEGACY_AMINO_JSON,
-    })
-    .toSignable();
-  return signableTx;
-};

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

@@ -1,25 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { AccountLike, Account } from "@ledgerhq/types-live";
-import { getMainAccount } from "../../account";
-import type { Transaction } from "./types";
-import getEstimatedFees from "./js-getFeesForTransaction";
-
-/**
- * Returns the maximum possible amount for transaction
- *
- * @param {Object} param - the account, parentAccount and transaction
- */
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-}: {
-  account: AccountLike;
-  parentAccount: Account | null | undefined;
-  transaction: Transaction | null | undefined;
-}): Promise<BigNumber> => {
-  const a = getMainAccount(account, parentAccount);
-  const fees = await getEstimatedFees();
-  return BigNumber.max(0, a.spendableBalance.minus(fees));
-};
-
-export default estimateMaxSpendable;

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

@@ -1,58 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import {
-  NotEnoughBalance,
-  RecipientRequired,
-  InvalidAddress,
-  FeeNotLoaded,
-  AmountRequired,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-} from "@ledgerhq/errors";
-import type { Account } from "@ledgerhq/types-live";
-import type { Transaction, TransactionStatus } from "./types";
-import { isValidAddress } from "./logic";
-
-const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
-  const errors: {
-    fees?: Error;
-    amount?: Error;
-    recipient?: Error;
-  } = {};
-  const warnings = {};
-  const useAllAmount = !!t.useAllAmount;
-
-  if (!t.fees) {
-    errors.fees = new FeeNotLoaded();
-  }
-
-  const estimatedFees = t.fees || new BigNumber(0);
-  const totalSpent = useAllAmount ? a.balance : new BigNumber(t.amount).plus(estimatedFees);
-  const amount = useAllAmount ? a.balance.minus(estimatedFees) : new BigNumber(t.amount);
-
-  if (totalSpent.gt(a.balance)) {
-    errors.amount = new NotEnoughBalance();
-  }
-
-  if (!amount.gt(0)) {
-    errors.amount = new AmountRequired();
-  }
-
-  if (!t.recipient) {
-    errors.recipient = new RecipientRequired();
-  } else if (!isValidAddress(t.recipient, a.currency.id)) {
-    errors.recipient = new InvalidAddress("", {
-      currencyName: a.currency.name,
-    });
-  } else if (t.mode === "send" && a.freshAddress === t.recipient) {
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-  }
-
-  return Promise.resolve({
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-  });
-};
-
-export default getTransactionStatus;

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

@@ -1,152 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { Observable } from "rxjs";
-import { utils } from "@crypto-org-chain/chain-jslib";
-import { FeeNotLoaded } from "@ledgerhq/errors";
-import CryptoOrgApp from "@ledgerhq/hw-app-cosmos";
-import { CryptoOrgWrongSignatureHeader, CryptoOrgSignatureSize } from "./errors";
-import type { CryptoOrgOperation, Transaction } from "./types";
-import type { Account, SignOperationFnSignature } from "@ledgerhq/types-live";
-import { encodeOperationId } from "../../operation";
-import { withDevice } from "../../hw/deviceAccess";
-import { buildTransaction } from "./js-buildTransaction";
-import { isTestNet } from "./logic";
-
-const buildOptimisticOperation = (
-  account: Account,
-  transaction: Transaction,
-  fee: BigNumber,
-): CryptoOrgOperation => {
-  const type = "OUT";
-  const value = new BigNumber(transaction.amount).plus(fee);
-  const operation: CryptoOrgOperation = {
-    id: encodeOperationId(account.id, "", type),
-    hash: "",
-    type,
-    value,
-    fee,
-    blockHash: null,
-    blockHeight: null,
-    senders: [account.freshAddress],
-    recipients: [transaction.recipient].filter(Boolean),
-    accountId: account.id,
-    date: new Date(),
-    extra: {
-      memo: transaction.memo,
-    },
-  };
-  return operation;
-};
-
-function convertASN1toBase64(signature) {
-  // 0 0x30: a header byte indicating a compound structure
-  // 1 A 1-byte length descriptor for all what follows (ignore)
-  // 2 0x02: a header byte indicating an integer
-  // 3 A 1-byte length descriptor for the R value
-  // 4 The R coordinate, as a big-endian integer
-  //   0x02: a header byte indicating an integer
-  //   A 1-byte length descriptor for the S value
-  //   The S coordinate, as a big-endian integer
-  //  = 7 bytes of overhead
-  if (signature[0] !== 0x30) {
-    throw new CryptoOrgWrongSignatureHeader();
-  }
-
-  // decode DER string format
-  const rOffset = 4;
-  const rLen = signature[3];
-  const sLen = signature[4 + rLen + 1]; // skip over following 0x02 type prefix for s
-
-  const sOffset = signature.length - sLen;
-  const sigR = signature.slice(rOffset, rOffset + rLen); // skip e.g. 3045022100 and pad
-
-  const sigS = signature.slice(sOffset);
-  const newSigR = padZero(sigR, 32);
-  const newSigS = padZero(sigS, 32);
-
-  const signatureFormatted = Buffer.concat([newSigR, newSigS]);
-
-  if (signatureFormatted.length !== 64) {
-    throw new CryptoOrgSignatureSize();
-  }
-
-  return signatureFormatted;
-}
-
-function padZero(original_array: Uint8Array, wanted_length: number) {
-  const new_array = new Uint8Array(wanted_length);
-
-  for (let i = wanted_length - 1; i >= 0; i--) {
-    const j = wanted_length - 1 - i;
-    const new_i = original_array.length - 1 - j;
-
-    if (new_i >= 0 && new_i < original_array.length) {
-      new_array[i] = original_array[new_i];
-    } else {
-      new_array[i] = 0;
-    }
-  }
-
-  return new_array;
-}
-
-/**
- * Sign Transaction with Ledger hardware
- */
-const signOperation: SignOperationFnSignature<Transaction> = ({ account, deviceId, transaction }) =>
-  withDevice(deviceId)(
-    transport =>
-      new Observable(o => {
-        async function main() {
-          o.next({
-            type: "device-signature-requested",
-          });
-
-          if (!transaction.fees) {
-            throw new FeeNotLoaded();
-          }
-
-          // Get the public key
-          const hwApp = new CryptoOrgApp(transport);
-          const cointype = isTestNet(account.currency.id) ? "tcro" : "cro";
-          const { publicKey } = await hwApp.getAddress(account.freshAddressPath, cointype, false);
-          const unsigned = await buildTransaction(account, transaction, publicKey);
-          // Sign by device
-          const { signature } = await hwApp.sign(
-            account.freshAddressPath,
-            unsigned.toSignDocument(0).toUint8Array(),
-          );
-
-          // Ledger has encoded the sig in ASN1 DER format, but we need a 64-byte buffer of <r,s>
-          // DER-encoded signature from Ledger
-          if (signature != null) {
-            const base64Sig = convertASN1toBase64(signature);
-            const signed = unsigned
-              .setSignature(0, utils.Bytes.fromUint8Array(new Uint8Array(base64Sig)))
-              .toSigned()
-              .getHexEncoded();
-            o.next({
-              type: "device-signature-granted",
-            });
-            const operation = buildOptimisticOperation(
-              account,
-              transaction,
-              transaction.fees ?? new BigNumber(0),
-            );
-            o.next({
-              type: "signed",
-              signedOperation: {
-                operation,
-                signature: signed,
-              },
-            });
-          }
-        }
-
-        main().then(
-          () => o.complete(),
-          e => o.error(e),
-        );
-      }),
-  );
-
-export default signOperation;

package/src/families/crypto_org/js-transaction.ts

@@ -1,44 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { Account } from "@ledgerhq/types-live";
-import type { Transaction } from "./types";
-import getEstimatedFees from "./js-getFeesForTransaction";
-
-const sameFees = (a, b) => (!a || !b ? a === b : a.eq(b));
-
-/**
- * Create an empty transaction
- *
- * @returns {Transaction}
- */
-export const createTransaction = (): Transaction => ({
-  family: "crypto_org",
-  mode: "send",
-  amount: new BigNumber(0),
-  recipient: "",
-  useAllAmount: false,
-  fees: new BigNumber(0),
-  memo: null,
-});
-
-/**
- * Prepare transaction before checking status
- *
- * @param {Account} a
- * @param {Transaction} t
- */
-export const prepareTransaction = async (a: Account, t: Transaction) => {
-  let fees = t.fees;
-  let memo = t.memo;
-
-  fees = await getEstimatedFees();
-
-  if (t.mode !== "send" && !memo) {
-    memo = "Ledger Live";
-  }
-
-  if (t.memo !== memo || !sameFees(t.fees, fees)) {
-    return { ...t, memo, fees };
-  }
-
-  return t;
-};

package/src/families/elrond/js-broadcast.ts

@@ -1,15 +0,0 @@
-import type { BroadcastFnSignature, Operation } from "@ledgerhq/types-live";
-import { patchOperationWithHash } from "../../operation";
-import { broadcastTransaction } from "./api";
-
-/**
- * Broadcast the signed transaction
- * @param {signature: string, operation: string} signedOperation
- */
-const broadcast: BroadcastFnSignature = async ({ signedOperation }): Promise<Operation> => {
-  const hash = await broadcastTransaction(signedOperation);
-
-  return patchOperationWithHash(signedOperation.operation, hash);
-};
-
-export default broadcast;

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

@@ -1,48 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { Account, AccountLike } from "@ledgerhq/types-live";
-import { getMainAccount } from "../../account";
-import type { Transaction } from "./types";
-import { getFees } from "./api";
-import { createTransaction } from "./js-transaction";
-
-/**
- * Returns the maximum possible amount for transaction
- *
- * @param {Object} param - the account, parentAccount and transaction
- */
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-  transaction,
-}: {
-  account: AccountLike;
-  parentAccount: Account | null | undefined;
-  transaction: Transaction | null | undefined;
-}): Promise<BigNumber> => {
-  const mainAccount = getMainAccount(account, parentAccount);
-  const tx: Transaction = {
-    ...createTransaction(),
-    subAccountId: account.type === "Account" ? null : account.id,
-    ...transaction,
-    useAllAmount: true,
-  };
-
-  const tokenAccount =
-    tx.subAccountId &&
-    mainAccount.subAccounts &&
-    mainAccount.subAccounts.find(ta => ta.id === tx.subAccountId);
-
-  if (tokenAccount) {
-    return tokenAccount.balance;
-  }
-
-  const fees = await getFees(tx);
-
-  if (fees.gt(mainAccount.spendableBalance)) {
-    return new BigNumber(0);
-  }
-
-  return mainAccount.spendableBalance.minus(fees);
-};
-
-export default estimateMaxSpendable;

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

@@ -1,140 +0,0 @@
-import BigNumber from "bignumber.js";
-import {
-  NotEnoughBalance,
-  RecipientRequired,
-  InvalidAddress,
-  FeeNotLoaded,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  FeeTooHigh,
-  AmountRequired,
-} from "@ledgerhq/errors";
-import { formatCurrencyUnit } from "../../currencies";
-import { getAccountCurrency } from "../../account";
-import { DECIMALS_LIMIT, MIN_DELEGATION_AMOUNT } from "./constants";
-import type { ElrondAccount, Transaction, TransactionStatus } from "./types";
-import { isValidAddress, isSelfTransaction, isAmountSpentFromBalance } from "./logic";
-import {
-  ElrondDecimalsLimitReached,
-  ElrondMinDelegatedAmountError,
-  ElrondMinUndelegatedAmountError,
-  ElrondDelegationBelowMinimumError,
-  NotEnoughEGLDForFees,
-} from "./errors";
-
-const getTransactionStatus = async (
-  a: ElrondAccount,
-  t: Transaction,
-): Promise<TransactionStatus> => {
-  const errors: Record<string, Error> = {};
-  const warnings: Record<string, Error> = {};
-
-  if (!t.recipient) {
-    errors.recipient = new RecipientRequired();
-  } else if (isSelfTransaction(a, t)) {
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-  } else if (!isValidAddress(t.recipient)) {
-    errors.recipient = new InvalidAddress("", {
-      currencyName: a.currency.name,
-    });
-  }
-
-  if (!t.fees) {
-    errors.fees = new FeeNotLoaded();
-  }
-
-  if (
-    !errors.amount &&
-    t.amount.eq(0) &&
-    !t.useAllAmount &&
-    !["unDelegate", "withdraw", "reDelegateRewards", "claimRewards"].includes(t.mode)
-  ) {
-    errors.amount = new AmountRequired();
-  }
-
-  let totalSpent = new BigNumber(0); // Will be in token amount for token transacations
-  let totalSpentEgld = new BigNumber(0); // Amount spent in main currency (EGLD)
-
-  const tokenAccount =
-    (t.subAccountId && a.subAccounts && a.subAccounts.find(ta => ta.id === t.subAccountId)) || null;
-
-  if (tokenAccount) {
-    totalSpent = t.amount;
-    totalSpentEgld = t.fees || new BigNumber(0);
-
-    if (!errors.amount && t.amount.gt(tokenAccount.balance)) {
-      errors.amount = new NotEnoughBalance();
-    }
-
-    if (!errors.amount && !totalSpentEgld.decimalPlaces(DECIMALS_LIMIT).isEqualTo(totalSpentEgld)) {
-      errors.amount = new ElrondDecimalsLimitReached();
-    }
-  } else {
-    totalSpent = totalSpentEgld = isAmountSpentFromBalance(t.mode)
-      ? t.fees?.plus(t.amount) || t.amount
-      : t.fees || new BigNumber(0);
-
-    if (t.mode === "send" && t.fees && t.amount.div(10).lt(t.fees)) {
-      warnings.feeTooHigh = new FeeTooHigh();
-    }
-
-    // All delegate and undelegate transactions must have an amount >= 1 EGLD
-    if (!errors.amount && t.amount.lt(MIN_DELEGATION_AMOUNT)) {
-      const formattedAmount = formatCurrencyUnit(
-        getAccountCurrency(a).units[0],
-        MIN_DELEGATION_AMOUNT,
-        {
-          showCode: true,
-        },
-      );
-      if (t.mode === "delegate") {
-        errors.amount = new ElrondMinDelegatedAmountError("", {
-          formattedAmount,
-        });
-      } else if (t.mode === "unDelegate") {
-        errors.amount = new ElrondMinUndelegatedAmountError("", {
-          formattedAmount,
-        });
-      }
-    }
-
-    // When undelegating, unless undelegating all, the delegation must remain >= 1 EGLD
-    const delegationBalance = a.elrondResources.delegations.find(
-      d => d.contract === t.recipient,
-    )?.userActiveStake;
-
-    const delegationRemainingBalance = new BigNumber(delegationBalance || 0).minus(t.amount);
-
-    const delegationBalanceForbidden =
-      delegationRemainingBalance.gt(0) && delegationRemainingBalance.lt(MIN_DELEGATION_AMOUNT);
-
-    if (!errors.amount && t.mode === "unDelegate" && delegationBalanceForbidden) {
-      const formattedAmount = formatCurrencyUnit(
-        getAccountCurrency(a).units[0],
-        MIN_DELEGATION_AMOUNT,
-        {
-          showCode: true,
-        },
-      );
-      errors.amount = new ElrondDelegationBelowMinimumError("", {
-        formattedAmount,
-      });
-    }
-  }
-
-  if (!errors.amount && totalSpentEgld.gt(a.spendableBalance)) {
-    errors.amount =
-      tokenAccount || !["delegate", "send"].includes(t.mode)
-        ? new NotEnoughEGLDForFees()
-        : new NotEnoughBalance();
-  }
-
-  return Promise.resolve({
-    errors,
-    warnings,
-    estimatedFees: t.fees || new BigNumber(0),
-    amount: t.amount,
-    totalSpent,
-  });
-};
-
-export default getTransactionStatus;