@ledgerhq/coin-stellar 0.2.0-nightly.0

package/src/network/index.ts

@@ -0,0 +1,17 @@
+export {
+  fetchAccount,
+  fetchOperations,
+  fetchBaseFee,
+  fetchSequence,
+  fetchSigners,
+  fetchAccountNetworkInfo,
+  broadcastTransaction,
+  buildPaymentOperation,
+  buildCreateAccountOperation,
+  buildChangeTrustOperation,
+  buildTransactionBuilder,
+  loadAccount,
+  BASE_RESERVE,
+  BASE_RESERVE_MIN_COUNT,
+  MIN_BALANCE,
+} from "./horizon";

package/src/prepareTransaction.ts

@@ -0,0 +1,35 @@
+import invariant from "invariant";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { fetchAccountNetworkInfo } from "./network";
+import { getAssetCodeIssuer } from "./logic";
+import type { Transaction } from "./types";
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  const networkInfo = transaction.networkInfo || (await fetchAccountNetworkInfo(account));
+  invariant(networkInfo.family === "stellar", "stellar networkInfo expected");
+  const fees = transaction.fees || networkInfo.fees;
+  const baseReserve = transaction.baseReserve || networkInfo.baseReserve;
+  const [assetCode, assetIssuer] = getAssetCodeIssuer(transaction);
+
+  if (
+    transaction.networkInfo !== networkInfo ||
+    transaction.fees !== fees ||
+    transaction.baseReserve !== baseReserve
+  ) {
+    return defaultUpdateTransaction(transaction, {
+      networkInfo,
+      fees,
+      baseReserve,
+      assetCode,
+      assetIssuer,
+    });
+  }
+
+  return defaultUpdateTransaction(transaction, { assetCode, assetIssuer });
+};
+
+export default prepareTransaction;

package/src/signOperation.ts

@@ -0,0 +1,58 @@
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import type { Account, AccountBridge } from "@ledgerhq/types-live";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { Transaction } from "./types";
+import { buildTransaction } from "./buildTransaction";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { StellarSigner } from "./types/signer";
+
+export function buildSignOperation(
+  signerContext: SignerContext<StellarSigner>,
+): AccountBridge<Transaction, Account>["signOperation"] {
+  return function signOperation({ account, deviceId, transaction }) {
+    return new Observable(obs => {
+      let cancelled = false;
+
+      async function main() {
+        obs.next({ type: "device-signature-requested" });
+
+        if (cancelled) {
+          return;
+        }
+
+        if (!transaction.fees) {
+          throw new FeeNotLoaded();
+        }
+
+        const unsigned = await buildTransaction(account, transaction);
+        const unsignedPayload: Buffer = Buffer.from(unsigned.signatureBase());
+        // Sign by device
+        const { signature } = await signerContext(deviceId, signer =>
+          signer.signTransaction(account.freshAddressPath, unsignedPayload),
+        );
+        unsigned.addSignature(account.freshAddress, signature.toString("base64"));
+        obs.next({
+          type: "device-signature-granted",
+        });
+        const operation = await buildOptimisticOperation(account, transaction);
+        obs.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: unsigned.toXDR(),
+          },
+        });
+      }
+
+      main().then(
+        () => obs.complete(),
+        err => obs.error(err),
+      );
+
+      return () => {
+        cancelled = true;
+      };
+    });
+  };
+}

package/src/specs.ts

@@ -0,0 +1,290 @@
+import expect from "expect";
+import invariant from "invariant";
+import BigNumber from "bignumber.js";
+import { DeviceModelId } from "@ledgerhq/devices";
+import type { SubAccount } from "@ledgerhq/types-live";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { botTest, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets/tokens";
+import { acceptTransaction } from "./speculos-deviceActions";
+import type { Transaction } from "./types";
+
+const currency = getCryptoCurrencyById("stellar");
+const minAmountCutoff = parseCurrencyUnit(currency.units[0], "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,
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Stellar",
+  },
+  genericDeviceAction: acceptTransaction,
+  testTimeout: 2 * 60 * 1000,
+  minViableAmount: minAmountCutoff,
+  mutations: [
+    {
+      name: "move ~50% 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;
+        let amount = maxSpendable.div(1.9 + 0.2 * Math.random()).integerValue();
+
+        if (!sibling.used && amount.lt(reserve)) {
+          invariant(
+            maxSpendable.gt(reserve.plus(minAmountCutoff)),
+            "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.
+        botTest("account balance decreased with operation", () =>
+          expect(account.balance.toNumber()).toBeLessThanOrEqual(
+            accountBeforeTransaction.balance.minus(operation.value).toNumber(),
+          ),
+        );
+
+        if (transaction.memoValue) {
+          botTest("operation memo", () =>
+            expect(operation.extra).toMatchObject({
+              memo: transaction.memoValue,
+            }),
+          );
+        }
+
+        const getType = () => {
+          switch (transaction.mode) {
+            case "send":
+              return "send";
+            case "changeTrust":
+              return /change_trust/;
+            default:
+              return "";
+          }
+        };
+
+        botTest("transaction mode", () => 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,
+          },
+        ];
+
+        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.
+        botTest("balance decreased with operation", () =>
+          expect(account.balance.toNumber()).toBeLessThanOrEqual(
+            accountBeforeTransaction.balance.minus(operation.value).toNumber(),
+          ),
+        );
+
+        if (transaction.memoValue) {
+          botTest("operation memo", () =>
+            expect(operation.extra).toMatchObject({
+              memo: transaction.memoValue,
+            }),
+          );
+        }
+
+        const getType = () => {
+          switch (transaction.mode) {
+            case "send":
+              return "send";
+            case "changeTrust":
+              return /change_trust/;
+            default:
+              return "";
+          }
+        };
+
+        botTest("transaction mode", () => 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));
+        botTest("has asset", () => 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);
+
+        botTest("asset balance decreased with operation", () =>
+          expect(asset?.balance.toString()).toBe(
+            assetBeforeTx?.balance.minus(status.amount).toString(),
+          ),
+        );
+
+        if (transaction.memoValue) {
+          botTest("operation memo", () =>
+            expect(operation.extra).toMatchObject({
+              memo: transaction.memoValue,
+            }),
+          );
+        }
+      },
+    },
+  ],
+};
+export default {
+  stellar,
+};

package/src/speculos-deviceActions.ts

@@ -0,0 +1,117 @@
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
+import {
+  deviceActionFlow,
+  formatDeviceAmount,
+  SpeculosButton,
+} from "@ledgerhq/coin-framework/bot/specs";
+import { Account } from "@ledgerhq/types-live";
+import type { Transaction, TransactionStatus } from "./types";
+
+function expectedAmount({
+  account,
+  status,
+  transaction,
+}: {
+  account: Account;
+  status: TransactionStatus;
+  transaction: Transaction;
+}) {
+  if (transaction.assetCode && transaction.assetIssuer) {
+    const amount = formatDeviceAmount(account.currency, status.amount, {
+      hideCode: true,
+    });
+
+    return `${amount} ${transaction.assetCode}@${truncateAddress(transaction.assetIssuer, 3, 4)}`;
+  }
+
+  return formatDeviceAmount(account.currency, status.amount, {
+    postfixCode: true,
+  });
+}
+
+function truncateAddress(stellarAddress: string, start = 6, end = 6) {
+  return `${stellarAddress.slice(0, start)}..${stellarAddress.slice(-end)}`;
+}
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Review",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Memo Text",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.memoValue || "",
+    },
+    {
+      title: "Max Fee",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, status }) =>
+        formatCurrencyUnit(getAccountCurrency(account).units[0], status.estimatedFees, {
+          disableRounding: true,
+        }) + " XLM",
+    },
+    {
+      title: "Sequence Num",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Tx Source",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account }) => truncateAddress(account.freshAddress),
+    },
+    {
+      title: "Operation Type",
+      button: SpeculosButton.RIGHT,
+      // Operation type can be Payment (or Create Account) or Change Trust.
+      // Create Account type is coming from operation, not transaction.
+      // Testing in `specs.ts`.
+    },
+    {
+      title: "Change Trust",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) =>
+        `${transaction.assetCode || ""}@${truncateAddress(transaction.assetIssuer || "", 3, 4)}`,
+      maxY: 5,
+    },
+    {
+      title: "Create Account",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.recipient,
+      maxY: 5,
+    },
+    {
+      title: "Send",
+      button: SpeculosButton.RIGHT,
+      expectedValue: expectedAmount,
+    },
+    {
+      title: "Destination",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Finalize",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Starting Balance",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Network",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Valid Before (UTC)",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Valid After (UTC)",
+      button: SpeculosButton.RIGHT,
+    },
+  ],
+});

package/src/synchronization.ts

@@ -0,0 +1,80 @@
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { inferSubOperations } from "@ledgerhq/coin-framework/serialization/index";
+import { Account } from "@ledgerhq/types-live";
+import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { fetchAccount, fetchOperations } from "./network";
+import { buildSubAccounts } from "./tokens";
+import { StellarOperation } from "./types";
+import { STELLAR_BURN_ADDRESS } from "./logic";
+import { StellarBurnAddressError } from "./errors";
+
+export const getAccountShape: GetAccountShape<Account> = async (info, syncConfig) => {
+  const { address, currency, initialAccount, derivationMode } = info;
+
+  // FIXME Workaround for burn address, see https://ledgerhq.atlassian.net/browse/LIVE-4014
+  if (address === STELLAR_BURN_ADDRESS) throw new StellarBurnAddressError();
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+
+  const { blockHeight, balance, spendableBalance, assets } = await fetchAccount(address);
+
+  const oldOperations = (initialAccount?.operations || []) as StellarOperation[];
+  const lastPagingToken = oldOperations[0]?.extra.pagingToken || "0";
+
+  const newOperations =
+    (await fetchOperations({
+      accountId,
+      addr: address,
+      order: "asc",
+      cursor: lastPagingToken,
+    })) || [];
+
+  const allOperations = mergeOps(oldOperations, newOperations) as StellarOperation[];
+  const assetOperations: StellarOperation[] = [];
+
+  allOperations.forEach(operation => {
+    if (
+      operation?.extra?.assetCode &&
+      operation?.extra?.assetIssuer &&
+      !["OPT_IN", "OPT_OUT"].includes(operation.type)
+    ) {
+      assetOperations.push(operation);
+    }
+  });
+
+  const subAccounts =
+    buildSubAccounts({
+      currency,
+      accountId,
+      assets,
+      syncConfig,
+      operations: assetOperations,
+    }) || [];
+
+  const shape = {
+    id: accountId,
+    balance,
+    spendableBalance,
+    operationsCount: allOperations.length,
+    blockHeight,
+    subAccounts,
+  };
+
+  return {
+    ...shape,
+    operations: allOperations.map(op => {
+      const subOperations = inferSubOperations(op.hash, subAccounts);
+
+      return {
+        ...op,
+        subOperations,
+      };
+    }),
+  };
+};

package/src/tokens.ts

@@ -0,0 +1,98 @@
+import BigNumber from "bignumber.js";
+import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { SyncConfig, TokenAccount } from "@ledgerhq/types-live";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/parseCurrencyUnit";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { findTokenById, listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
+import type { BalanceAsset, StellarOperation } from "./types";
+
+export const getAssetIdFromTokenId = (tokenId: string): string => tokenId.split("/")[2];
+
+const getAssetIdFromAsset = (asset: BalanceAsset) => `${asset.asset_code}:${asset.asset_issuer}`;
+
+function buildStellarTokenAccount({
+  parentAccountId,
+  stellarAsset,
+  token,
+  operations,
+}: {
+  parentAccountId: string;
+  stellarAsset: BalanceAsset;
+  token: TokenCurrency;
+  operations: StellarOperation[];
+}): TokenAccount {
+  const assetId = getAssetIdFromTokenId(token.id);
+  const id = `${parentAccountId}+${assetId}`;
+  const balance = parseCurrencyUnit(token.units[0], stellarAsset.balance || "0");
+
+  const reservedBalance = new BigNumber(stellarAsset.balance).minus(
+    stellarAsset.selling_liabilities || 0,
+  );
+  const spendableBalance = parseCurrencyUnit(token.units[0], reservedBalance.toString());
+
+  return {
+    type: "TokenAccount",
+    id,
+    parentId: parentAccountId,
+    token,
+    operationsCount: operations.length,
+    operations: operations.map(op => ({
+      ...op,
+      id: encodeOperationId(id, op.hash, op.extra.ledgerOpType),
+      accountId: id,
+      type: op.extra.ledgerOpType,
+      value: op.extra.assetAmount ? new BigNumber(op.extra.assetAmount) : op.value,
+    })),
+    pendingOperations: [],
+    balance,
+    spendableBalance,
+    swapHistory: [],
+    creationDate: operations.length > 0 ? operations[operations.length - 1].date : new Date(),
+    balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
+  };
+}
+
+export function buildSubAccounts({
+  currency,
+  accountId,
+  assets,
+  syncConfig,
+  operations,
+}: {
+  currency: CryptoCurrency;
+  accountId: string;
+  assets: BalanceAsset[];
+  syncConfig: SyncConfig;
+  operations: StellarOperation[];
+}): TokenAccount[] | undefined {
+  const { blacklistedTokenIds = [] } = syncConfig;
+  const allTokens = listTokensForCryptoCurrency(currency);
+
+  if (allTokens.length === 0 || assets.length === 0) {
+    return undefined;
+  }
+
+  const tokenAccounts: TokenAccount[] = [];
+
+  assets.map(asset => {
+    const token = findTokenById(`stellar/asset/${getAssetIdFromAsset(asset)}`);
+
+    if (token && !blacklistedTokenIds.includes(token.id)) {
+      tokenAccounts.push(
+        buildStellarTokenAccount({
+          parentAccountId: accountId,
+          stellarAsset: asset,
+          token,
+          operations: operations.filter(
+            op =>
+              op.extra.assetCode === asset.asset_code &&
+              op.extra.assetIssuer === asset.asset_issuer,
+          ),
+        }),
+      );
+    }
+  });
+
+  return tokenAccounts;
+}