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

package/src/families/stellar/logic.ts

@@ -1,19 +1,37 @@
 import { BigNumber } from "bignumber.js";
 import StellarSdk, { ServerApi } from "stellar-sdk";
+import { findSubAccountById } from "../../account";
 import type { CacheRes } from "../../cache";
 import { makeLRUCache } from "../../cache";
-import type { Account, Operation, OperationType } from "../../types";
-import { fetchSigners, fetchBaseFee, loadAccount } from "./api";
+import type {
+  Account,
+  Operation,
+  OperationType,
+  TokenAccount,
+} from "../../types";
+import {
+  fetchSigners,
+  fetchBaseFee,
+  loadAccount,
+  BASE_RESERVE,
+  BASE_RESERVE_MIN_COUNT,
+} from "./api";
 import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
 import { encodeOperationId } from "../../operation";
+import type {
+  Transaction,
+  TransactionRaw,
+  BalanceAsset,
+  RawOperation,
+} from "./types";
 
 const currency = getCryptoCurrencyById("stellar");
 
 const getMinimumBalance = (account: ServerApi.AccountRecord): BigNumber => {
-  const baseReserve = 0.5;
-  const numberOfEntries = account.subentry_count;
-  const minimumBalance = (2 + numberOfEntries) * baseReserve;
-  return parseCurrencyUnit(currency.units[0], minimumBalance.toString());
+  return parseCurrencyUnit(
+    currency.units[0],
+    getReservedBalance(account).toString()
+  );
 };
 
 export const getAccountSpendableBalance = async (
@@ -21,12 +39,69 @@ export const getAccountSpendableBalance = async (
   account: ServerApi.AccountRecord
 ): Promise<BigNumber> => {
   const minimumBalance = getMinimumBalance(account);
-  const baseFee = await fetchBaseFee();
-  return BigNumber.max(balance.minus(minimumBalance).minus(baseFee), 0);
+  const { recommendedFee } = await fetchBaseFee();
+  return BigNumber.max(balance.minus(minimumBalance).minus(recommendedFee), 0);
+};
+
+export const getAmountValue = (
+  account: Account,
+  transaction: Transaction,
+  fees: BigNumber
+): BigNumber => {
+  // Asset
+  if (transaction.subAccountId) {
+    const asset = findSubAccountById(
+      account,
+      transaction.subAccountId
+    ) as TokenAccount;
+    return transaction.useAllAmount
+      ? new BigNumber(asset.spendableBalance)
+      : transaction.amount;
+  }
+
+  // Native
+  return transaction.useAllAmount && transaction.networkInfo
+    ? BigNumber.max(account.spendableBalance.minus(fees), 0)
+    : transaction.amount;
+};
+
+export const getBalanceId = (balance: BalanceAsset): string | null => {
+  switch (balance.asset_type) {
+    case "native":
+      return "native";
+    case "liquidity_pool_shares":
+      return balance.liquidity_pool_id || null;
+    case "credit_alphanum4":
+    case "credit_alphanum12":
+      return `${balance.asset_code}:${balance.asset_issuer}`;
+    default:
+      return null;
+  }
+};
+
+export const getReservedBalance = (
+  account: ServerApi.AccountRecord
+): BigNumber => {
+  const numOfSponsoringEntries = Number(account.num_sponsoring);
+  const numOfSponsoredEntries = Number(account.num_sponsored);
+
+  const nativeAsset = account.balances?.find(
+    (b) => b.asset_type === "native"
+  ) as BalanceAsset;
+
+  const amountInOffers = new BigNumber(nativeAsset?.buying_liabilities || 0);
+  const numOfEntries = new BigNumber(account.subentry_count);
+
+  return new BigNumber(BASE_RESERVE_MIN_COUNT)
+    .plus(numOfEntries)
+    .plus(numOfSponsoringEntries)
+    .minus(numOfSponsoredEntries)
+    .times(BASE_RESERVE)
+    .plus(amountInOffers);
 };
 
 export const getOperationType = (
-  operation: ServerApi.OperationRecord,
+  operation: RawOperation,
   addr: string
 ): OperationType => {
   switch (operation.type) {
@@ -41,11 +116,19 @@ export const getOperationType = (
       return "IN";
 
     case "path_payment_strict_send":
+      if (operation.to === addr) return "IN";
       return "OUT";
 
     case "path_payment_strict_receive":
       return "IN";
 
+    case "change_trust":
+      if (new BigNumber(operation.limit).eq(0)) {
+        return "OPT_OUT";
+      }
+
+      return "OPT_IN";
+
     default:
       if (operation.source_account === addr) {
         return "OUT";
@@ -55,12 +138,26 @@ export const getOperationType = (
   }
 };
 
+export const getAssetCodeIssuer = (
+  tr: Transaction | TransactionRaw
+): string[] => {
+  if (tr.subAccountId) {
+    const assetString = tr.subAccountId.split("+")[1];
+    return assetString.split(":");
+  }
+
+  return [tr.assetCode || "", tr.assetIssuer || ""];
+};
+
 const getRecipients = (operation): string[] => {
   switch (operation.type) {
     case "create_account":
       return [operation.account];
 
     case "payment":
+      return [operation.to_muxed || operation.to];
+
+    case "path_payment_strict_send":
       return [operation.to];
 
     default:
@@ -69,7 +166,7 @@ const getRecipients = (operation): string[] => {
 };
 
 export const formatOperation = async (
-  rawOperation: ServerApi.OperationRecord,
+  rawOperation: RawOperation,
   accountId: string,
   addr: string
 ): Promise<Operation> => {
@@ -86,34 +183,42 @@ export const formatOperation = async (
     id: encodeOperationId(accountId, rawOperation.transaction_hash, type),
     accountId,
     fee: new BigNumber(transaction.fee_charged),
-    value,
-    type: type,
+    value: rawOperation?.asset_code
+      ? new BigNumber(transaction.fee_charged)
+      : value,
+    // Using type NONE to hide asset operations from the main account (show them
+    // only on sub-account)
+    type:
+      rawOperation?.asset_code && !["OPT_IN", "OPT_OUT"].includes(type)
+        ? "NONE"
+        : type,
     hash: rawOperation.transaction_hash,
     blockHeight: transaction.ledger_attr,
     date: new Date(rawOperation.created_at),
     senders: [rawOperation.source_account],
     recipients,
     transactionSequenceNumber: Number(transaction.source_account_sequence),
-    // @ts-expect-error check transaction_successful property
     hasFailed: !rawOperation.transaction_successful,
     blockHash: null,
-    extra: memo
-      ? {
-          memo,
-        }
-      : {},
+    extra: {
+      pagingToken: rawOperation.paging_token,
+      assetCode: rawOperation?.asset_code,
+      assetIssuer: rawOperation?.asset_issuer,
+      assetAmount: rawOperation?.asset_code ? value.toString() : undefined,
+      ledgerOpType: type,
+      memo,
+    },
   };
   return operation;
 };
 
 const getValue = (
-  operation: ServerApi.OperationRecord,
+  operation: RawOperation,
   transaction: ServerApi.TransactionRecord,
   type: OperationType
 ): BigNumber => {
   let value = new BigNumber(0);
 
-  // @ts-expect-error check transaction_successful property
   if (!operation.transaction_successful) {
     return type === "IN" ? value : new BigNumber(transaction.fee_charged || 0);
   }
@@ -131,38 +236,13 @@ const getValue = (
     case "payment":
     case "path_payment_strict_send":
     case "path_payment_strict_receive":
-      value =
-        operation.asset_type === "native"
-          ? parseCurrencyUnit(currency.units[0], operation.amount)
-          : new BigNumber(0);
-
-      if (type === "OUT") {
-        value = value.plus(transaction.fee_charged);
-      }
-
-      return value;
+      return parseCurrencyUnit(currency.units[0], operation.amount);
 
     default:
       return type !== "IN" ? new BigNumber(transaction.fee_charged) : value;
   }
 };
 
-// TODO: Move to cache.js
-export const checkRecipientExist: CacheRes<
-  Array<{
-    account: Account;
-    recipient: string;
-  }>,
-  boolean
-> = makeLRUCache(
-  async ({ recipient }) => await addressExists(recipient),
-  (extract) => extract.recipient,
-  {
-    max: 300,
-    maxAge: 5 * 60,
-  } // 5 minutes
-);
-
 export const isMemoValid = (memoType: string, memoValue: string): boolean => {
   switch (memoType) {
     case "MEMO_TEXT":
@@ -191,7 +271,9 @@ export const isMemoValid = (memoType: string, memoValue: string): boolean => {
   return true;
 };
 
-export const isAccountMultiSign = async (account: Account) => {
+export const isAccountMultiSign = async (
+  account: Account
+): Promise<boolean> => {
   const signers = await fetchSigners(account);
   return signers.length > 1;
 };
@@ -205,43 +287,97 @@ export const isAddressValid = (address: string): boolean => {
   if (!address) return false;
 
   try {
-    return StellarSdk.StrKey.isValidEd25519PublicKey(address);
+    return (
+      StellarSdk.StrKey.isValidEd25519PublicKey(address) ||
+      StellarSdk.StrKey.isValidMed25519PublicKey(address)
+    );
   } catch (err) {
     return false;
   }
 };
 
-/**
- * Checks if the current account exists on the stellar Network. If it doesn't the account needs
- * to be activated by sending an account creation operation with an amount of at least the base reserve.
- *
- * @param {*} address
- */
-export const addressExists = async (address: string): Promise<boolean> => {
-  const account = await loadAccount(address);
-  return !!account;
+export const getRecipientAccount: CacheRes<
+  Array<{
+    account: Account;
+    recipient: string;
+  }>,
+  {
+    id: string | null;
+    isMuxedAccount: boolean;
+    assetIds: string[];
+  } | null
+> = makeLRUCache(
+  async ({ recipient }) => await recipientAccount(recipient),
+  (extract) => extract.recipient,
+  {
+    max: 300,
+    maxAge: 5 * 60,
+  } // 5 minutes
+);
+
+export const recipientAccount = async (
+  address?: string
+): Promise<{
+  id: string | null;
+  isMuxedAccount: boolean;
+  assetIds: string[];
+} | null> => {
+  if (!address) {
+    return null;
+  }
+
+  let accountAddress = address;
+
+  const isMuxedAccount = Boolean(
+    StellarSdk.StrKey.isValidMed25519PublicKey(address)
+  );
+
+  if (isMuxedAccount) {
+    const muxedAccount = new StellarSdk.MuxedAccount.fromAddress(address, "0");
+    accountAddress = muxedAccount.baseAccount().accountId();
+  }
+
+  const account = await loadAccount(accountAddress);
+
+  if (!account) {
+    return null;
+  }
+
+  return {
+    id: account.id,
+    isMuxedAccount,
+    assetIds: account.balances.reduce((allAssets, balance) => {
+      return [...allAssets, getBalanceId(balance)];
+    }, []),
+  };
 };
 
 export const rawOperationsToOperations = async (
-  operations: ServerApi.OperationRecord[],
+  operations: RawOperation[],
   addr: string,
   accountId: string
 ): Promise<Operation[]> => {
+  const supportedOperationTypes = [
+    "create_account",
+    "payment",
+    "path_payment_strict_send",
+    "path_payment_strict_receive",
+    "change_trust",
+  ];
+
   return Promise.all(
     operations
       .filter((operation) => {
         return (
-          // @ts-expect-error check from property
           operation.from === addr ||
-          // @ts-expect-error check to property
           operation.to === addr ||
-          // @ts-expect-error check funder property
           operation.funder === addr ||
-          // @ts-expect-error check account property
           operation.account === addr ||
+          operation.trustor === addr ||
           operation.source_account === addr
         );
       })
+      .filter((operation) => supportedOperationTypes.includes(operation.type))
       .map((operation) => formatOperation(operation, accountId, addr))
   );
 };

package/src/families/stellar/specs.ts

@@ -1,13 +1,30 @@
 import expect from "expect";
 import invariant from "invariant";
+import BigNumber from "bignumber.js";
 import type { Transaction } from "./types";
-import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
+import {
+  getCryptoCurrencyById,
+  parseCurrencyUnit,
+  listTokensForCryptoCurrency,
+} from "../../currencies";
 import { pickSiblings } from "../../bot/specs";
 import type { AppSpec } from "../../bot/types";
 import { DeviceModelId } from "@ledgerhq/devices";
+import { TokenCurrency, SubAccount } from "../../types";
+
 const currency = getCryptoCurrencyById("stellar");
 const minAmountCutoff = parseCurrencyUnit(currency.units[0], "0.1");
-const reserve = parseCurrencyUnit(currency.units[0], "1");
+const reserve = parseCurrencyUnit(currency.units[0], "1.5");
+
+const MAX_FEE = 5000;
+const USDC_CODE = "USDC";
+const USDC_ISSUER = "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN";
+const USDC_ASSET_ID = `${USDC_CODE}:${USDC_ISSUER}`;
+const MIN_ASSET_BALANCE = parseCurrencyUnit(currency.units[0], "0.01");
+
+const findAssetUSDC = <T extends { id: string }>(subAccounts?: T[]) =>
+  (subAccounts || []).find((s) => s.id.endsWith(USDC_ASSET_ID));
+
 const stellar: AppSpec<Transaction> = {
   name: "Stellar",
   currency,
@@ -15,12 +32,14 @@ const stellar: AppSpec<Transaction> = {
     model: DeviceModelId.nanoS,
     appName: "Stellar",
   },
+  testTimeout: 2 * 60 * 1000,
   mutations: [
     {
-      name: "move ~50%",
+      name: "move ~50% XLM",
       maxRun: 2,
       transaction: ({ account, siblings, bridge, maxSpendable }) => {
-        invariant(maxSpendable.gt(minAmountCutoff), "balance is too low");
+        invariant(maxSpendable.gt(minAmountCutoff), "XLM balance is too low");
+
         const transaction = bridge.createTransaction(account);
         const sibling = pickSiblings(siblings, 4);
         const recipient = sibling.freshAddress;
@@ -29,17 +48,81 @@ const stellar: AppSpec<Transaction> = {
         if (!sibling.used && amount.lt(reserve)) {
           invariant(
             maxSpendable.gt(reserve.plus(minAmountCutoff)),
-            "not enough funds to send to new account"
+            "not enough XLM funds to send to new account"
           );
           amount = reserve;
         }
 
         const updates: Array<Partial<Transaction>> = [
+          {
+            recipient,
+            // Setting higher max fee here to make sure transaction doesn't
+            // time out.
+            fees: new BigNumber(MAX_FEE),
+          },
           {
             amount,
           },
+        ];
+
+        if (Math.random() < 0.5) {
+          updates.push({
+            memoType: "MEMO_TEXT",
+            memoValue: "Ledger Live",
+          });
+        }
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ account, accountBeforeTransaction, operation, transaction }) => {
+        // We don't know what the final fee will be until after the tx is
+        // submitted. Using higher max fee to make sure tx doesn't time out.
+        expect(account.balance.toNumber()).toBeLessThanOrEqual(
+          accountBeforeTransaction.balance.minus(operation.value).toNumber()
+        );
+
+        if (transaction.memoValue) {
+          expect(operation.extra).toMatchObject({
+            memo: transaction.memoValue,
+          });
+        }
+
+        const getType = () => {
+          switch (transaction.mode) {
+            case "send":
+              return "send";
+            case "changeTrust":
+              return /change_trust/;
+            default:
+              return "";
+          }
+        };
+
+        expect(transaction.mode).toMatch(getType());
+      },
+    },
+    {
+      name: "Send max XLM",
+      maxRun: 2,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minAmountCutoff), "XLM balance is too low");
+
+        const transaction = bridge.createTransaction(account);
+        const sibling = pickSiblings(siblings, 4);
+        const recipient = sibling.freshAddress;
+
+        const updates: Array<Partial<Transaction>> = [
           {
             recipient,
+            // Setting higher max fee here to make sure transaction doesn't
+            // time out.
+            fees: new BigNumber(MAX_FEE),
+          },
+          {
+            useAllAmount: true,
           },
         ];
 
@@ -56,12 +139,148 @@ const stellar: AppSpec<Transaction> = {
         };
       },
       test: ({ account, accountBeforeTransaction, operation, transaction }) => {
-        expect(account.balance.toString()).toBe(
-          accountBeforeTransaction.balance.minus(operation.value).toString()
+        // We don't know what the final fee will be until after the tx is
+        // submitted. Using higher max fee to make sure tx doesn't time out.
+        expect(account.balance.toNumber()).toBeLessThanOrEqual(
+          accountBeforeTransaction.balance.minus(operation.value).toNumber()
+        );
+
+        if (transaction.memoValue) {
+          expect(operation.extra).toMatchObject({
+            memo: transaction.memoValue,
+          });
+        }
+
+        const getType = () => {
+          switch (transaction.mode) {
+            case "send":
+              return "send";
+            case "changeTrust":
+              return /change_trust/;
+            default:
+              return "";
+          }
+        };
+
+        expect(transaction.mode).toMatch(getType());
+      },
+    },
+    {
+      name: "add USDC asset",
+      maxRun: 1,
+      transaction: ({ account, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(reserve), "XLM balance is too low 1");
+        invariant(
+          account.subAccounts && !findAssetUSDC(account.subAccounts),
+          "already have subaccounts"
+        );
+        const assetUSDC = findAssetUSDC<TokenCurrency>(
+          listTokensForCryptoCurrency(account.currency)
+        );
+        invariant(assetUSDC, "USDC asset not found");
+
+        const transaction = bridge.createTransaction(account);
+
+        const updates: Array<Partial<Transaction>> = [
+          {
+            mode: "changeTrust",
+            // Setting higher max fee here to make sure transaction doesn't
+            // time out.
+            fees: new BigNumber(MAX_FEE),
+          },
+          {
+            assetCode: USDC_CODE,
+            assetIssuer: USDC_ISSUER,
+          },
+        ];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ account }) => {
+        const assetId = `${USDC_CODE}:${USDC_ISSUER}`;
+        const hasAsset = account.subAccounts?.find((a) =>
+          a.id.endsWith(assetId)
+        );
+        expect(hasAsset).toBeTruthy();
+      },
+    },
+    {
+      name: "move ~50% USDC asset",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minAmountCutoff), "XLM balance is too low");
+
+        const usdcSubAccount = findAssetUSDC<SubAccount>(account?.subAccounts);
+
+        invariant(usdcSubAccount, "USDC asset not found");
+        invariant(
+          usdcSubAccount?.balance.gt(MIN_ASSET_BALANCE),
+          "USDC balance is too low"
+        );
+
+        const siblingWithAssetUSDC = siblings.find((s) =>
+          findAssetUSDC(s.subAccounts)
+        );
+        invariant(siblingWithAssetUSDC, "No siblings with USDC asset");
+
+        if (!usdcSubAccount || !siblingWithAssetUSDC) {
+          throw new Error("No USDC asset or sibling with USDC asset");
+        }
+
+        const transaction = bridge.createTransaction(account);
+        const recipient = siblingWithAssetUSDC.freshAddress;
+        const amount = usdcSubAccount.balance
+          .div(1.9 + 0.2 * Math.random())
+          .integerValue();
+
+        const updates: Array<Partial<Transaction>> = [
+          {
+            recipient,
+          },
+          {
+            subAccountId: usdcSubAccount.id,
+          },
+          {
+            amount,
+            // Setting higher max fee here to make sure transaction doesn't
+            // time out.
+            fees: new BigNumber(MAX_FEE),
+          },
+        ];
+
+        if (Math.random() < 0.5) {
+          updates.push({
+            memoType: "MEMO_TEXT",
+            memoValue: "Ledger Live",
+          });
+        }
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({
+        account,
+        accountBeforeTransaction,
+        operation,
+        transaction,
+        status,
+      }) => {
+        const asset = findAssetUSDC<SubAccount>(account?.subAccounts);
+        const assetBeforeTx = findAssetUSDC<SubAccount>(
+          accountBeforeTransaction?.subAccounts
+        );
+
+        expect(asset?.balance.toString()).toBe(
+          assetBeforeTx?.balance.minus(status.amount).toString()
         );
 
         if (transaction.memoValue) {
-          expect(operation.extra).toEqual({
+          expect(operation.extra).toMatchObject({
             memo: transaction.memoValue,
           });
         }