@ledgerhq/live-common 21.22.1 → 21.23.0

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

@@ -102,7 +102,7 @@ function inferTransactions(
       memo: opts.memo,
       mode: opts.mode || "send",
       subAccountId: account.type === "TokenAccount" ? account.id : null,
-      assetId: "algorand/asa/" + opts.token,
+      assetId: opts.token ? "algorand/asa/" + opts.token : null,
     };
   });
 }

package/src/families/algorand/deviceTransactionConfig.ts

@@ -3,7 +3,7 @@ import type {
   TransactionStatus,
   TokenCurrency,
 } from "../../types";
-import type { Transaction } from "./types";
+import type { AlgorandTransaction } from "./types";
 import type { DeviceTransactionField } from "../../transaction";
 import { getAccountUnit } from "../../account";
 import { formatCurrencyUnit, findTokenById } from "../../currencies";
@@ -68,7 +68,7 @@ function getDeviceTransactionConfig({
   status,
 }: {
   account: AccountLike;
-  transaction: Transaction;
+  transaction: AlgorandTransaction;
   status: TransactionStatus;
 }): Array<DeviceTransactionField> {
   const { mode, assetId } = transaction;
@@ -121,20 +121,6 @@ function getDeviceTransactionConfig({
       });
       break;
 
-    case "optOut":
-      fields.push({
-        type: "text",
-        label: "Type",
-        value: "Opt out",
-      });
-      if (assetId)
-        fields.push({
-          type: "text",
-          label: "Asset id",
-          value: assetId,
-        });
-      break;
-
     default:
       break;
   }

package/src/families/algorand/hw-getAddress.ts

@@ -1,20 +1,11 @@
 import Algorand from "@ledgerhq/hw-app-algorand";
 import type { Resolver } from "../../hw/getAddress/types";
-import { withLibcore } from "../../libcore/access";
-
-const convertPubkeyToAddress = async (pubkey) => {
-  return await withLibcore(async (core) => {
-    const address = await core.AlgorandAddress.fromPublicKey(pubkey);
-    return address;
-  });
-};
 
 const resolver: Resolver = async (transport, { path, verify }) => {
   const algorand = new Algorand(transport);
   const r = await algorand.getAddress(path, verify || false);
-  const address = await convertPubkeyToAddress(r.publicKey);
   return {
-    address: address,
+    address: r.address,
     publicKey: r.publicKey,
     path,
   };

package/src/families/algorand/js-broadcast.ts

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

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

@@ -0,0 +1,51 @@
+import { BigNumber } from "bignumber.js";
+import type { Account, AccountLike } from "../../types";
+import { getMainAccount } from "../../account";
+import type { AlgorandTransaction } from "./types";
+import { computeAlgoMaxSpendable } from "./logic";
+import { createTransaction } from "./js-prepareTransaction";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+
+export const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount?: Account | null | undefined;
+  transaction?: AlgorandTransaction | null | undefined;
+}): Promise<BigNumber> => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const { algorandResources } = mainAccount;
+  if (!algorandResources) {
+    throw new Error("Algorand account expected");
+  }
+
+  const tx = {
+    ...createTransaction(),
+    subAccountId: account.type === "Account" ? null : account.id,
+    ...transaction,
+    recipient:
+      transaction?.recipient || getAbandonSeedAddress(mainAccount.currency.id),
+    useAllAmount: true,
+  };
+
+  const tokenAccount =
+    tx.subAccountId &&
+    mainAccount.subAccounts &&
+    mainAccount.subAccounts.find((ta) => ta.id === tx.subAccountId);
+
+  if (tokenAccount) {
+    return tokenAccount.balance;
+  } else {
+    let maxSpendable = computeAlgoMaxSpendable({
+      accountBalance: mainAccount.balance,
+      nbAccountAssets: algorandResources.nbAssets,
+      mode: tx.mode,
+    });
+    if (tx.fees) {
+      maxSpendable = maxSpendable.minus(tx.fees);
+    }
+    return maxSpendable.gte(0) ? maxSpendable : new BigNumber(0);
+  }
+};

package/src/families/algorand/js-getFeesForTransaction.ts

@@ -0,0 +1,25 @@
+import { BigNumber } from "bignumber.js";
+import type { Account } from "../../types";
+import type { Transaction } from "./types";
+import { getTransactionParams } from "./api";
+import { buildTransactionPayload, encodeToSign } from "./buildTransaction";
+
+// This is only true for a single signature. If we ever support different type of signatures
+// (e.g multi signatures), we will have to add the correct corresponding number of bytes.
+const SINGLE_SIGNATURE_SIZE = 71;
+
+export const getEstimatedFees = async (
+  account: Account,
+  transaction: Transaction
+): Promise<BigNumber> => {
+  const params = await getTransactionParams();
+
+  let suggestedFees = 0;
+  if (params.fee) {
+    const payload = await buildTransactionPayload(account, transaction);
+    const encoded = await encodeToSign(payload);
+    suggestedFees =
+      params.fee * (Buffer.from(encoded, "hex").length + SINGLE_SIGNATURE_SIZE);
+  }
+  return new BigNumber(Math.max(suggestedFees, params.minFee));
+};

package/src/families/algorand/js-getTransactionStatus.ts

@@ -0,0 +1,178 @@
+import invariant from "invariant";
+import { BigNumber } from "bignumber.js";
+import { isValidAddress } from "algosdk";
+
+import {
+  RecipientRequired,
+  AmountRequired,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  FeeNotLoaded,
+  FeeTooHigh,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+  NotEnoughBalanceInParentAccount,
+  InvalidAddress,
+} from "@ledgerhq/errors";
+
+import {
+  ClaimRewardsFeesWarning,
+  AlgorandASANotOptInInRecipient,
+} from "../../errors";
+import type { Account } from "../../types";
+import type { AlgorandResources, Transaction } from "./types";
+import { extractTokenId } from "./tokens";
+import {
+  ALGORAND_MAX_MEMO_SIZE,
+  recipientHasAsset,
+  isAmountValid,
+  computeAlgoMaxSpendable,
+} from "./logic";
+
+/*
+ * Here are the list of the differents things we check
+ * - Check if recipient is the same in case of send
+ * - Check if recipient is valid
+ * - Check if amounts are set
+ * - Check if fees are loaded
+ * - Check if is a send Max and set the amount
+ * - Check if Token is already optin at the recipient
+ * - Check if memo is too long
+ */
+export const getTransactionStatus = async (a: Account, t: Transaction) => {
+  const errors: any = {};
+  const warnings: any = {};
+  const tokenAccount = !t.subAccountId
+    ? null
+    : a.subAccounts && a.subAccounts.find((ta) => ta.id === t.subAccountId);
+
+  if (!t.recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (!(await isValidAddress(t.recipient))) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: a.currency.name,
+    });
+  } else if (t.mode === "send" && a.freshAddress === t.recipient) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  const estimatedFees = t.fees || new BigNumber(0);
+  let amount = t.amount;
+  let totalSpent = estimatedFees;
+
+  invariant(a.algorandResources, "Algorand family expected");
+  const algorandResources = a.algorandResources as AlgorandResources;
+
+  const algoSpendableBalance = computeAlgoMaxSpendable({
+    accountBalance: a.balance,
+    nbAccountAssets: algorandResources.nbAssets,
+    mode: t.mode,
+  });
+
+  switch (t.mode) {
+    case "send": {
+      if (amount.lte(0) && !t.useAllAmount) {
+        errors.amount = new AmountRequired();
+      }
+
+      if (!t.fees || !t.fees.gt(0)) {
+        errors.fees = new FeeNotLoaded();
+      }
+
+      if (
+        tokenAccount &&
+        tokenAccount.type === "TokenAccount" &&
+        !errors.recipient &&
+        !(await recipientHasAsset(
+          t.recipient,
+          extractTokenId(tokenAccount.token.id)
+        ))
+      ) {
+        errors.recipient = new AlgorandASANotOptInInRecipient();
+      }
+
+      amount = t.useAllAmount
+        ? tokenAccount
+          ? tokenAccount.balance
+          : algoSpendableBalance.minus(estimatedFees)
+        : amount;
+
+      if (amount.lt(0)) {
+        amount = new BigNumber(0);
+      }
+
+      totalSpent = tokenAccount ? amount : amount.plus(estimatedFees);
+
+      if (!errors.recipient && !(await isAmountValid(t.recipient, amount))) {
+        errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
+          minimalAmount: "0.1 ALGO",
+        });
+      }
+
+      if (!tokenAccount && amount.gt(0) && estimatedFees.times(10).gt(amount)) {
+        warnings.feeTooHigh = new FeeTooHigh();
+      }
+
+      if (
+        (amount.lte(0) && t.useAllAmount) || // if use all Amount sets an amount at 0
+        (!errors.recipient && !errors.amount && tokenAccount
+          ? totalSpent.gt(tokenAccount.balance)
+          : totalSpent.gt(algoSpendableBalance)) // if spendable balance lower than total
+      ) {
+        errors.amount = new NotEnoughBalance();
+      }
+
+      // if spendable balance lower than fees for token
+      if (
+        !errors.amount &&
+        tokenAccount &&
+        algoSpendableBalance.lt(estimatedFees)
+      ) {
+        errors.amount = new NotEnoughBalanceInParentAccount();
+      }
+
+      break;
+    }
+
+    case "optIn": {
+      if (!t.fees || !t.fees.gt(0)) {
+        errors.fees = new FeeNotLoaded();
+      }
+
+      // This error doesn't need to be translate,
+      // it will use to block until the user choose an assetId
+      if (!t.assetId) {
+        errors.assetId = new Error("Asset Id is not set");
+      }
+
+      if (algoSpendableBalance.lt(estimatedFees)) {
+        errors.amount = new NotEnoughBalance();
+      }
+
+      break;
+    }
+
+    case "claimReward": {
+      if (algoSpendableBalance.lt(totalSpent)) {
+        errors.amount = new NotEnoughBalance();
+      }
+
+      if (estimatedFees.gt(algorandResources.rewards)) {
+        warnings.claimReward = new ClaimRewardsFeesWarning();
+      }
+
+      break;
+    }
+  }
+
+  if (t.memo && t.memo.length > ALGORAND_MAX_MEMO_SIZE) {
+    throw new Error("Memo is too long");
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  });
+};

package/src/families/algorand/js-prepareTransaction.ts

@@ -0,0 +1,42 @@
+import { BigNumber } from "bignumber.js";
+import type { Account } from "../../types";
+import type { Transaction } from "./types";
+import { getEstimatedFees } from "./js-getFeesForTransaction";
+import { estimateMaxSpendable } from "./js-estimateMaxSpendable";
+
+export const createTransaction = (): Transaction => ({
+  family: "algorand",
+  amount: new BigNumber(0),
+  fees: null,
+  recipient: "",
+  useAllAmount: false,
+  memo: null,
+  mode: "send",
+  assetId: null,
+});
+
+export const prepareTransaction = async (
+  account: Account,
+  transaction: Transaction
+): Promise<Transaction> => {
+  let recipient: string;
+  let amount: BigNumber;
+  if (transaction.mode === "send") {
+    recipient = transaction.recipient;
+    amount = transaction.useAllAmount
+      ? await estimateMaxSpendable({ account, transaction })
+      : transaction.amount;
+  } else if (
+    transaction.mode === "optIn" ||
+    transaction.mode === "claimReward"
+  ) {
+    recipient = account.freshAddress;
+    amount = new BigNumber(0);
+  } else {
+    throw new Error(`Unsupported transaction mode '${transaction.mode}'`);
+  }
+
+  const fees = await getEstimatedFees(account, transaction);
+
+  return { ...transaction, fees, amount, recipient };
+};

package/src/families/algorand/js-signOperation.ts

@@ -0,0 +1,145 @@
+import { BigNumber } from "bignumber.js";
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import Algorand from "@ledgerhq/hw-app-algorand";
+import type { Account, Operation, SignOperationEvent } from "../../types";
+import { withDevice } from "../../hw/deviceAccess";
+import type { Transaction } from "./types";
+import {
+  buildTransactionPayload,
+  encodeToSign,
+  encodeToBroadcast,
+} from "./buildTransaction";
+
+export const signOperation = ({
+  account,
+  transaction,
+  deviceId,
+}: {
+  account: Account;
+  transaction: Transaction;
+  deviceId: any;
+}): Observable<SignOperationEvent> =>
+  withDevice(deviceId)((transport) =>
+    Observable.create((o) => {
+      let cancelled;
+
+      async function main() {
+        if (!transaction.fees) {
+          throw new FeeNotLoaded();
+        }
+
+        const algoTx = await buildTransactionPayload(account, transaction);
+
+        const toSign = await encodeToSign(algoTx);
+
+        const hwApp = new Algorand(transport);
+        const { freshAddressPath } = account;
+
+        o.next({ type: "device-signature-requested" });
+
+        const { signature } = await hwApp.sign(freshAddressPath, toSign);
+
+        if (cancelled) return;
+
+        o.next({ type: "device-signature-granted" });
+
+        if (!signature) {
+          throw new Error("No signature");
+        }
+
+        const toBroadcast = await encodeToBroadcast(algoTx, signature);
+
+        const operation = buildOptimisticOperation(account, transaction);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: toBroadcast,
+            expirationDate: null,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        (e) => o.error(e)
+      );
+
+      return () => {
+        cancelled = true;
+      };
+    })
+  );
+
+const buildOptimisticOperation = (
+  account: Account,
+  transaction: Transaction
+): Operation => {
+  const { spendableBalance, id, freshAddress, subAccounts } = account;
+
+  const senders = [freshAddress];
+  const recipients = [transaction.recipient];
+  const { subAccountId, fees } = transaction;
+
+  if (!fees) {
+    throw new FeeNotLoaded();
+  }
+
+  const value = subAccountId
+    ? fees
+    : transaction.useAllAmount
+    ? spendableBalance
+    : transaction.amount.plus(fees);
+
+  const type = subAccountId
+    ? "FEES"
+    : transaction.mode === "optIn"
+    ? "OPT_IN"
+    : "OUT";
+
+  const op: Operation = {
+    id: `${id}--${type}`,
+    hash: "",
+    type,
+    value,
+    fee: fees,
+    blockHash: null,
+    blockHeight: null,
+    senders,
+    recipients,
+    accountId: id,
+    date: new Date(),
+    extra: {},
+  };
+
+  const tokenAccount = !subAccountId
+    ? null
+    : subAccounts && subAccounts.find((ta) => ta.id === subAccountId);
+
+  if (tokenAccount && subAccountId) {
+    op.subOperations = [
+      {
+        id: `${subAccountId}--OUT`,
+        hash: "",
+        type: "OUT",
+        value: transaction.useAllAmount
+          ? tokenAccount.balance
+          : transaction.amount,
+        fee: new BigNumber(0),
+        blockHash: null,
+        blockHeight: null,
+        senders,
+        recipients,
+        accountId: subAccountId,
+        date: new Date(),
+        extra: {},
+      },
+    ];
+  }
+
+  return op;
+};
+
+export default signOperation;