@ledgerhq/coin-stellar 0.2.0-nightly.0

package/src/buildOptimisticOperation.ts

@@ -0,0 +1,63 @@
+import BigNumber from "bignumber.js";
+import { Account } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { StellarOperation, Transaction } from "./types";
+import { getAmountValue } from "./logic";
+import { fetchSequence } from "./network";
+
+export async function buildOptimisticOperation(
+  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(),
+    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;
+}

package/src/buildTransaction.ts

@@ -0,0 +1,106 @@
+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 "./network";
+import { getRecipientAccount, getAmountValue } from "./logic";
+import { StellarAssetRequired, StellarMuxedAccountNotExist } from "./errors";
+
+/**
+ * @param {Account} account
+ * @param {Transaction} transaction
+ */
+export async function buildTransaction(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/cli.ts

@@ -0,0 +1,107 @@
+import invariant from "invariant";
+import type { AccountLike, Account, AccountLikeArray } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/helpers";
+import type { Transaction } from "./types";
+import { getAssetIdFromTokenId } from "./tokens";
+
+const options = [
+  {
+    name: "fee",
+    type: String,
+    desc: "how much fee",
+  },
+  {
+    name: "memoType",
+    type: String,
+    desc: "stellar memo type",
+  },
+  {
+    name: "memoValue",
+    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",
+  },
+] as const;
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: Record<string, any>,
+): 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 function makeCliTools() {
+  return {
+    options,
+    inferTransactions,
+    inferAccounts,
+  };
+}

package/src/config.ts

@@ -0,0 +1,18 @@
+import { CurrencyConfig, CoinConfig } from "@ledgerhq/coin-framework/config";
+import { MissingCoinConfig } from "@ledgerhq/coin-framework/errors";
+
+export type StellarCoinConfig = CurrencyConfig;
+
+let coinConfig: CoinConfig<StellarCoinConfig> | undefined;
+
+export function setCoinConfig(config: CoinConfig<StellarCoinConfig>): void {
+  coinConfig = config;
+}
+
+export function getCoinConfig(): StellarCoinConfig {
+  if (!coinConfig) {
+    throw new MissingCoinConfig();
+  }
+
+  return coinConfig();
+}

package/src/createTransaction.ts

@@ -0,0 +1,25 @@
+import { BigNumber } from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import type { Transaction } from "./types";
+
+/**
+ * Create an empty transaction
+ *
+ * @returns {Transaction}
+ */
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => ({
+  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/deviceTransactionConfig.ts

@@ -0,0 +1,75 @@
+import type { AccountLike, Account } from "@ledgerhq/types-live";
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import type { Transaction, TransactionStatus } from "./types";
+
+export type ExtraDeviceTransactionField =
+  | {
+      type: "stellar.memo";
+      label: string;
+    }
+  | {
+      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",
+      label: "Network",
+    },
+  ];
+
+  if (!amount.isZero()) {
+    fields.push({
+      type: "amount",
+      label: "Amount",
+    });
+  }
+
+  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",
+  });
+
+  //NB device displays [none] for an empty memo
+  if (estimatedFees && !estimatedFees.isZero()) {
+    fields.push({
+      type: "fees",
+      label: "Fees",
+    });
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/errors.ts

@@ -0,0 +1,20 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const StellarBurnAddressError = createCustomErrorClass("StellarBurnAddressError");
+export const StellarAssetRequired = createCustomErrorClass("StellarAssetRequired");
+export const StellarMuxedAccountNotExist = createCustomErrorClass("StellarMuxedAccountNotExist");
+export const StellarMemoRecommended = createCustomErrorClass("StellarMemoRecommended");
+export const StellarWrongMemoFormat = createCustomErrorClass("StellarWrongMemoFormat");
+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 StellarSourceHasMultiSign = createCustomErrorClass("StellarSourceHasMultiSign");

package/src/estimateMaxSpendable.ts

@@ -0,0 +1,29 @@
+import BigNumber from "bignumber.js";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { getMainAccount } from "@ledgerhq/coin-framework/account";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { prepareTransaction } from "./prepareTransaction";
+import { createTransaction } from "./createTransaction";
+import type { Transaction } from "./types";
+
+const notCreatedStellarMockAddress = "GAW46JE3SHIAYLNNNQCAZFQ437WB5ZH7LDRDWR5LVDWHCTHCKYB6RCCH";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const preparedTransaction = await prepareTransaction(mainAccount, {
+    ...createTransaction(account),
+    ...transaction,
+    recipient: transaction?.recipient || notCreatedStellarMockAddress,
+    // not used address
+    useAllAmount: true,
+  });
+
+  const status = await getTransactionStatus(mainAccount, preparedTransaction);
+  return status.amount.gte(0) ? status.amount : new BigNumber(0);
+};
+
+export default estimateMaxSpendable;

package/src/getTransactionStatus.ts

@@ -0,0 +1,207 @@
+import {
+  AccountAwaitingSendPendingOperations,
+  AmountRequired,
+  NotEnoughBalance,
+  FeeNotLoaded,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughSpendableBalance,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+  RecipientRequired,
+  InvalidAddress,
+} from "@ledgerhq/errors";
+import { BigNumber } from "bignumber.js";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { isAddressValid, isAccountMultiSign, isMemoValid, getRecipientAccount } from "./logic";
+import { BASE_RESERVE, MIN_BALANCE } from "./network";
+import type { Transaction } from "./types";
+import {
+  StellarWrongMemoFormat,
+  StellarAssetRequired,
+  StellarAssetNotAccepted,
+  StellarAssetNotFound,
+  StellarNotEnoughNativeBalance,
+  StellarFeeSmallerThanRecommended,
+  StellarFeeSmallerThanBase,
+  StellarNotEnoughNativeBalanceToAddTrustline,
+  StellarMuxedAccountNotExist,
+  StellarSourceHasMultiSign,
+} from "./errors";
+
+export const getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
+  account,
+  transaction,
+) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  const useAllAmount = !!transaction.useAllAmount;
+
+  const destinationNotExistMessage = new NotEnoughBalanceBecauseDestinationNotCreated("", {
+    minimalAmount: `${MIN_BALANCE} XLM`,
+  });
+
+  if (account.pendingOperations.length > 0) {
+    throw new AccountAwaitingSendPendingOperations();
+  }
+
+  if (!transaction.fees || !transaction.baseReserve) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  const estimatedFees = !transaction.fees ? new BigNumber(0) : transaction.fees;
+  const baseReserve = !transaction.baseReserve ? new BigNumber(0) : transaction.baseReserve;
+  const isAssetPayment =
+    transaction.subAccountId && transaction.assetCode && transaction.assetIssuer;
+  const nativeBalance = account.balance;
+  const nativeAmountAvailable = account.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(transaction.networkInfo?.baseFee || 0)) {
+    errors.transaction = new StellarFeeSmallerThanBase();
+    // Entered fee is smaller than recommended
+  } else if (estimatedFees.lt(transaction.networkInfo?.fees || 0)) {
+    warnings.transaction = new StellarFeeSmallerThanRecommended();
+  }
+
+  // Operation specific checks
+  if (transaction.mode === "changeTrust") {
+    // Check asset provided
+    if (!transaction.assetCode || !transaction.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 (!transaction.recipient) {
+      errors.recipient = new RecipientRequired("");
+    } else if (!isAddressValid(transaction.recipient)) {
+      errors.recipient = new InvalidAddress("", {
+        currencyName: account.currency.name,
+      });
+    } else if (account.freshAddress === transaction.recipient) {
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+    }
+
+    const recipientAccount = await getRecipientAccount({
+      account: account,
+      recipient: transaction.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(account, transaction.subAccountId || "");
+
+      if (asset === null) {
+        // This is unlikely
+        throw new StellarAssetNotFound();
+      }
+
+      // Check recipient account accepts asset
+      if (
+        recipientAccount?.id &&
+        !errors.recipient &&
+        !warnings.recipient &&
+        !recipientAccount.assetIds.includes(`${transaction.assetCode}:${transaction.assetIssuer}`)
+      ) {
+        errors.recipient = new StellarAssetNotAccepted("", {
+          assetCode: transaction.assetCode,
+        });
+      }
+
+      const assetBalance = asset?.balance || new BigNumber(0);
+
+      maxAmount = asset?.spendableBalance || assetBalance;
+      amount = useAllAmount ? maxAmount : transaction.amount;
+      totalSpent = amount;
+
+      if (!errors.amount && amount.gt(assetBalance)) {
+        errors.amount = new NotEnoughBalance();
+      }
+    } else {
+      // Native payment
+      maxAmount = nativeAmountAvailable;
+      amount = useAllAmount ? maxAmount : transaction.amount || 0;
+
+      if (amount.gt(maxAmount)) {
+        errors.amount = new NotEnoughBalance();
+      }
+
+      totalSpent = useAllAmount ? nativeAmountAvailable : transaction.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(account.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(account)) {
+    errors.recipient = new StellarSourceHasMultiSign();
+  }
+
+  if (
+    transaction.memoType &&
+    transaction.memoValue &&
+    !isMemoValid(transaction.memoType, transaction.memoValue)
+  ) {
+    errors.transaction = new StellarWrongMemoFormat();
+  }
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};
+
+export default getTransactionStatus;

package/src/hw-getAddress.ts

@@ -0,0 +1,24 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { StrKey } from "@stellar/stellar-sdk";
+import { StellarSigner } from "./types/signer";
+
+function resolver(signerContext: SignerContext<StellarSigner>): GetAddressFn {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const rawPublicKey = await signerContext(deviceId, async signer => {
+      const { rawPublicKey } = await signer.getPublicKey(path, verify);
+      return rawPublicKey;
+    });
+
+    const publicKey = StrKey.encodeEd25519PublicKey(rawPublicKey);
+
+    return {
+      path,
+      address: publicKey,
+      publicKey: rawPublicKey.toString("hex"),
+    };
+  };
+}
+
+export default resolver;