@ledgerhq/coin-stellar 0.2.0-nightly.0

package/src/logic.ts

@@ -0,0 +1,371 @@
+import { BigNumber } from "bignumber.js";
+import type { CacheRes } from "@ledgerhq/live-network/cache";
+import { makeLRUCache } from "@ledgerhq/live-network/cache";
+import type { Account, OperationType, TokenAccount } from "@ledgerhq/types-live";
+import {
+  Horizon,
+  StrKey,
+  MuxedAccount,
+  // @ts-expect-error stellar-sdk ts definition missing?
+  AccountRecord,
+} from "@stellar/stellar-sdk";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
+import {
+  BASE_RESERVE,
+  BASE_RESERVE_MIN_COUNT,
+  fetchBaseFee,
+  fetchSigners,
+  loadAccount,
+} from "./network";
+import type {
+  BalanceAsset,
+  RawOperation,
+  StellarOperation,
+  Transaction,
+  TransactionRaw,
+} from "./types";
+
+export const STELLAR_BURN_ADDRESS = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
+
+const currency = getCryptoCurrencyById("stellar");
+
+const getMinimumBalance = (account: Horizon.ServerApi.AccountRecord): BigNumber => {
+  return parseCurrencyUnit(currency.units[0], getReservedBalance(account).toString());
+};
+
+export async function getAccountSpendableBalance(
+  balance: BigNumber,
+  account: Horizon.ServerApi.AccountRecord,
+): Promise<BigNumber> {
+  const minimumBalance = getMinimumBalance(account);
+  const { recommendedFee } = await fetchBaseFee();
+  return BigNumber.max(balance.minus(minimumBalance).minus(recommendedFee), 0);
+}
+
+export function 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 function 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 function getReservedBalance(account: Horizon.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?.selling_liabilities || 0);
+  const numOfEntries = new BigNumber(account.subentry_count || 0);
+
+  return new BigNumber(BASE_RESERVE_MIN_COUNT)
+    .plus(numOfEntries)
+    .plus(numOfSponsoringEntries)
+    .minus(numOfSponsoredEntries)
+    .times(BASE_RESERVE)
+    .plus(amountInOffers);
+}
+
+export function getOperationType(operation: RawOperation, addr: string): OperationType {
+  switch (operation.type) {
+    case "create_account":
+      return operation.funder === addr ? "OUT" : "IN";
+
+    case "payment":
+      if (operation.from === addr && operation.to !== addr) {
+        return "OUT";
+      }
+
+      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";
+      }
+
+      return "IN";
+  }
+}
+
+export function getAssetCodeIssuer(tr: Transaction | TransactionRaw): string[] {
+  if (tr.subAccountId) {
+    const assetString = tr.subAccountId.split("+")[1];
+    return assetString.split(":");
+  }
+
+  return [tr.assetCode || "", tr.assetIssuer || ""];
+}
+
+function getRecipients(operation: RawOperation): 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:
+      return [];
+  }
+}
+
+export async function formatOperation(
+  rawOperation: RawOperation,
+  accountId: string,
+  addr: string,
+): Promise<StellarOperation> {
+  const transaction = await rawOperation.transaction();
+  const type = getOperationType(rawOperation, addr);
+  const value = getValue(rawOperation, transaction, type);
+  const recipients = getRecipients(rawOperation);
+  const memo = transaction.memo
+    ? transaction.memo_type === "hash" || transaction.memo_type === "return"
+      ? Buffer.from(transaction.memo, "base64").toString("hex")
+      : transaction.memo
+    : null;
+
+  const operation: StellarOperation = {
+    id: encodeOperationId(accountId, rawOperation.transaction_hash, type),
+    accountId,
+    fee: new BigNumber(transaction.fee_charged),
+    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),
+    hasFailed: !rawOperation.transaction_successful,
+    blockHash: null,
+    extra: {
+      ledgerOpType: type,
+    },
+  };
+
+  if (rawOperation.paging_token) {
+    operation.extra.pagingToken = rawOperation.paging_token;
+  }
+  if (rawOperation.asset_code) {
+    operation.extra.assetCode = rawOperation.asset_code;
+    operation.extra.assetAmount = rawOperation.asset_code ? value.toString() : undefined;
+  }
+  if (rawOperation.asset_issuer) {
+    operation.extra.assetIssuer = rawOperation.asset_issuer;
+  }
+  if (memo) {
+    operation.extra.memo = memo;
+  }
+
+  return operation;
+}
+
+function getValue(
+  operation: RawOperation,
+  transaction: Horizon.ServerApi.TransactionRecord,
+  type: OperationType,
+): BigNumber {
+  let value = new BigNumber(0);
+
+  if (!operation.transaction_successful) {
+    return type === "IN" ? value : new BigNumber(transaction.fee_charged || 0);
+  }
+
+  switch (operation.type) {
+    case "create_account":
+      value = parseCurrencyUnit(currency.units[0], operation.starting_balance);
+
+      if (type === "OUT") {
+        value = value.plus(transaction.fee_charged);
+      }
+
+      return value;
+
+    case "payment":
+    case "path_payment_strict_send":
+    case "path_payment_strict_receive":
+      return parseCurrencyUnit(currency.units[0], operation.amount);
+
+    default:
+      return type !== "IN" ? new BigNumber(transaction.fee_charged) : value;
+  }
+}
+
+export function isMemoValid(memoType: string, memoValue: string): boolean {
+  switch (memoType) {
+    case "MEMO_TEXT":
+      if (memoValue.length > 28) {
+        return false;
+      }
+
+      break;
+
+    case "MEMO_ID":
+      if (new BigNumber(memoValue.toString()).isNaN()) {
+        return false;
+      }
+
+      break;
+
+    case "MEMO_HASH":
+    case "MEMO_RETURN":
+      if (!memoValue.length || memoValue.length !== 64) {
+        return false;
+      }
+
+      break;
+  }
+
+  return true;
+}
+
+export async function isAccountMultiSign(account: Account): Promise<boolean> {
+  const signers = await fetchSigners(account);
+  return signers.length > 1;
+}
+
+/**
+ * Returns true if address is valid, false if it's invalid (can't parse or wrong checksum)
+ *
+ * @param {*} address
+ */
+export function isAddressValid(address: string): boolean {
+  if (!address) return false;
+
+  // FIXME Workaround for burn address, see https://ledgerhq.atlassian.net/browse/LIVE-4014
+  if (address === STELLAR_BURN_ADDRESS) return false;
+
+  try {
+    return StrKey.isValidEd25519PublicKey(address) || StrKey.isValidMed25519PublicKey(address);
+  } catch (err) {
+    return false;
+  }
+}
+
+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,
+    ttl: 5 * 60,
+  }, // 5 minutes
+);
+
+export async function recipientAccount(address?: string): Promise<{
+  id: string | null;
+  isMuxedAccount: boolean;
+  assetIds: string[];
+} | null> {
+  if (!address) {
+    return null;
+  }
+
+  let accountAddress = address;
+
+  const isMuxedAccount = StrKey.isValidMed25519PublicKey(address);
+
+  if (isMuxedAccount) {
+    const muxedAccount = MuxedAccount.fromAddress(address, "0");
+    accountAddress = muxedAccount.baseAccount().accountId();
+  }
+
+  const account: AccountRecord = await loadAccount(accountAddress);
+
+  if (!account) {
+    return null;
+  }
+
+  return {
+    id: account.id,
+    isMuxedAccount,
+    assetIds: account.balances.reduce((allAssets: any[], balance: any) => {
+      return [...allAssets, getBalanceId(balance)];
+    }, []),
+  };
+}
+
+export function rawOperationsToOperations(
+  operations: RawOperation[],
+  addr: string,
+  accountId: string,
+): Promise<StellarOperation[]> {
+  const supportedOperationTypes = [
+    "create_account",
+    "payment",
+    "path_payment_strict_send",
+    "path_payment_strict_receive",
+    "change_trust",
+  ];
+
+  return Promise.all(
+    operations
+      .filter(operation => {
+        return (
+          operation.from === addr ||
+          operation.to === addr ||
+          operation.funder === addr ||
+          operation.account === addr ||
+          operation.trustor === addr ||
+          operation.source_account === addr
+        );
+      })
+      .filter(operation => supportedOperationTypes.includes(operation.type))
+      .map(operation => formatOperation(operation, accountId, addr)),
+  );
+}

package/src/network/horizon.ts

@@ -0,0 +1,352 @@
+import { LedgerAPI4xx, LedgerAPI5xx, NetworkDown } from "@ledgerhq/errors";
+import type { Account, Operation } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import {
+  // @ts-expect-error stellar-sdk ts definition missing?
+  AccountRecord,
+  NetworkError,
+  NotFoundError,
+  Horizon,
+  BASE_FEE,
+  Asset,
+  Operation as StellarSdkOperation,
+  Account as StellarSdkAccount,
+  Transaction as StellarSdkTransaction,
+  TransactionBuilder,
+  Networks,
+} from "@stellar/stellar-sdk";
+import { log } from "@ledgerhq/logs";
+import { getEnv } from "@ledgerhq/live-env";
+import {
+  type BalanceAsset,
+  type NetworkInfo,
+  type RawOperation,
+  type Signer,
+  NetworkCongestionLevel,
+} from "../types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import {
+  getAccountSpendableBalance,
+  getReservedBalance,
+  rawOperationsToOperations,
+} from "../logic";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+
+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 Horizon.Server(getEnv("API_STELLAR_HORIZON"));
+
+// Constants
+export const BASE_RESERVE = 0.5;
+export const BASE_RESERVE_MIN_COUNT = 2;
+export const MIN_BALANCE = 1;
+
+// Due to the inconsistency between the axios version (1.6.5) used by `stellar-sdk`
+// and the version (0.26.1) used by `@ledgerhq/live-network/network`, it is not possible to use the interceptors
+// provided by `@ledgerhq/live-network/network`.
+Horizon.AxiosClient.interceptors.request.use(config => {
+  if (!getEnv("ENABLE_NETWORK_LOGS")) {
+    return config;
+  }
+
+  const { url, method, data } = config;
+  log("network", `${method} ${url}`, { data });
+  return config;
+});
+
+Horizon.AxiosClient.interceptors.response.use(response => {
+  if (getEnv("ENABLE_NETWORK_LOGS")) {
+    const { url, method } = response.config;
+    log("network-success", `${response.status} ${method} ${url}`, { data: response.data });
+  }
+
+  // FIXME: workaround for the Stellar SDK not using the correct URL: the "next" URL
+  // included in server responses points to the node itself instead of our reverse proxy...
+  // (https://github.com/stellar/js-stellar-sdk/issues/637)
+  const next_href = response?.data?._links?.next?.href;
+
+  if (next_href) {
+    const next = new URL(next_href);
+    next.host = new URL(getEnv("API_STELLAR_HORIZON")).host;
+    response.data._links.next.href = next.toString();
+  }
+
+  return response;
+});
+
+function getFormattedAmount(amount: BigNumber) {
+  return amount.div(new BigNumber(10).pow(currency.units[0].magnitude)).toString(10);
+}
+
+export async function fetchBaseFee(): 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 = new BigNumber(BASE_FEE).toNumber() || FALLBACK_BASE_FEE;
+  let recommendedFee = baseFee;
+  let networkCongestionLevel = NetworkCongestionLevel.MEDIUM;
+
+  try {
+    const feeStats = await server.feeStats();
+    const ledgerCapacityUsage = feeStats.ledger_capacity_usage;
+    recommendedFee = new BigNumber(feeStats.fee_charged.mode).toNumber();
+
+    if (
+      new BigNumber(ledgerCapacityUsage).toNumber() > TRESHOLD_LOW &&
+      new BigNumber(ledgerCapacityUsage).toNumber() <= TRESHOLD_MEDIUM
+    ) {
+      networkCongestionLevel = NetworkCongestionLevel.MEDIUM;
+    } else if (new BigNumber(ledgerCapacityUsage).toNumber() > TRESHOLD_MEDIUM) {
+      networkCongestionLevel = NetworkCongestionLevel.HIGH;
+    } else {
+      networkCongestionLevel = NetworkCongestionLevel.LOW;
+    }
+  } catch (e) {
+    // do nothing, will use defaults
+  }
+
+  return {
+    baseFee,
+    recommendedFee,
+    networkCongestionLevel,
+  };
+}
+
+/**
+ * Get all account-related data
+ *
+ * @async
+ * @param {string} addr
+ */
+export async function fetchAccount(addr: string): Promise<{
+  blockHeight: number;
+  balance: BigNumber;
+  spendableBalance: BigNumber;
+  assets: BalanceAsset[];
+}> {
+  let account: Horizon.ServerApi.AccountRecord = {} as Horizon.ServerApi.AccountRecord;
+  let assets: BalanceAsset[] = [];
+  let balance = "0";
+
+  try {
+    account = await server.accounts().accountId(addr).call();
+    balance =
+      account.balances?.find(balance => {
+        return balance.asset_type === "native";
+      })?.balance || "0";
+    // Getting all non-native (XLM) assets on the account
+    assets = account.balances?.filter(balance => {
+      return balance.asset_type !== "native";
+    }) as BalanceAsset[];
+  } catch (e) {
+    balance = "0";
+  }
+
+  const formattedBalance = parseCurrencyUnit(currency.units[0], balance);
+
+  const spendableBalance = await getAccountSpendableBalance(formattedBalance, account);
+
+  return {
+    blockHeight: account.sequence ? new BigNumber(account.sequence).toNumber() : 0,
+    balance: formattedBalance,
+    spendableBalance,
+    assets,
+  };
+}
+
+/**
+ * Fetch all operations for a single account from indexer
+ *
+ * @param {string} accountId
+ * @param {string} addr
+ * @param {string} order - "desc" or "asc" order of returned records
+ * @param {string} cursor - point to start fetching records
+ *
+ * @return {Operation[]}
+ */
+export async function fetchOperations({
+  accountId,
+  addr,
+  order,
+  cursor,
+}: {
+  accountId: string;
+  addr: string;
+  order: "asc" | "desc";
+  cursor: string;
+}): Promise<Operation[]> {
+  if (!addr) {
+    return [];
+  }
+
+  let operations: Operation[] = [];
+
+  try {
+    let rawOperations = await server
+      .operations()
+      .forAccount(addr)
+      .limit(LIMIT)
+      .order(order)
+      .cursor(cursor)
+      .includeFailed(true)
+      .join("transactions")
+      .call();
+
+    if (!rawOperations || !rawOperations.records.length) {
+      return [];
+    }
+
+    operations = operations.concat(
+      await rawOperationsToOperations(rawOperations.records as RawOperation[], addr, accountId),
+    );
+
+    while (rawOperations.records.length > 0) {
+      rawOperations = await rawOperations.next();
+      operations = operations.concat(
+        await rawOperationsToOperations(rawOperations.records as RawOperation[], addr, accountId),
+      );
+    }
+
+    return operations;
+  } catch (e: unknown) {
+    // FIXME: terrible hacks, because Stellar SDK fails to cast network failures to typed errors in react-native...
+    // (https://github.com/stellar/js-stellar-sdk/issues/638)
+    const errorMsg = e ? String(e) : "";
+
+    if (e instanceof NotFoundError || errorMsg.match(/status code 404/)) {
+      return [];
+    }
+
+    if (errorMsg.match(/status code 4[0-9]{2}/)) {
+      throw new LedgerAPI4xx();
+    }
+
+    if (errorMsg.match(/status code 5[0-9]{2}/)) {
+      throw new LedgerAPI5xx();
+    }
+
+    if (
+      e instanceof NetworkError ||
+      errorMsg.match(/ECONNRESET|ECONNREFUSED|ENOTFOUND|EPIPE|ETIMEDOUT/) ||
+      errorMsg.match(/undefined is not an object/)
+    ) {
+      throw new NetworkDown();
+    }
+
+    throw e;
+  }
+}
+
+export async function fetchAccountNetworkInfo(account: Account): Promise<NetworkInfo> {
+  try {
+    const extendedAccount = await server.accounts().accountId(account.freshAddress).call();
+    const baseReserve = getReservedBalance(extendedAccount);
+    const { recommendedFee, networkCongestionLevel, baseFee } = await fetchBaseFee();
+
+    return {
+      family: "stellar",
+      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),
+    };
+  }
+}
+
+export async function fetchSequence(account: Account): Promise<BigNumber> {
+  const extendedAccount = await loadAccount(account.freshAddress);
+  return extendedAccount ? new BigNumber(extendedAccount.sequence) : new BigNumber(0);
+}
+
+export async function fetchSigners(account: Account): Promise<Signer[]> {
+  try {
+    const extendedAccount = await server.accounts().accountId(account.freshAddress).call();
+    return extendedAccount.signers;
+  } catch (error) {
+    return [];
+  }
+}
+
+export async function broadcastTransaction(signedTransaction: string): Promise<string> {
+  const transaction = new StellarSdkTransaction(signedTransaction, Networks.PUBLIC);
+  const res = await server.submitTransaction(transaction, {
+    skipMemoRequiredCheck: true,
+  });
+  return res.hash;
+}
+
+export function buildPaymentOperation({
+  destination,
+  amount,
+  assetCode,
+  assetIssuer,
+}: {
+  destination: string;
+  amount: BigNumber;
+  assetCode: string | undefined;
+  assetIssuer: string | undefined;
+}) {
+  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 Asset(assetCode, assetIssuer) : Asset.native();
+  return StellarSdkOperation.payment({
+    destination: destination,
+    amount: formattedAmount,
+    asset,
+  });
+}
+
+export function buildCreateAccountOperation(destination: string, amount: BigNumber) {
+  const formattedAmount = getFormattedAmount(amount);
+  return StellarSdkOperation.createAccount({
+    destination: destination,
+    startingBalance: formattedAmount,
+  });
+}
+
+export function buildChangeTrustOperation(assetCode: string, assetIssuer: string) {
+  return StellarSdkOperation.changeTrust({
+    asset: new Asset(assetCode, assetIssuer),
+  });
+}
+
+export function buildTransactionBuilder(source: StellarSdkAccount, fee: BigNumber) {
+  const formattedFee = fee.toString();
+  return new TransactionBuilder(source, {
+    fee: formattedFee,
+    networkPassphrase: Networks.PUBLIC,
+  });
+}
+
+export async function loadAccount(addr: string): Promise<AccountRecord | null> {
+  if (!addr || !addr.length) {
+    return null;
+  }
+
+  try {
+    return await server.loadAccount(addr);
+  } catch (e) {
+    return null;
+  }
+}