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

package/src/families/stellar/api/horizon.ts

@@ -12,15 +12,25 @@ import type { NetworkInfo } from "../types";
 import {
   getAccountSpendableBalance,
   rawOperationsToOperations,
+  getReservedBalance,
 } from "../logic";
 import { NetworkDown, LedgerAPI4xx, LedgerAPI5xx } from "@ledgerhq/errors";
 import { requestInterceptor, responseInterceptor } from "../../../network";
+import type { BalanceAsset } from "../types";
+import { NetworkCongestionLevel, Signer } from "../types";
 
 const LIMIT = getEnv("API_STELLAR_HORIZON_FETCH_LIMIT");
 const FALLBACK_BASE_FEE = 100;
+const TRESHOLD_LOW = 0.5;
+const TRESHOLD_MEDIUM = 0.75;
 const currency = getCryptoCurrencyById("stellar");
 const server = new StellarSdk.Server(getEnv("API_STELLAR_HORIZON"));
 
+// Constants
+export const BASE_RESERVE = 0.5;
+export const BASE_RESERVE_MIN_COUNT = 2;
+export const MIN_BALANCE = 1;
+
 StellarSdk.HorizonAxiosClient.interceptors.request.use(requestInterceptor);
 
 StellarSdk.HorizonAxiosClient.interceptors.response.use((response) => {
@@ -46,16 +56,48 @@ const getFormattedAmount = (amount: BigNumber) => {
     .toString(10);
 };
 
-export const fetchBaseFee = async (): Promise<number> => {
-  let baseFee;
+export const fetchBaseFee = async (): Promise<{
+  baseFee: number;
+  recommendedFee: number;
+  networkCongestionLevel: NetworkCongestionLevel;
+}> => {
+  // For tests
+  if (getEnv("API_STELLAR_HORIZON_STATIC_FEE")) {
+    return {
+      baseFee: 100,
+      recommendedFee: 100,
+      networkCongestionLevel: NetworkCongestionLevel.LOW,
+    };
+  }
+
+  const baseFee = StellarSdk.BASE_FEE || FALLBACK_BASE_FEE;
+  let recommendedFee = baseFee;
+  let networkCongestionLevel = NetworkCongestionLevel.MEDIUM;
 
   try {
-    baseFee = await server.fetchBaseFee();
+    const feeStats = await server.feeStats();
+    const ledgerCapacityUsage = feeStats.ledger_capacity_usage;
+    recommendedFee = Number(feeStats.fee_charged.mode);
+
+    if (
+      ledgerCapacityUsage > TRESHOLD_LOW &&
+      ledgerCapacityUsage <= TRESHOLD_MEDIUM
+    ) {
+      networkCongestionLevel = NetworkCongestionLevel.MEDIUM;
+    } else if (ledgerCapacityUsage > TRESHOLD_MEDIUM) {
+      networkCongestionLevel = NetworkCongestionLevel.HIGH;
+    } else {
+      networkCongestionLevel = NetworkCongestionLevel.LOW;
+    }
   } catch (e) {
-    baseFee = FALLBACK_BASE_FEE;
+    // do nothing, will use defaults
   }
 
-  return baseFee;
+  return {
+    baseFee,
+    recommendedFee,
+    networkCongestionLevel,
+  };
 };
 
 /**
@@ -70,15 +112,21 @@ export const fetchAccount = async (
   blockHeight?: number;
   balance: BigNumber;
   spendableBalance: BigNumber;
+  assets: BalanceAsset[];
 }> => {
   let account: typeof AccountRecord = {};
   let balance: Record<string, any> = {};
+  let assets: BalanceAsset[] = [];
 
   try {
     account = await server.accounts().accountId(addr).call();
-    balance = account.balances.find((balance) => {
+    balance = account.balances?.find((balance) => {
       return balance.asset_type === "native";
     });
+    // Getting all non-native (XLM) assets on the account
+    assets = account.balances?.filter((balance) => {
+      return balance.asset_type !== "native";
+    });
   } catch (e) {
     balance.balance = "0";
   }
@@ -97,6 +145,7 @@ export const fetchAccount = async (
     blockHeight: account.sequence ? Number(account.sequence) : undefined,
     balance: formattedBalance,
     spendableBalance,
+    assets,
   };
 };
 
@@ -105,16 +154,23 @@ export const fetchAccount = async (
  *
  * @param {string} accountId
  * @param {string} addr
- * @param {number} startAt - blockHeight after which you fetch this op (included)
+ * @param {string} order - "desc" or "asc" order of returned records
+ * @param {string} cursor - point to start fetching records
  *
  * @return {Operation[]}
  */
-export const fetchOperations = async (
-  accountId: string,
-  addr: string,
-  startAt = 0
-): Promise<Operation[]> => {
-  if (!addr || !addr.length) {
+export const fetchOperations = async ({
+  accountId,
+  addr,
+  order,
+  cursor,
+}: {
+  accountId: string;
+  addr: string;
+  order: "asc" | "desc";
+  cursor: string;
+}): Promise<Operation[]> => {
+  if (!addr) {
     return [];
   }
 
@@ -125,10 +181,11 @@ export const fetchOperations = async (
     rawOperations = await server
       .operations()
       .forAccount(addr)
-      .join("transactions")
-      .includeFailed(true)
       .limit(LIMIT)
-      .cursor(startAt)
+      .order(order)
+      .cursor(cursor)
+      .includeFailed(true)
+      .join("transactions")
       .call();
   } catch (e: any) {
     // FIXME: terrible hacks, because Stellar SDK fails to cast network failures to typed errors in react-native...
@@ -175,6 +232,7 @@ export const fetchOperations = async (
 
   return operations;
 };
+
 export const fetchAccountNetworkInfo = async (
   account: Account
 ): Promise<NetworkInfo> => {
@@ -183,25 +241,24 @@ export const fetchAccountNetworkInfo = async (
       .accounts()
       .accountId(account.freshAddress)
       .call();
-    const numberOfEntries = extendedAccount.subentry_count;
-    const ledger = await server
-      .ledgers()
-      .ledger(extendedAccount.last_modified_ledger)
-      .call();
-    const baseReserve = new BigNumber(
-      (ledger.base_reserve_in_stroops * (2 + numberOfEntries)).toString()
-    );
-    const fees = new BigNumber(ledger.base_fee_in_stroops.toString());
+    const baseReserve = getReservedBalance(extendedAccount);
+    const { recommendedFee, networkCongestionLevel, baseFee } =
+      await fetchBaseFee();
+
     return {
       family: "stellar",
-      fees,
+      fees: new BigNumber(recommendedFee.toString()),
+      baseFee: new BigNumber(baseFee.toString()),
       baseReserve,
+      networkCongestionLevel,
     };
   } catch (error) {
     return {
       family: "stellar",
       fees: new BigNumber(0),
+      baseFee: new BigNumber(0),
       baseReserve: new BigNumber(0),
+      networkCongestionLevel: undefined,
     };
   }
 };
@@ -213,7 +270,7 @@ export const fetchSequence = async (a: Account): Promise<BigNumber> => {
     : new BigNumber(0);
 };
 
-export const fetchSigners = async (a: Account) => {
+export const fetchSigners = async (a: Account): Promise<Signer[]> => {
   try {
     const extendedAccount = await server
       .accounts()
@@ -238,15 +295,29 @@ export const broadcastTransaction = async (
   return res.hash;
 };
 
-export const buildPaymentOperation = (
-  destination: string,
-  amount: BigNumber
-): any => {
+export const buildPaymentOperation = ({
+  destination,
+  amount,
+  assetCode,
+  assetIssuer,
+}: {
+  destination: string;
+  amount: BigNumber;
+  assetCode: string | undefined;
+  assetIssuer: string | undefined;
+}): any => {
   const formattedAmount = getFormattedAmount(amount);
+  // Non-native assets should always have asset code and asset issuer. If an
+  // asset doesn't have both, we assume it is native asset.
+  const asset =
+    assetCode && assetIssuer
+      ? new StellarSdk.Asset(assetCode, assetIssuer)
+      : StellarSdk.Asset.native();
   return StellarSdk.Operation.payment({
     destination: destination,
     amount: formattedAmount,
-    asset: StellarSdk.Asset.native(),
+    asset,
+    withMuxing: true,
   });
 };
 
@@ -261,6 +332,15 @@ export const buildCreateAccountOperation = (
   });
 };
 
+export const buildChangeTrustOperation = (
+  assetCode: string,
+  assetIssuer: string
+): any => {
+  return StellarSdk.Operation.changeTrust({
+    asset: new StellarSdk.Asset(assetCode, assetIssuer),
+  });
+};
+
 export const buildTransactionBuilder = (
   source: typeof StellarSdk.Account,
   fee: BigNumber
@@ -272,7 +352,9 @@ export const buildTransactionBuilder = (
   });
 };
 
-export const loadAccount = async (addr: string): Promise<any> => {
+export const loadAccount = async (
+  addr: string
+): Promise<AccountRecord | null> => {
   if (!addr || !addr.length) {
     return null;
   }

package/src/families/stellar/api/index.ts

@@ -8,6 +8,10 @@ export {
   broadcastTransaction,
   buildPaymentOperation,
   buildCreateAccountOperation,
+  buildChangeTrustOperation,
   buildTransactionBuilder,
   loadAccount,
+  BASE_RESERVE,
+  BASE_RESERVE_MIN_COUNT,
+  MIN_BALANCE,
 } from "./horizon";

package/src/families/stellar/bridge/mock.ts

@@ -43,6 +43,9 @@ const createTransaction = (): Transaction => ({
   memoValue: null,
   memoType: null,
   useAllAmount: false,
+  mode: "send",
+  assetCode: "",
+  assetIssuer: "",
 });
 
 const updateTransaction = (t, patch) => {

package/src/families/stellar/bridge.integration.test.ts

@@ -111,11 +111,15 @@ const dataset: DatasetTest<Transaction> = {
                 networkInfo: {
                   family: "stellar",
                   fees: "100",
+                  baseFee: "100",
                   baseReserve: "1500000",
                 },
                 fees: "100",
                 memoType: null,
                 memoValue: null,
+                mode: "send",
+                assetCode: "",
+                assetIssuer: "",
               }),
               expectedStatus: {
                 errors: {
@@ -166,18 +170,22 @@ const dataset: DatasetTest<Transaction> = {
                 networkInfo: {
                   family: "stellar",
                   fees: "100",
+                  baseFee: "100",
                   baseReserve: "1500000",
                 },
                 fees: "100",
                 memoType: null,
                 memoValue: null,
+                mode: "send",
+                assetCode: "",
+                assetIssuer: "",
               }),
               expectedStatus: (account) => ({
                 errors: {},
                 warnings: {},
                 estimatedFees: new BigNumber("100"),
-                amount: account.balance.minus("1500000").minus("100"),
-                totalSpent: account.balance.minus("1500000"),
+                amount: account.spendableBalance.minus("100"),
+                totalSpent: account.spendableBalance.minus("100"),
               }),
             },
             {

package/src/families/stellar/cli-transaction.ts

@@ -1,5 +1,13 @@
 import invariant from "invariant";
-import type { Transaction, AccountLike } from "../../types";
+import { getAccountCurrency } from "../../account";
+import type {
+  Transaction,
+  AccountLike,
+  Account,
+  AccountLikeArray,
+} from "../../types";
+import { getAssetIdFromTokenId } from "./tokens";
+
 const options = [
   {
     name: "fee",
@@ -16,6 +24,21 @@ const options = [
     type: String,
     desc: "stellar memo value",
   },
+  {
+    name: "mode",
+    type: String,
+    desc: "change operation type",
+  },
+  {
+    name: "assetIssuer",
+    type: String,
+    desc: "Asset issuer",
+  },
+  {
+    name: "assetCode",
+    type: String,
+    desc: "Same as token",
+  },
 ];
 
 function inferTransactions(
@@ -25,17 +48,67 @@ function inferTransactions(
   }>,
   opts: Record<string, any>
 ): Transaction[] {
-  return transactions.map(({ transaction }) => {
+  return transactions.map(({ transaction, account }) => {
     invariant(transaction.family === "stellar", "stellar family");
+
     return {
       ...transaction,
+      subAccountId: account.type === "TokenAccount" ? account.id : null,
       memoType: opts.memoType,
       memoValue: opts.memoValue,
+      mode: opts.mode ?? "send",
+      assetCode: opts.token,
+      assetIssuer: opts.assetIssuer,
     };
   });
 }
 
+function inferAccounts(
+  account: Account,
+  opts: Record<string, any>
+): AccountLikeArray {
+  invariant(account.currency.family === "stellar", "stellar family");
+
+  if (opts.subAccountId) {
+    const assetSubAccount = account.subAccounts?.find(
+      (a) => a.id === opts.subAccountId
+    );
+
+    if (!assetSubAccount) {
+      throw new Error(`${opts.subAccountId} asset not found`);
+    }
+
+    return [assetSubAccount];
+  }
+
+  if (opts.assetCode) {
+    const subAccounts = account.subAccounts || [];
+
+    const subAccount = subAccounts.find((sa) => {
+      const currency = getAccountCurrency(sa);
+      return (
+        opts.assetCode.toLowerCase() === currency.ticker.toLowerCase() ||
+        opts.assetCode.toLowerCase() === getAssetIdFromTokenId(currency.id)
+      );
+    });
+
+    if (!subAccount) {
+      throw new Error(
+        "token account '" +
+          opts.assetCode +
+          "' not found. Available: " +
+          subAccounts.map((t) => getAccountCurrency(t).ticker).join(", ")
+      );
+    }
+
+    return [subAccount];
+  }
+
+  return [account];
+}
+
 export default {
   options,
+  inferAccounts,
   inferTransactions,
 };

package/src/families/stellar/deviceTransactionConfig.ts

@@ -10,16 +10,27 @@ export type ExtraDeviceTransactionField =
   | {
       type: "stellar.network";
       label: string;
+    }
+  | {
+      type: "stellar.assetCode";
+      label: string;
+    }
+  | {
+      type: "stellar.assetIssuer";
+      label: string;
     };
 
 function getDeviceTransactionConfig({
   status: { amount, estimatedFees },
+  transaction,
 }: {
   account: AccountLike;
   parentAccount: Account | null | undefined;
   transaction: Transaction;
   status: TransactionStatus;
 }): Array<DeviceTransactionField | ExtraDeviceTransactionField> {
+  const { assetCode, assetIssuer } = transaction;
+
   const fields: Array<DeviceTransactionField | ExtraDeviceTransactionField> = [
     {
       type: "stellar.network",
@@ -34,6 +45,17 @@ function getDeviceTransactionConfig({
     });
   }
 
+  if (assetCode && assetIssuer) {
+    fields.push({
+      type: "stellar.assetCode",
+      label: "Asset",
+    });
+    fields.push({
+      type: "stellar.assetIssuer",
+      label: "Asset issuer",
+    });
+  }
+
   fields.push({
     type: "stellar.memo",
     label: "Memo",

package/src/families/stellar/errors.ts

@@ -0,0 +1,34 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const StellarMemoRecommended = createCustomErrorClass(
+  "StellarMemoRecommended"
+);
+export const StellarWrongMemoFormat = createCustomErrorClass(
+  "StellarWrongMemoFormat"
+);
+export const StellarAssetRequired = createCustomErrorClass(
+  "StellarAssetRequired"
+);
+export const StellarAssetNotAccepted = createCustomErrorClass(
+  "StellarAssetNotAccepted"
+);
+export const StellarAssetNotFound = createCustomErrorClass(
+  "StellarAssetNotFound"
+);
+export const StellarNotEnoughNativeBalance = createCustomErrorClass(
+  "StellarNotEnoughNativeBalance"
+);
+export const StellarFeeSmallerThanRecommended = createCustomErrorClass(
+  "StellarFeeSmallerThanRecommended"
+);
+export const StellarFeeSmallerThanBase = createCustomErrorClass(
+  "StellarFeeSmallerThanBase"
+);
+export const StellarNotEnoughNativeBalanceToAddTrustline =
+  createCustomErrorClass("StellarNotEnoughNativeBalanceToAddTrustline");
+export const StellarMuxedAccountNotExist = createCustomErrorClass(
+  "StellarMuxedAccountNotExist"
+);
+export const StellarSourceHasMultiSign = createCustomErrorClass(
+  "StellarSourceHasMultiSign"
+);

package/src/families/stellar/exchange.ts

@@ -1,4 +1,4 @@
-import { bip32asBuffer } from "@ledgerhq/hw-app-btc/lib/bip32";
+import { bip32asBuffer } from "@ledgerhq/hw-app-btc/bip32";
 
 const getSerializedAddressParameters = (
   path: string

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

@@ -1,5 +1,4 @@
 import invariant from "invariant";
-import { BigNumber } from "bignumber.js";
 import StellarSdk from "stellar-sdk";
 import { AmountRequired, FeeNotLoaded, NetworkDown } from "@ledgerhq/errors";
 import type { Account } from "../../types";
@@ -8,9 +7,14 @@ import {
   buildPaymentOperation,
   buildCreateAccountOperation,
   buildTransactionBuilder,
+  buildChangeTrustOperation,
   loadAccount,
 } from "./api";
-import { addressExists } from "./logic";
+import { getRecipientAccount, getAmountValue } from "./logic";
+import {
+  StellarAssetRequired,
+  StellarMuxedAccountNotExist,
+} from "../../errors";
 
 /**
  * @param {Account} a
@@ -20,33 +24,69 @@ export const buildTransaction = async (
   account: Account,
   transaction: Transaction
 ): Promise<any> => {
-  const { recipient, useAllAmount, networkInfo, fees, memoType, memoValue } =
-    transaction;
+  const {
+    recipient,
+    networkInfo,
+    fees,
+    memoType,
+    memoValue,
+    mode,
+    assetCode,
+    assetIssuer,
+  } = transaction;
 
   if (!fees) {
     throw new FeeNotLoaded();
   }
 
-  invariant(networkInfo && networkInfo.family === "stellar", "stellar family");
-  let amount = new BigNumber(0);
-  amount =
-    useAllAmount && networkInfo
-      ? account.balance.minus(networkInfo.baseReserve).minus(fees)
-      : transaction.amount;
-  if (!amount) throw new AmountRequired();
   const source = await loadAccount(account.freshAddress);
-  if (!source) throw new NetworkDown();
+
+  if (!source) {
+    throw new NetworkDown();
+  }
+
+  invariant(networkInfo && networkInfo.family === "stellar", "stellar family");
+
   const transactionBuilder = buildTransactionBuilder(source, fees);
   let operation = null;
-  const recipientExists = await addressExists(transaction.recipient); // TODO: use cache with checkRecipientExist instead?
 
-  if (recipientExists) {
-    operation = buildPaymentOperation(recipient, amount);
+  if (mode === "changeTrust") {
+    if (!assetCode || !assetIssuer) {
+      throw new StellarAssetRequired("");
+    }
+
+    operation = buildChangeTrustOperation(assetCode, assetIssuer);
   } else {
-    operation = buildCreateAccountOperation(recipient, amount);
+    // 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 = null;
 
   if (memoType && memoValue) {

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

@@ -16,6 +16,9 @@ const createTransaction = (): Transaction => ({
   memoValue: null,
   memoType: null,
   useAllAmount: false,
+  mode: "send",
+  assetCode: "",
+  assetIssuer: "",
 });
 
 export default createTransaction;

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

@@ -27,7 +27,7 @@ const estimateMaxSpendable = async ({
     useAllAmount: true,
   });
   const s = await getTransactionStatus(mainAccount, t);
-  return s.amount;
+  return s.amount.gte(0) ? s.amount : new BigNumber(0);
 };
 
 export default estimateMaxSpendable;