@ledgerhq/live-common 21.22.0 → 21.24.0

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

@@ -0,0 +1,46 @@
+import type { AccountBridge, CurrencyBridge } from "../../../types";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+
+import type { AlgorandTransaction } from "../types";
+import { sync, scanAccounts } from "../js-synchronization";
+import {
+  createTransaction,
+  prepareTransaction,
+} from "../js-prepareTransaction";
+import { estimateMaxSpendable } from "../js-estimateMaxSpendable";
+import { getTransactionStatus } from "../js-getTransactionStatus";
+import { signOperation } from "../js-signOperation";
+import { broadcast } from "../js-broadcast";
+
+const receive = makeAccountBridgeReceive();
+
+const updateTransaction = (t, patch) => {
+  return { ...t, ...patch };
+};
+
+const preload = async () => Promise.resolve({});
+
+const hydrate = () => {};
+
+const currencyBridge: CurrencyBridge = {
+  preload,
+  hydrate,
+  scanAccounts,
+};
+
+const accountBridge: AccountBridge<AlgorandTransaction> = {
+  createTransaction,
+  updateTransaction,
+  prepareTransaction,
+  getTransactionStatus,
+  sync,
+  receive,
+  signOperation,
+  broadcast,
+  estimateMaxSpendable,
+};
+
+export default {
+  currencyBridge,
+  accountBridge,
+};

package/src/families/algorand/bridge/libcore.ts

@@ -13,7 +13,7 @@ import {
 import { AlgorandASANotOptInInRecipient } from "../../../errors";
 import { validateRecipient } from "../../../bridge/shared";
 import type { AccountBridge, CurrencyBridge, Account } from "../../../types";
-import type { AlgorandResources, Transaction } from "../types";
+import type { AlgorandResources, AlgorandTransaction } from "../types";
 import { AlgorandOperationTypeEnum } from "../types";
 import { scanAccounts } from "../../../libcore/scanAccounts";
 import { sync } from "../../../libcore/syncAccount";
@@ -34,7 +34,7 @@ const receive = makeAccountBridgeReceive();
 export const calculateFees: CacheRes<
   Array<{
     a: Account;
-    t: Transaction;
+    t: AlgorandTransaction;
   }>,
   {
     estimatedFees: BigNumber;
@@ -72,7 +72,7 @@ const getSpendableMaxForOptIn = async (account) =>
     return spendableBalance;
   });
 
-const createTransaction = (): Transaction => ({
+const createTransaction = (): AlgorandTransaction => ({
   family: "algorand",
   amount: new BigNumber(0),
   fees: null,
@@ -328,7 +328,7 @@ const currencyBridge: CurrencyBridge = {
   hydrate,
   scanAccounts,
 };
-const accountBridge: AccountBridge<Transaction> = {
+const accountBridge: AccountBridge<AlgorandTransaction> = {
   createTransaction,
   updateTransaction,
   prepareTransaction,

package/src/families/algorand/bridge/mock.ts

@@ -5,7 +5,7 @@ import {
   InvalidAddress,
   FeeTooHigh,
 } from "@ledgerhq/errors";
-import type { Transaction } from "../types";
+import type { AlgorandTransaction } from "../types";
 import type { AccountBridge, CurrencyBridge } from "../../../types";
 import {
   scanAccounts,
@@ -20,7 +20,7 @@ const receive = makeAccountBridgeReceive();
 
 const defaultGetFees = (a, t) => t.fees || new BigNumber(0);
 
-const createTransaction = (): Transaction => ({
+const createTransaction = (): AlgorandTransaction => ({
   family: "algorand",
   mode: "send",
   amount: new BigNumber(0),
@@ -88,7 +88,7 @@ const prepareTransaction = async (a, t) => {
   return t;
 };
 
-const accountBridge: AccountBridge<Transaction> = {
+const accountBridge: AccountBridge<AlgorandTransaction> = {
   estimateMaxSpendable,
   createTransaction,
   updateTransaction,

package/src/families/algorand/buildTransaction.ts

@@ -0,0 +1,100 @@
+import { encode as msgpackEncode } from "algo-msgpack-with-bigint";
+import type {
+  SuggestedParams as AlgoSuggestedParams,
+  Transaction as AlgoTransaction,
+  EncodedTransaction as AlgoTransactionPayload,
+  EncodedSignedTransaction as AlgoSignedTransactionPayload,
+} from "algosdk";
+import {
+  makePaymentTxnWithSuggestedParams,
+  makeAssetTransferTxnWithSuggestedParams,
+} from "algosdk";
+
+import type { Account } from "../../types";
+import type { Transaction } from "./types";
+
+import { extractTokenId } from "./tokens";
+import { getTransactionParams } from "./api";
+
+export const buildTransactionPayload = async (
+  account: Account,
+  transaction: Transaction
+): Promise<AlgoTransactionPayload> => {
+  const { amount, recipient, mode, memo, assetId, subAccountId } = transaction;
+  const subAccount = subAccountId
+    ? account.subAccounts &&
+      account.subAccounts.find((t) => t.id === subAccountId)
+    : null;
+
+  const note = memo ? new TextEncoder().encode(memo) : undefined;
+
+  // Minor hack: cast the result as a algosdk.SuggestedParams, while it's actually a TransactionParametersResponse
+  const params = (await getTransactionParams()) as AlgoSuggestedParams;
+
+  let algoTxn: AlgoTransaction;
+  if (subAccount || (assetId && mode === "optIn")) {
+    const targetAssetId =
+      subAccount && subAccount.type === "TokenAccount"
+        ? extractTokenId(subAccount.token.id)
+        : assetId
+        ? extractTokenId(assetId)
+        : "";
+
+    if (!targetAssetId) {
+      throw new Error("Token Asset Id not found");
+    }
+
+    algoTxn = makeAssetTransferTxnWithSuggestedParams(
+      account.freshAddress,
+      recipient,
+      undefined,
+      undefined,
+      amount.toNumber(),
+      note,
+      Number(targetAssetId),
+      params,
+      undefined
+    );
+  } else {
+    algoTxn = makePaymentTxnWithSuggestedParams(
+      account.freshAddress,
+      recipient,
+      amount.toNumber(),
+      undefined,
+      note,
+      params
+    );
+  }
+
+  // Bit of safety: set tx validity to the next 1000 blocks
+  algoTxn.firstRound = params.lastRound;
+  algoTxn.lastRound = params.lastRound + 1000;
+
+  // Flaw in the SDK: payload isn't sorted, but it needs to be for msgPack encoding
+  const sorted = Object.fromEntries(
+    Object.entries(algoTxn.get_obj_for_encoding()).sort()
+  ) as AlgoTransactionPayload;
+
+  return sorted;
+};
+
+export const encodeToSign = async (
+  payload: AlgoTransactionPayload
+): Promise<string> => {
+  const msgPackEncoded = msgpackEncode(payload);
+
+  return Buffer.from(msgPackEncoded).toString("hex");
+};
+
+export const encodeToBroadcast = async (
+  payload: AlgoTransactionPayload,
+  signature: Buffer
+): Promise<Buffer> => {
+  const signedPayload: AlgoSignedTransactionPayload = {
+    sig: signature,
+    txn: payload,
+  };
+  const msgPackEncoded = msgpackEncode(signedPayload);
+
+  return Buffer.from(msgPackEncoded);
+};

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 };
+};