@ledgerhq/live-common 24.1.0 → 25.0.0-next.1

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

@@ -3,26 +3,36 @@ import {
   AmountRequired,
   NotEnoughBalance,
   FeeNotLoaded,
-  InvalidAddress,
   InvalidAddressBecauseDestinationIsAlsoSource,
   NotEnoughSpendableBalance,
   NotEnoughBalanceBecauseDestinationNotCreated,
   RecipientRequired,
+  InvalidAddress,
 } from "@ledgerhq/errors";
 import {
   StellarWrongMemoFormat,
-  SourceHasMultiSign,
   AccountAwaitingSendPendingOperations,
+  StellarAssetRequired,
+  StellarAssetNotAccepted,
+  StellarAssetNotFound,
+  StellarNotEnoughNativeBalance,
+  StellarFeeSmallerThanRecommended,
+  StellarFeeSmallerThanBase,
+  StellarNotEnoughNativeBalanceToAddTrustline,
+  StellarMuxedAccountNotExist,
+  StellarSourceHasMultiSign,
 } from "../../errors";
+import { findSubAccountById } from "../../account";
 import { formatCurrencyUnit } from "../../currencies";
-import type { Account } from "../../types";
+import type { Account, TokenAccount } from "../../types";
 import type { Transaction } from "./types";
 import {
   isAddressValid,
-  checkRecipientExist,
   isAccountMultiSign,
   isMemoValid,
+  getRecipientAccount,
 } from "./logic";
+import { BASE_RESERVE, MIN_BALANCE } from "./api";
 
 const getTransactionStatus = async (
   a: Account,
@@ -38,81 +48,163 @@ const getTransactionStatus = async (
   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.recipient) {
-    errors.recipient = new RecipientRequired("");
-  } else if (a.freshAddress === t.recipient) {
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-  } else if (!isAddressValid(t.recipient)) {
-    errors.recipient = new InvalidAddress("");
-  }
-
-  if (await isAccountMultiSign(a)) {
-    errors.recipient = new SourceHasMultiSign("", {
-      currencyName: a.currency.name,
-    });
-  }
-
   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;
-  let amount = !useAllAmount
-    ? t.amount
-    : a.balance.minus(baseReserve).minus(estimatedFees);
-  let totalSpent = !useAllAmount
-    ? amount.plus(estimatedFees)
-    : a.balance.minus(baseReserve);
-
-  if (totalSpent.gt(a.balance.minus(baseReserve))) {
-    errors.amount = new NotEnoughSpendableBalance(undefined, {
-      minimumAmount: formatCurrencyUnit(a.currency.units[0], baseReserve, {
-        disableRounding: true,
-        showCode: true,
-      }),
-    });
-  }
+  const isAssetPayment = t.subAccountId && t.assetCode && t.assetIssuer;
+  const nativeBalance = a.balance;
+  const nativeAmountAvailable = a.spendableBalance.minus(estimatedFees);
 
-  if (
-    !errors.amount &&
-    amount.plus(estimatedFees).plus(baseReserve).gt(a.balance)
-  ) {
-    errors.amount = new NotEnoughBalance();
-  }
+  let amount = new BigNumber(0);
+  let maxAmount = new BigNumber(0);
+  let totalSpent = new BigNumber(0);
 
-  if (
-    !errors.recipient &&
-    !errors.amount &&
-    (amount.lt(0) || totalSpent.gt(a.balance))
-  ) {
-    errors.amount = new NotEnoughBalance();
-    totalSpent = new BigNumber(0);
-    amount = new BigNumber(0);
+  // Enough native balance to cover transaction (with required reserve + fees)
+  if (!errors.amount && nativeAmountAvailable.lt(0)) {
+    errors.amount = new StellarNotEnoughNativeBalance();
   }
 
-  if (!errors.amount && amount.eq(0)) {
-    errors.amount = new AmountRequired();
+  // 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();
   }
 
-  // if amount < 1.0 you can't send to an empty address
-  if (
-    !errors.recipient &&
-    t.recipient &&
-    !errors.amount &&
-    !(await checkRecipientExist({
+  // 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("");
+    } else if (a.freshAddress === t.recipient) {
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+    }
+
+    const recipientAccount = await getRecipientAccount({
       account: a,
       recipient: t.recipient,
-    })) &&
-    amount.lt(10000000)
-  ) {
-    errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
-      minimalAmount: "1 XLM",
     });
+
+    // 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)) {

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

@@ -1,7 +1,7 @@
 import invariant from "invariant";
 import { fetchAccountNetworkInfo } from "./api";
 import type { Account } from "../../types";
-
+import { getAssetCodeIssuer } from "./logic";
 import type { Transaction } from "./types";
 
 const prepareTransaction = async (
@@ -12,16 +12,17 @@ const prepareTransaction = async (
   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 { ...t, networkInfo, fees, baseReserve };
+    return { ...t, networkInfo, fees, baseReserve, assetCode, assetIssuer };
   }
 
-  return t;
+  return { ...t, assetCode, assetIssuer };
 };
 
 export default prepareTransaction;

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

@@ -7,6 +7,7 @@ import { withDevice } from "../../hw/deviceAccess";
 import type { Transaction } from "./types";
 import { buildTransaction } from "./js-buildTransaction";
 import { fetchSequence } from "./api";
+import { getAmountValue } from "./logic";
 
 const buildOptimisticOperation = async (
   account: Account,
@@ -14,14 +15,15 @@ const buildOptimisticOperation = async (
 ): Promise<Operation> => {
   const transactionSequenceNumber = await fetchSequence(account);
   const fees = transaction.fees ?? new BigNumber(0);
+  const type = transaction.mode === "changeTrust" ? "OPT_IN" : "OUT";
+
   const operation: Operation = {
-    id: `${account.id}--OUT`,
+    id: `${account.id}--${type}`,
     hash: "",
-    type: "OUT",
-    value:
-      transaction.useAllAmount && transaction.networkInfo
-        ? account.balance.minus(transaction.networkInfo.baseReserve).minus(fees)
-        : transaction.amount.plus(fees),
+    type,
+    value: transaction.subAccountId
+      ? fees
+      : getAmountValue(account, transaction, fees),
     fee: fees,
     blockHash: null,
     blockHeight: null,
@@ -33,6 +35,35 @@ const buildOptimisticOperation = async (
     transactionSequenceNumber: transactionSequenceNumber?.plus(1).toNumber(),
     extra: {},
   };
+
+  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: {},
+      },
+    ];
+  }
+
   return operation;
 };
 

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

@@ -1,10 +1,13 @@
+import type { Operation } from "../../types";
 import { encodeAccountId } from "../../account";
 import type { GetAccountShape } from "../../bridge/jsHelpers";
 import { makeScanAccounts, makeSync, mergeOps } from "../../bridge/jsHelpers";
 import { fetchAccount, fetchOperations } from "./api";
+import { buildSubAccounts } from "./tokens";
+import { inferSubOperations } from "../../account";
 
-const getAccountShape: GetAccountShape = async (info) => {
-  const { address, initialAccount, currency, derivationMode } = info;
+const getAccountShape: GetAccountShape = async (info, syncConfig) => {
+  const { address, currency, initialAccount, derivationMode } = info;
   const accountId = encodeAccountId({
     type: "js",
     version: "2",
@@ -12,23 +15,62 @@ const getAccountShape: GetAccountShape = async (info) => {
     xpubOrAddress: address,
     derivationMode,
   });
-  const oldOperations = initialAccount?.operations || [];
-  const startAt = oldOperations.length
-    ? (oldOperations[0].blockHeight || 0) + 1
-    : 0;
-  const { blockHeight, balance, spendableBalance } = await fetchAccount(
+  const { blockHeight, balance, spendableBalance, assets } = await fetchAccount(
     address
   );
-  const newOperations = await fetchOperations(accountId, address, startAt);
-  const operations = mergeOps(oldOperations, newOperations);
+
+  const oldOperations = initialAccount?.operations || [];
+  const lastPagingToken = oldOperations[0]?.extra?.pagingToken || 0;
+
+  const newOperations =
+    (await fetchOperations({
+      accountId,
+      addr: address,
+      order: "asc",
+      cursor: lastPagingToken,
+    })) || [];
+
+  const allOperations = mergeOps(oldOperations, newOperations);
+  const assetOperations: Operation[] = [];
+
+  allOperations.forEach((op) => {
+    if (
+      op?.extra?.assetCode &&
+      op?.extra?.assetIssuer &&
+      !["OPT_IN", "OPT_OUT"].includes(op.type)
+    ) {
+      assetOperations.push(op);
+    }
+  });
+
+  const subAccounts =
+    buildSubAccounts({
+      currency,
+      accountId,
+      assets,
+      syncConfig,
+      operations: assetOperations,
+    }) || [];
+
   const shape = {
     id: accountId,
     balance,
     spendableBalance,
-    operationsCount: operations.length,
+    operationsCount: allOperations.length,
     blockHeight,
+    subAccounts,
+  };
+  return {
+    ...shape,
+    operations: allOperations.map((op) => {
+      const subOperations = inferSubOperations(op.hash, subAccounts);
+
+      return {
+        ...op,
+        subOperations,
+      };
+    }),
   };
-  return { ...shape, operations };
 };
 
 export const sync = makeSync({ getAccountShape });