@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

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

@@ -1,33 +1,23 @@
-import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+import type { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
 import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
-import type { Transaction } from "../types";
-import { scanAccounts, sync } from "../js-synchronization";
-import getTransactionStatus from "../js-getTransactionStatus";
-import estimateMaxSpendable from "../js-estimateMaxSpendable";
-import createTransaction from "../js-createTransaction";
-import prepareTransaction from "../js-prepareTransaction";
-import signOperation from "../js-signOperation";
-import broadcast from "../js-broadcast";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-
-const preload = async (): Promise<any> => {};
-
-const hydrate = (): void => {};
-
-const receive = makeAccountBridgeReceive();
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export const getPreloadStrategy = (currency: CryptoCurrency): any => ({});
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { getTransactionStatus } from "../getTransactionStatus";
+import type { Transaction, TransactionStatus } from "../types";
+import { prepareTransaction } from "../prepareTransaction";
+import { createTransaction } from "../createTransaction";
+import { scanAccounts, sync } from "../synchronization";
+import { signOperation } from "../signOperation";
+import { broadcast } from "../broadcast";
 
 const currencyBridge: CurrencyBridge = {
-  getPreloadStrategy,
-  preload,
-  hydrate,
+  preload: async () => {},
+  hydrate: () => {},
   scanAccounts,
 };
 
-const accountBridge: AccountBridge<Transaction> = {
+const receive = makeAccountBridgeReceive();
+const accountBridge: AccountBridge<Transaction, Account, TransactionStatus> = {
   createTransaction,
   updateTransaction: defaultUpdateTransaction,
   prepareTransaction,

package/src/families/stellar/broadcast.ts

@@ -0,0 +1,20 @@
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import type { AccountBridge, Operation, SignedOperation } from "@ledgerhq/types-live";
+import { broadcastTransaction as apiBroadcast } from "./api";
+import { Transaction } from "./types";
+
+/**
+ * Broadcast a signed transaction
+ * @param {signature: string, operation: string} signedOperation
+ */
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation,
+}: {
+  signedOperation: SignedOperation;
+}): Promise<Operation> => {
+  const { signature, operation } = signedOperation;
+  const hash = await apiBroadcast(signature);
+  return patchOperationWithHash(operation, hash);
+};
+
+export default broadcast;

package/src/families/stellar/buildOptimisticOperation.ts

@@ -0,0 +1,63 @@
+import BigNumber from "bignumber.js";
+import { Account } from "@ledgerhq/types-live";
+import { StellarOperation, Transaction } from "./types";
+import { encodeOperationId } from "../../operation";
+import { getAmountValue } from "./logic";
+import { fetchSequence } from "./api";
+
+export const buildOptimisticOperation = async (
+  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/families/stellar/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 "./api";
+import { getRecipientAccount, getAmountValue } from "./logic";
+import { StellarAssetRequired, StellarMuxedAccountNotExist } from "../../errors";
+
+/**
+ * @param {Account} account
+ * @param {Transaction} transaction
+ */
+export const buildTransaction = async (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/families/stellar/createTransaction.ts

@@ -0,0 +1,25 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "./types";
+import { AccountBridge } from "@ledgerhq/types-live";
+
+/**
+ * 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/families/stellar/estimateMaxSpendable.ts

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

package/src/families/stellar/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 "./api";
+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/families/stellar/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 "./api";
+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/families/stellar/signOperation.ts

@@ -0,0 +1,60 @@
+import { Observable } from "rxjs";
+import Stellar from "@ledgerhq/hw-app-str";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { withDevice } from "../../hw/deviceAccess";
+import type { Transaction } from "./types";
+import { buildTransaction } from "./buildTransaction";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const signOperation: AccountBridge<Transaction>["signOperation"] = ({
+  account,
+  deviceId,
+  transaction,
+}) =>
+  withDevice(deviceId)(
+    transport =>
+      new Observable(o => {
+        async function main() {
+          o.next({
+            type: "device-signature-requested",
+          });
+
+          // Fees are loaded during prepareTransaction
+          if (!transaction.fees) {
+            throw new FeeNotLoaded();
+          }
+
+          const unsigned = await buildTransaction(account, transaction);
+          const unsignedPayload: Buffer = Buffer.from(unsigned.signatureBase());
+          // Sign by device
+          const hwApp = new Stellar(transport);
+          const { signature } = await hwApp.signTransaction(
+            account.freshAddressPath,
+            unsignedPayload,
+          );
+          unsigned.addSignature(account.freshAddress, signature.toString("base64"));
+          o.next({
+            type: "device-signature-granted",
+          });
+          const operation = await buildOptimisticOperation(account, transaction);
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature: unsigned.toXDR(),
+            },
+          });
+        }
+
+        main().then(
+          () => o.complete(),
+          e => o.error(e),
+        );
+      }),
+  );
+
+export default signOperation;

package/src/families/tezos/setup.ts

@@ -2,7 +2,12 @@
 
 import { DerivationType, LedgerSigner } from "@taquito/ledger-signer";
 import { createBridges } from "@ledgerhq/coin-tezos/bridge/index";
-import type { Transaction, TezosSigner } from "@ledgerhq/coin-tezos/types/index";
+import type {
+  Transaction,
+  TezosSigner,
+  TransactionStatus,
+  TezosAccount,
+} from "@ledgerhq/coin-tezos/types/index";
 import makeCliTools from "@ledgerhq/coin-tezos/test/cli";
 import type { CliTools } from "@ledgerhq/coin-tezos/test/cli";
 import tezosResolver from "@ledgerhq/coin-tezos/signer/index";
@@ -38,7 +43,9 @@ const createSigner: CreateSigner<TezosSigner> = (transport: Transport) => {
   };
 };
 
-const bridge: Bridge<Transaction> = createBridges(executeWithSigner(createSigner));
+const bridge: Bridge<Transaction, TezosAccount, TransactionStatus> = createBridges(
+  executeWithSigner(createSigner),
+);
 
 const resolver: Resolver = createResolver(createSigner, tezosResolver);