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

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

@@ -1,106 +0,0 @@
-import invariant from "invariant";
-import { Memo, Operation as StellarSdkOperation, xdr } from "@stellar/stellar-sdk";
-import { AmountRequired, FeeNotLoaded, NetworkDown } from "@ledgerhq/errors";
-import type { Account } from "@ledgerhq/types-live";
-import type { Transaction } from "./types";
-import {
-  buildPaymentOperation,
-  buildCreateAccountOperation,
-  buildTransactionBuilder,
-  buildChangeTrustOperation,
-  loadAccount,
-} from "./api";
-import { getRecipientAccount, getAmountValue } from "./logic";
-import { StellarAssetRequired, StellarMuxedAccountNotExist } from "../../errors";
-
-/**
- * @param {Account} a
- * @param {Transaction} t
- */
-export const buildTransaction = async (account: Account, transaction: Transaction) => {
-  const { recipient, networkInfo, fees, memoType, memoValue, mode, assetCode, assetIssuer } =
-    transaction;
-
-  if (!fees) {
-    throw new FeeNotLoaded();
-  }
-
-  const source = await loadAccount(account.freshAddress);
-
-  if (!source) {
-    throw new NetworkDown();
-  }
-
-  invariant(networkInfo && networkInfo.family === "stellar", "stellar family");
-
-  const transactionBuilder = buildTransactionBuilder(source, fees);
-  let operation: xdr.Operation<StellarSdkOperation.ChangeTrust> | null = null;
-
-  if (mode === "changeTrust") {
-    if (!assetCode || !assetIssuer) {
-      throw new StellarAssetRequired("");
-    }
-
-    operation = buildChangeTrustOperation(assetCode, assetIssuer);
-  } else {
-    // Payment
-    const amount = getAmountValue(account, transaction, fees);
-
-    if (!amount) {
-      throw new AmountRequired();
-    }
-
-    const recipientAccount = await getRecipientAccount({
-      account,
-      recipient: transaction.recipient,
-    });
-
-    if (recipientAccount?.id) {
-      operation = buildPaymentOperation({
-        destination: recipient,
-        amount,
-        assetCode,
-        assetIssuer,
-      });
-    } else {
-      if (recipientAccount?.isMuxedAccount) {
-        throw new StellarMuxedAccountNotExist("");
-      }
-
-      operation = buildCreateAccountOperation(recipient, amount);
-    }
-  }
-
-  transactionBuilder.addOperation(operation);
-
-  let memo: Memo | null = null;
-
-  if (memoType && memoValue) {
-    switch (memoType) {
-      case "MEMO_TEXT":
-        memo = Memo.text(memoValue);
-        break;
-
-      case "MEMO_ID":
-        memo = Memo.id(memoValue);
-        break;
-
-      case "MEMO_HASH":
-        memo = Memo.hash(memoValue);
-        break;
-
-      case "MEMO_RETURN":
-        memo = Memo.return(memoValue);
-        break;
-    }
-  }
-
-  if (memo) {
-    transactionBuilder.addMemo(memo);
-  }
-
-  const built = transactionBuilder.setTimeout(0).build();
-  return built;
-};
-
-export default buildTransaction;

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

@@ -1,24 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { Transaction } from "./types";
-
-/**
- * Create an empty transaction
- *
- * @returns {Transaction}
- */
-const createTransaction = (): Transaction => ({
-  family: "stellar",
-  amount: new BigNumber(0),
-  baseReserve: null,
-  networkInfo: null,
-  fees: null,
-  recipient: "",
-  memoValue: null,
-  memoType: null,
-  useAllAmount: false,
-  mode: "send",
-  assetCode: "",
-  assetIssuer: "",
-});
-
-export default createTransaction;

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

@@ -1,32 +0,0 @@
-import { getMainAccount } from "../../account";
-import createTransaction from "./js-createTransaction";
-import prepareTransaction from "./js-prepareTransaction";
-import getTransactionStatus from "./js-getTransactionStatus";
-import type { Account, AccountLike } from "@ledgerhq/types-live";
-import type { Transaction } from "./types";
-import BigNumber from "bignumber.js";
-
-const notCreatedStellarMockAddress = "GAW46JE3SHIAYLNNNQCAZFQ437WB5ZH7LDRDWR5LVDWHCTHCKYB6RCCH";
-
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-  transaction,
-}: {
-  account: AccountLike;
-  parentAccount: Account | null | undefined;
-  transaction: Transaction | null | undefined;
-}): Promise<BigNumber> => {
-  const mainAccount = getMainAccount(account, parentAccount);
-  const t = await prepareTransaction(mainAccount, {
-    ...createTransaction(),
-    ...transaction,
-    recipient: transaction?.recipient || notCreatedStellarMockAddress,
-    // not used address
-    useAllAmount: true,
-  });
-  const s = await getTransactionStatus(mainAccount, t);
-  return s.amount.gte(0) ? s.amount : new BigNumber(0);
-};
-
-export default estimateMaxSpendable;

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

@@ -1,208 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import {
-  AccountAwaitingSendPendingOperations,
-  AmountRequired,
-  NotEnoughBalance,
-  FeeNotLoaded,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  NotEnoughSpendableBalance,
-  NotEnoughBalanceBecauseDestinationNotCreated,
-  RecipientRequired,
-  InvalidAddress,
-} from "@ledgerhq/errors";
-import {
-  StellarWrongMemoFormat,
-  StellarAssetRequired,
-  StellarAssetNotAccepted,
-  StellarAssetNotFound,
-  StellarNotEnoughNativeBalance,
-  StellarFeeSmallerThanRecommended,
-  StellarFeeSmallerThanBase,
-  StellarNotEnoughNativeBalanceToAddTrustline,
-  StellarMuxedAccountNotExist,
-  StellarSourceHasMultiSign,
-} from "../../errors";
-import { findSubAccountById } from "../../account";
-import { formatCurrencyUnit } from "../../currencies";
-import type { Account, TokenAccount } from "@ledgerhq/types-live";
-import type { Transaction } from "./types";
-import { isAddressValid, isAccountMultiSign, isMemoValid, getRecipientAccount } from "./logic";
-import { BASE_RESERVE, MIN_BALANCE } from "./api";
-
-const getTransactionStatus = async (
-  a: Account,
-  t: Transaction,
-): Promise<{
-  errors: Record<string, Error>;
-  warnings: Record<string, Error>;
-  estimatedFees: BigNumber;
-  amount: BigNumber;
-  totalSpent: BigNumber;
-}> => {
-  const errors: Record<string, Error> = {};
-  const warnings: Record<string, Error> = {};
-  const useAllAmount = !!t.useAllAmount;
-
-  const destinationNotExistMessage = new NotEnoughBalanceBecauseDestinationNotCreated("", {
-    minimalAmount: `${MIN_BALANCE} XLM`,
-  });
-
-  if (a.pendingOperations.length > 0) {
-    throw new AccountAwaitingSendPendingOperations();
-  }
-
-  if (!t.fees || !t.baseReserve) {
-    errors.fees = new FeeNotLoaded();
-  }
-
-  const estimatedFees = !t.fees ? new BigNumber(0) : t.fees;
-  const baseReserve = !t.baseReserve ? new BigNumber(0) : t.baseReserve;
-  const isAssetPayment = t.subAccountId && t.assetCode && t.assetIssuer;
-  const nativeBalance = a.balance;
-  const nativeAmountAvailable = a.spendableBalance.minus(estimatedFees);
-
-  let amount = new BigNumber(0);
-  let maxAmount = new BigNumber(0);
-  let totalSpent = new BigNumber(0);
-
-  // Enough native balance to cover transaction (with required reserve + fees)
-  if (!errors.amount && nativeAmountAvailable.lt(0)) {
-    errors.amount = new StellarNotEnoughNativeBalance();
-  }
-
-  // Entered fee is smaller than base fee
-  if (estimatedFees.lt(t.networkInfo?.baseFee || 0)) {
-    errors.transaction = new StellarFeeSmallerThanBase();
-    // Entered fee is smaller than recommended
-  } else if (estimatedFees.lt(t.networkInfo?.fees || 0)) {
-    warnings.transaction = new StellarFeeSmallerThanRecommended();
-  }
-
-  // Operation specific checks
-  if (t.mode === "changeTrust") {
-    // Check asset provided
-    if (!t.assetCode || !t.assetIssuer) {
-      // This is unlikely
-      errors.transaction = new StellarAssetRequired("");
-    }
-
-    // Has enough native balance to add new trustline
-    if (nativeAmountAvailable.minus(BASE_RESERVE).lt(0)) {
-      errors.amount = new StellarNotEnoughNativeBalanceToAddTrustline();
-    }
-  } else {
-    // Payment
-    // Check recipient address
-    if (!t.recipient) {
-      errors.recipient = new RecipientRequired("");
-    } else if (!isAddressValid(t.recipient)) {
-      errors.recipient = new InvalidAddress("", {
-        currencyName: a.currency.name,
-      });
-    } else if (a.freshAddress === t.recipient) {
-      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-    }
-
-    const recipientAccount = await getRecipientAccount({
-      account: a,
-      recipient: t.recipient,
-    });
-
-    // Check recipient account
-    if (!recipientAccount?.id && !errors.recipient && !warnings.recipient) {
-      if (recipientAccount?.isMuxedAccount) {
-        errors.recipient = new StellarMuxedAccountNotExist();
-      } else {
-        if (isAssetPayment) {
-          errors.recipient = destinationNotExistMessage;
-        } else {
-          warnings.recipient = destinationNotExistMessage;
-        }
-      }
-    }
-
-    // Asset payment
-    if (isAssetPayment) {
-      const asset = findSubAccountById(a, t.subAccountId || "") as TokenAccount;
-
-      if (asset === null) {
-        // This is unlikely
-        throw new StellarAssetNotFound();
-      }
-
-      // Check recipient account accepts asset
-      if (
-        recipientAccount?.id &&
-        !errors.recipient &&
-        !warnings.recipient &&
-        !recipientAccount.assetIds.includes(`${t.assetCode}:${t.assetIssuer}`)
-      ) {
-        errors.recipient = new StellarAssetNotAccepted("", {
-          assetCode: t.assetCode,
-        });
-      }
-
-      const assetBalance = asset?.balance || new BigNumber(0);
-
-      maxAmount = asset?.spendableBalance || assetBalance;
-      amount = useAllAmount ? maxAmount : t.amount;
-      totalSpent = amount;
-
-      if (!errors.amount && amount.gt(assetBalance)) {
-        errors.amount = new NotEnoughBalance();
-      }
-    } else {
-      // Native payment
-      maxAmount = nativeAmountAvailable;
-      amount = useAllAmount ? maxAmount : t.amount || 0;
-
-      if (amount.gt(maxAmount)) {
-        errors.amount = new NotEnoughBalance();
-      }
-
-      totalSpent = useAllAmount ? nativeAmountAvailable : t.amount.plus(estimatedFees);
-
-      // Need to send at least 1 XLM to create an account
-      if (!errors.recipient && !recipientAccount?.id && !errors.amount && amount.lt(10000000)) {
-        errors.amount = destinationNotExistMessage;
-      }
-
-      if (totalSpent.gt(nativeBalance.minus(baseReserve))) {
-        errors.amount = new NotEnoughSpendableBalance(undefined, {
-          minimumAmount: formatCurrencyUnit(a.currency.units[0], baseReserve, {
-            disableRounding: true,
-            showCode: true,
-          }),
-        });
-      }
-
-      if (!errors.recipient && !errors.amount && (amount.lt(0) || totalSpent.gt(nativeBalance))) {
-        errors.amount = new NotEnoughBalance();
-        totalSpent = new BigNumber(0);
-        amount = new BigNumber(0);
-      }
-    }
-
-    if (!errors.amount && amount.eq(0)) {
-      errors.amount = new AmountRequired();
-    }
-  }
-
-  if (await isAccountMultiSign(a)) {
-    errors.recipient = new StellarSourceHasMultiSign();
-  }
-
-  if (t.memoType && t.memoValue && !isMemoValid(t.memoType, t.memoValue)) {
-    errors.transaction = new StellarWrongMemoFormat();
-  }
-
-  return Promise.resolve({
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-  });
-};
-
-export default getTransactionStatus;

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

@@ -1,22 +0,0 @@
-import invariant from "invariant";
-import type { Account } from "@ledgerhq/types-live";
-import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { fetchAccountNetworkInfo } from "./api";
-import { getAssetCodeIssuer } from "./logic";
-import type { Transaction } from "./types";
-
-const prepareTransaction = async (a: Account, t: Transaction): Promise<Transaction> => {
-  const networkInfo: any = t.networkInfo || (await fetchAccountNetworkInfo(a));
-  invariant(networkInfo.family === "stellar", "stellar networkInfo expected");
-  const fees = t.fees || networkInfo.fees;
-  const baseReserve = t.baseReserve || networkInfo.baseReserve;
-  const [assetCode, assetIssuer] = getAssetCodeIssuer(t);
-
-  if (t.networkInfo !== networkInfo || t.fees !== fees || t.baseReserve !== baseReserve) {
-    return defaultUpdateTransaction(t, { networkInfo, fees, baseReserve, assetCode, assetIssuer });
-  }
-
-  return defaultUpdateTransaction(t, { assetCode, assetIssuer });
-};
-
-export default prepareTransaction;

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

@@ -1,117 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { Observable } from "rxjs";
-import Stellar from "@ledgerhq/hw-app-str";
-import { FeeNotLoaded } from "@ledgerhq/errors";
-import type { Account, SignOperationFnSignature } from "@ledgerhq/types-live";
-import { withDevice } from "../../hw/deviceAccess";
-import type { StellarOperation, Transaction } from "./types";
-import { buildTransaction } from "./js-buildTransaction";
-import { fetchSequence } from "./api";
-import { getAmountValue } from "./logic";
-import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-
-const buildOptimisticOperation = async (
-  account: Account,
-  transaction: Transaction,
-): Promise<StellarOperation> => {
-  const transactionSequenceNumber = await fetchSequence(account);
-  const fees = transaction.fees ?? new BigNumber(0);
-  const type = transaction.mode === "changeTrust" ? "OPT_IN" : "OUT";
-
-  const operation: StellarOperation = {
-    id: encodeOperationId(account.id, "", type),
-    hash: "",
-    type,
-    value: transaction.subAccountId ? fees : getAmountValue(account, transaction, fees),
-    fee: fees,
-    blockHash: null,
-    blockHeight: null,
-    senders: [account.freshAddress],
-    recipients: [transaction.recipient],
-    accountId: account.id,
-    date: new Date(),
-    // FIXME: Javascript number may be not precise enough
-    transactionSequenceNumber: transactionSequenceNumber?.plus(1).toNumber(),
-    extra: {
-      ledgerOpType: type,
-    },
-  };
-
-  const { subAccountId } = transaction;
-  const { subAccounts } = account;
-
-  const tokenAccount = !subAccountId
-    ? null
-    : subAccounts && subAccounts.find(ta => ta.id === subAccountId);
-
-  if (tokenAccount && subAccountId) {
-    operation.subOperations = [
-      {
-        id: `${subAccountId}--OUT`,
-        hash: "",
-        type: "OUT",
-        value: transaction.useAllAmount ? tokenAccount.balance : transaction.amount,
-        fee: new BigNumber(0),
-        blockHash: null,
-        blockHeight: null,
-        senders: [account.freshAddress],
-        recipients: [transaction.recipient],
-        accountId: subAccountId,
-        date: new Date(),
-        extra: {
-          ledgerOpType: type,
-        },
-      },
-    ];
-  }
-
-  return operation;
-};
-
-/**
- * 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",
-          });
-
-          // Fees are loaded during prepareTransaction
-          if (!transaction.fees) {
-            throw new FeeNotLoaded();
-          }
-
-          const unsigned = await buildTransaction(account, transaction);
-          const unsignedPayload: Buffer = Buffer.from(unsigned.signatureBase());
-          // Sign by device
-          const hwApp = new Stellar(transport);
-          const { signature } = await hwApp.signTransaction(
-            account.freshAddressPath,
-            unsignedPayload,
-          );
-          unsigned.addSignature(account.freshAddress, signature.toString("base64"));
-          o.next({
-            type: "device-signature-granted",
-          });
-          const operation = await buildOptimisticOperation(account, transaction);
-          o.next({
-            type: "signed",
-            signedOperation: {
-              operation,
-              signature: unsigned.toXDR(),
-            },
-          });
-        }
-
-        main().then(
-          () => o.complete(),
-          e => o.error(e),
-        );
-      }),
-  );
-
-export default signOperation;

package/src/families/vechain/bridge/js-estimateMaxSpendable.ts

@@ -1,20 +0,0 @@
-import BigNumber from "bignumber.js";
-import { calculateGasFees } from "../utils/transaction-utils";
-import type { Transaction } from "../types";
-import { AccountLike } from "@ledgerhq/types-live";
-
-export const estimateMaxSpendable = async (inputs: {
-  account: AccountLike;
-  transaction: Transaction;
-}): Promise<BigNumber> => {
-  const { account, transaction } = inputs;
-
-  if (account.type === "Account" || !transaction) {
-    return account.balance;
-  }
-
-  const { estimatedGasFees: maxTokenFees } = await calculateGasFees(transaction, true);
-  const spendable = account.balance.minus(maxTokenFees);
-  if (spendable.gt(0)) return account.balance.minus(maxTokenFees);
-  return new BigNumber(0);
-};

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

@@ -1,22 +0,0 @@
-import type { Operation, SignedOperation } from "@ledgerhq/types-live";
-import { patchOperationWithHash } from "../../operation";
-import { Transaction } from "thor-devkit";
-import { submit } from "./api";
-
-/**
- * Broadcast the signed transaction
- * @param {signature: string, operation: string} signedOperation
- */
-const broadcast = async ({
-  signedOperation: { signature, operation, rawData },
-}: {
-  signedOperation: SignedOperation;
-}): Promise<Operation> => {
-  const transaction = new Transaction((rawData as unknown as Transaction).body);
-  transaction.signature = Buffer.from(signature, "hex");
-  const hash = await submit(transaction);
-
-  return patchOperationWithHash(operation, hash);
-};
-
-export default broadcast;

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

@@ -1,78 +0,0 @@
-import {
-  AmountRequired,
-  FeeNotLoaded,
-  InvalidAddress,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  NotEnoughBalance,
-  RecipientRequired,
-} from "@ledgerhq/errors";
-import type { TransactionStatus } from "./types";
-import type { Transaction } from "./types";
-import { Account } from "@ledgerhq/types-live";
-import { isValid } from "./utils/address-utils";
-import BigNumber from "bignumber.js";
-import { NotEnoughVTHO } from "./errors";
-import { calculateTransactionInfo } from "./utils/transaction-utils";
-
-const getTransactionStatus = async (
-  account: Account,
-  transaction: Transaction,
-): Promise<TransactionStatus> => {
-  const { freshAddress, currency, subAccounts } = account;
-  const { body, recipient, amount } = transaction;
-  const errors: Record<string, Error> = {};
-  const warnings: Record<string, Error> = {};
-  const { isTokenAccount, spendableBalance } = await calculateTransactionInfo(
-    account,
-    transaction,
-    {
-      estimatedGas: body.gas as number,
-      estimatedGasFees: new BigNumber(transaction.estimatedFees),
-    },
-  );
-
-  if (!body || !body.gas) {
-    errors.fees = new FeeNotLoaded();
-  }
-
-  if (!recipient) {
-    errors.recipient = new RecipientRequired();
-  } else if (freshAddress.toLowerCase() === recipient.toLowerCase()) {
-    warnings.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-  } else if (!isValid(recipient)) {
-    errors.recipient = new InvalidAddress("", {
-      currencyName: currency.name,
-    });
-  }
-  const estimatedFees = new BigNumber(transaction.estimatedFees);
-  if (!amount.gt(0)) {
-    if (!transaction.useAllAmount) errors.amount = new AmountRequired();
-    else errors.amount = new NotEnoughBalance();
-  } else {
-    if (amount.gt(spendableBalance)) {
-      errors.amount = new NotEnoughBalance();
-    }
-    if (!isTokenAccount) {
-      // vet
-      const vthoBalance = subAccounts?.[0].balance;
-      if (estimatedFees.gt(vthoBalance || 0)) {
-        errors.amount = new NotEnoughVTHO();
-      }
-    }
-  }
-
-  let totalSpent = amount;
-  if (isTokenAccount) {
-    totalSpent = amount.plus(estimatedFees);
-  }
-
-  return Promise.resolve({
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-  });
-};
-
-export default getTransactionStatus;