@ledgerhq/live-common 21.22.0 → 21.24.0

package/src/families/algorand/logic.ts

@@ -1 +1,48 @@
+import { BigNumber } from "bignumber.js";
+import type { AlgorandOperationMode } from "./types";
+import { getAccount } from "./api";
+
 export const ALGORAND_MAX_MEMO_SIZE = 32;
+export const ALGORAND_MIN_ACCOUNT_BALANCE = 100000;
+
+export const recipientHasAsset = async (
+  recipientAddress: string,
+  assetId: string
+): Promise<boolean> => {
+  const recipientAccount = await getAccount(recipientAddress);
+  return recipientAccount.assets.map((a) => a.assetId).includes(assetId);
+};
+
+export const isAmountValid = async (
+  recipientAddress: string,
+  amount: BigNumber
+): Promise<boolean> => {
+  const recipientAccount = await getAccount(recipientAddress);
+  return recipientAccount.balance.isZero()
+    ? amount.gte(ALGORAND_MIN_ACCOUNT_BALANCE)
+    : true;
+};
+
+export const computeAlgoMaxSpendable = ({
+  accountBalance,
+  nbAccountAssets,
+  mode,
+}: {
+  accountBalance: BigNumber;
+  nbAccountAssets: number;
+  mode: AlgorandOperationMode;
+}): BigNumber => {
+  const minBalance = computeMinimumAlgoBalance(mode, nbAccountAssets);
+  const maxSpendable = accountBalance.minus(minBalance);
+  return maxSpendable.gte(0) ? maxSpendable : new BigNumber(0);
+};
+
+const computeMinimumAlgoBalance = (
+  mode: AlgorandOperationMode,
+  nbAccountAssets: number
+): BigNumber => {
+  const base = 100000; // 0.1 algo = 100000 malgo
+  const currentAssets = nbAccountAssets;
+  const newAsset = mode === "optIn" ? 1 : 0;
+  return new BigNumber(base * (1 + currentAssets + newAsset));
+};

package/src/families/algorand/mock.ts

@@ -7,7 +7,7 @@ function setAlgorandResources(account: Account): Account {
   /** format algorandResources given the new delegations */
   account.algorandResources = {
     rewards: account.balance.multipliedBy(0.01),
-    rewardsAccumulated: account.balance.multipliedBy(0.1),
+    nbAssets: account.subAccounts?.length ?? 0,
   };
   return account;
 }
@@ -70,15 +70,6 @@ function addOptOut(account: Account, rng: Prando): Account {
   return account;
 }
 
-function addCloseAccount(account: Account, rng: Prando): Account {
-  /** select position on the operation stack where we will insert the new claim rewards */
-  const opIndex = rng.next(0, 10);
-  const opt = genBaseOperation(account, rng, "CLOSE_ACCOUNT", opIndex);
-  account.operations.splice(opIndex, 0, opt);
-  account.operationsCount++;
-  return account;
-}
-
 /**
  * add in specific algorand operations
  * @memberof algorand/mock
@@ -88,7 +79,6 @@ function addCloseAccount(account: Account, rng: Prando): Account {
 function genAccountEnhanceOperations(account: Account, rng: Prando): Account {
   addOptIn(account, rng);
   addOptOut(account, rng);
-  addCloseAccount(account, rng);
   setAlgorandResources(account);
   return account;
 }
@@ -122,7 +112,7 @@ function postScanAccount(
   if (isEmpty) {
     account.algorandResources = {
       rewards: new BigNumber(0),
-      rewardsAccumulated: new BigNumber(0),
+      nbAssets: account.subAccounts?.length ?? 0,
     };
     account.operations = [];
     account.subAccounts = [];

package/src/families/algorand/serialization.ts

@@ -3,18 +3,18 @@ import type { AlgorandResourcesRaw, AlgorandResources } from "./types";
 export function toAlgorandResourcesRaw(
   r: AlgorandResources
 ): AlgorandResourcesRaw {
-  const { rewards, rewardsAccumulated } = r;
+  const { rewards, nbAssets } = r;
   return {
     rewards: rewards.toString(),
-    rewardsAccumulated: rewardsAccumulated.toString(),
+    nbAssets,
   };
 }
 export function fromAlgorandResourcesRaw(
   r: AlgorandResourcesRaw
 ): AlgorandResources {
-  const { rewards, rewardsAccumulated } = r;
+  const { rewards, nbAssets } = r;
   return {
     rewards: new BigNumber(rewards),
-    rewardsAccumulated: new BigNumber(rewardsAccumulated),
+    nbAssets,
   };
 }

package/src/families/algorand/specs.ts

@@ -1,6 +1,6 @@
 import expect from "expect";
 import invariant from "invariant";
-import type { Transaction } from "./types";
+import type { AlgorandTransaction } from "./types";
 import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
 import { isAccountEmpty } from "../../account";
 import { pickSiblings } from "../../bot/specs";
@@ -12,18 +12,9 @@ import { listTokensForCryptoCurrency } from "../../currencies";
 import { extractTokenId } from "./tokens";
 import { DeviceModelId } from "@ledgerhq/devices";
 const currency = getCryptoCurrencyById("algorand");
-// Minimum fees
-const minFees = parseCurrencyUnit(currency.units[0], "0.001");
 // Minimum balance required for a new non-ASA account
 const minBalanceNewAccount = parseCurrencyUnit(currency.units[0], "0.1");
 
-// Spendable balance for a non-ASA account
-const getSpendableBalance = (maxSpendable) => {
-  maxSpendable = maxSpendable.minus(minFees);
-  invariant(maxSpendable.gt(0), "Spendable balance is too low");
-  return maxSpendable;
-};
-
 // Ensure that, when the recipient corresponds to an empty account,
 // the amount to send is greater or equal to the required minimum
 // balance for such a recipient
@@ -74,7 +65,7 @@ const getRandomAssetId = (account) => {
   return sample(diff);
 };
 
-const algorand: AppSpec<Transaction> = {
+const algorand: AppSpec<AlgorandTransaction> = {
   name: "Algorand",
   currency,
   appQuery: {
@@ -86,11 +77,11 @@ const algorand: AppSpec<Transaction> = {
       name: "move ~50%",
       maxRun: 2,
       transaction: ({ account, siblings, bridge, maxSpendable }) => {
-        const spendableBalance = getSpendableBalance(maxSpendable);
+        invariant(maxSpendable.gt(0), "Spendable balance is too low");
         const sibling = pickSiblings(siblings, 4);
         const recipient = sibling.freshAddress;
         const transaction = bridge.createTransaction(account);
-        const amount = spendableBalance
+        const amount = maxSpendable
           .div(1.9 + 0.2 * Math.random())
           .integerValue();
         checkSendableToEmptyAccount(amount, sibling);
@@ -119,10 +110,10 @@ const algorand: AppSpec<Transaction> = {
       name: "send max",
       maxRun: 1,
       transaction: ({ account, siblings, bridge, maxSpendable }) => {
-        const spendableBalance = getSpendableBalance(maxSpendable);
+        invariant(maxSpendable.gt(0), "Spendable balance is too low");
         const sibling = pickSiblings(siblings, 4);
         // Send the full spendable balance
-        const amount = spendableBalance;
+        const amount = maxSpendable;
         checkSendableToEmptyAccount(amount, sibling);
         return {
           transaction: bridge.createTransaction(account),
@@ -147,7 +138,7 @@ const algorand: AppSpec<Transaction> = {
       name: "send ASA ~50%",
       maxRun: 2,
       transaction: ({ account, siblings, bridge, maxSpendable }) => {
-        invariant(maxSpendable.gt(minFees), "Spendable balance is too low");
+        invariant(maxSpendable.gt(0), "Spendable balance is too low");
         const subAccount = sample(getAssetsWithBalance(account));
         invariant(
           subAccount && subAccount.type === "TokenAccount",
@@ -161,7 +152,7 @@ const algorand: AppSpec<Transaction> = {
         const amount = subAccount.balance
           .div(1.9 + 0.2 * Math.random())
           .integerValue();
-        const updates: Array<Partial<Transaction>> = [
+        const updates: Array<Partial<AlgorandTransaction>> = [
           {
             mode,
             subAccountId: subAccount.id,
@@ -196,10 +187,13 @@ const algorand: AppSpec<Transaction> = {
       name: "opt-In ASA available",
       maxRun: 1,
       transaction: ({ account, bridge, maxSpendable }) => {
-        // maxSpendable is expected to be greater than 100,000 micro-Algos (+ 1,000 for fees)
+        // maxSpendable is expected to be greater than 100,000 micro-Algos
         // corresponding to the requirement that the main account will have
         // one more ASA after the opt-in; its minimum balance is updated accordingly
-        invariant(maxSpendable.gt(new BigNumber(101000)), "balance is too low");
+        invariant(
+          maxSpendable.gt(new BigNumber(100000)),
+          "Spendable balance is too low"
+        );
         const transaction = bridge.createTransaction(account);
         const mode = "optIn";
         const assetId = getRandomAssetId(account);
@@ -207,7 +201,7 @@ const algorand: AppSpec<Transaction> = {
           ? account.subAccounts.find((a) => a.id.includes(assetId as string))
           : null;
         invariant(!subAccount, "already opt-in");
-        const updates: Array<Partial<Transaction>> = [
+        const updates: Array<Partial<AlgorandTransaction>> = [
           {
             mode,
           },
@@ -241,10 +235,10 @@ const algorand: AppSpec<Transaction> = {
         invariant(rewards && rewards.gt(0), "No pending rewards");
         // Ensure that the rewards can effectively be claimed
         // (fees have to be paid in order to claim the rewards)
-        invariant(maxSpendable.gt(minFees), "Spendable balance is too low");
+        invariant(maxSpendable.gt(0), "Spendable balance is too low");
         const transaction = bridge.createTransaction(account);
         const mode = "claimReward";
-        const updates: Array<Partial<Transaction>> = [
+        const updates: Array<Partial<AlgorandTransaction>> = [
           {
             mode,
           },

package/src/families/algorand/speculos-deviceActions.ts

@@ -1,5 +1,5 @@
 import type { DeviceAction } from "../../bot/types";
-import type { Transaction } from "./types";
+import type { AlgorandTransaction } from "./types";
 import { formatCurrencyUnit, findTokenById } from "../../currencies";
 import { deviceActionFlow } from "../../bot/specs";
 import { extractTokenId, addPrefixToken } from "./tokens";
@@ -11,88 +11,93 @@ const expectedAmount = ({ account, status }) =>
     disableRounding: true,
   });
 
-const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
-  steps: [
-    {
-      title: "Txn Type",
-      button: "Rr",
-      expectedValue: ({ transaction }) =>
-        transaction.subAccountId ? "Asset xfer" : "Payment",
-    },
-    {
-      title: "Asset xfer",
-      button: "Rr",
-    },
-    {
-      title: "Payment",
-      button: "Rr",
-    },
-    {
-      title: "Fee",
-      button: "Rr",
-      expectedValue: ({ account, status }) =>
-        formatCurrencyUnit(account.unit, status.estimatedFees, {
-          disableRounding: true,
-        }),
-    },
-    {
-      title: "Asset ID",
-      button: "Rr",
-      expectedValue: ({ transaction }) => {
-        const id = transaction.assetId
-          ? extractTokenId(transaction.assetId)
-          : transaction.subAccountId
-          ? extractTokenId(transaction.subAccountId)
-          : "";
-        const token = findTokenById(addPrefixToken(id));
-        return token ? displayTokenValue(token) : `#${id}`;
+const acceptTransaction: DeviceAction<AlgorandTransaction, any> =
+  deviceActionFlow({
+    steps: [
+      {
+        title: "Txn Type",
+        button: "Rr",
+        expectedValue: ({ transaction }) =>
+          transaction.subAccountId ? "Asset xfer" : "Payment",
       },
-    },
-    {
-      title: "Asset amt",
-      button: "Rr",
-      expectedValue: ({ transaction, status }) =>
-        transaction.mode === "optIn" ? "0" : status.amount.toString(),
-    },
-    {
-      title: "Receiver",
-      button: "Rr",
-      expectedValue: ({ transaction }) => transaction.recipient,
-    },
-    {
-      title: "Asset dst",
-      button: "Rr",
-      expectedValue: ({ transaction }) => transaction.recipient,
-    },
-    {
-      title: "Amount",
-      button: "Rr",
-      expectedValue: ({ account, status, transaction }) =>
-        transaction.mode === "claimReward"
-          ? "0"
-          : expectedAmount({
-              account,
-              status,
-            }),
-    },
-    {
-      title: "Sign",
-      button: "LRlr",
-    },
-    {
-      title: "Review",
-      button: "Rr",
-    },
-    {
-      title: "Genesis ID",
-      button: "Rr",
-    }, // Only on testnet
-    {
-      title: "Genesis hash",
-      button: "Rr",
-    }, // Only on testnet
-  ],
-});
+      {
+        title: "Asset xfer",
+        button: "Rr",
+      },
+      {
+        title: "Payment",
+        button: "Rr",
+      },
+      {
+        title: "Fee",
+        button: "Rr",
+        expectedValue: ({ account, status }) =>
+          formatCurrencyUnit(account.unit, status.estimatedFees, {
+            disableRounding: true,
+          }),
+      },
+      {
+        title: "Asset ID",
+        button: "Rr",
+        expectedValue: ({ transaction }) => {
+          const id = transaction.assetId
+            ? extractTokenId(transaction.assetId)
+            : transaction.subAccountId
+            ? extractTokenId(transaction.subAccountId)
+            : "";
+          const token = findTokenById(addPrefixToken(id));
+          return token ? displayTokenValue(token) : `#${id}`;
+        },
+      },
+      {
+        title: "Asset amt",
+        button: "Rr",
+        expectedValue: ({ transaction, status }) =>
+          transaction.mode === "optIn" ? "0" : status.amount.toString(),
+      },
+      {
+        title: "Sender",
+        button: "Rr",
+      },
+      {
+        title: "Receiver",
+        button: "Rr",
+        expectedValue: ({ transaction }) => transaction.recipient,
+      },
+      {
+        title: "Asset dst",
+        button: "Rr",
+        expectedValue: ({ transaction }) => transaction.recipient,
+      },
+      {
+        title: "Amount",
+        button: "Rr",
+        expectedValue: ({ account, status, transaction }) =>
+          transaction.mode === "claimReward"
+            ? "0"
+            : expectedAmount({
+                account,
+                status,
+              }),
+      },
+      {
+        title: "Sign",
+        button: "LRlr",
+      },
+      {
+        title: "Review",
+        button: "Rr",
+      },
+      {
+        title: "Genesis ID",
+        button: "Rr",
+      }, // Only on testnet
+      {
+        title: "Genesis hash",
+        button: "Rr",
+      }, // Only on testnet
+    ],
+  });
 export default {
   acceptTransaction,
 };

package/src/families/algorand/test-dataset.ts

@@ -6,19 +6,18 @@ import {
   NotEnoughBalanceBecauseDestinationNotCreated,
 } from "@ledgerhq/errors";
 import { AlgorandASANotOptInInRecipient } from "../../errors";
-import type { Transaction } from "./types";
+import type { AlgorandTransaction } from "./types";
 // const notCreatedAlgorandAddress =
 //   "ZBILW5BPM7AQU54YQZICSGS4J7KJ2XV6OC3DFUQ7BB4DVLYKKUEVWDDBGM";
-const dataset: DatasetTest<Transaction> = {
+const dataset: DatasetTest<AlgorandTransaction> = {
   implementations: ["libcore"],
   // test disabled. FIXME ctx LL-5485
   currencies: {} || {
     algorand: {
       FIXME_ignoreAccountFields: [
-        "algorandResources.rewards", // We cant keep track of this since it's always move
-        "algorandResources.rewardsAccumulated", // same
-        "balance", // I think rewards are included
-        "spendableBalance", // same since the rewards are included here
+        "algorandResources.rewards", // We cant keep track of this since it's always moving
+        "balance", // Rewards are included, same as above
+        "spendableBalance", // Same since the rewards are included here too
       ],
       scanAccounts: [
         {

package/src/families/algorand/tokens.ts

@@ -1,4 +1,5 @@
 export const addPrefixToken = (tokenId: string) => `algorand/asa/${tokenId}`;
+
 export const extractTokenId = (tokenId: string) => {
   return tokenId.split("/")[2];
 };

package/src/families/algorand/transaction.ts

@@ -1,5 +1,5 @@
 import { BigNumber } from "bignumber.js";
-import type { Transaction, TransactionRaw } from "./types";
+import type { AlgorandTransaction, AlgorandTransactionRaw } from "./types";
 import {
   fromTransactionCommonRaw,
   toTransactionCommonRaw,
@@ -8,7 +8,14 @@ import type { Account } from "../../types";
 import { getAccountUnit } from "../../account";
 import { formatCurrencyUnit } from "../../currencies";
 export const formatTransaction = (
-  { mode, subAccountId, amount, recipient, fees, useAllAmount }: Transaction,
+  {
+    mode,
+    subAccountId,
+    amount,
+    recipient,
+    fees,
+    useAllAmount,
+  }: AlgorandTransaction,
   mainAccount: Account
 ): string => {
   const account =
@@ -41,7 +48,9 @@ export const formatTransaction = (
     }`;
 };
 
-const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+const fromTransactionRaw = (
+  tr: AlgorandTransactionRaw
+): AlgorandTransaction => {
   const common = fromTransactionCommonRaw(tr);
   return {
     ...common,
@@ -53,7 +62,7 @@ const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
   };
 };
 
-const toTransactionRaw = (t: Transaction): TransactionRaw => {
+const toTransactionRaw = (t: AlgorandTransaction): AlgorandTransactionRaw => {
   const common = toTransactionCommonRaw(t);
   return {
     ...common,

package/src/families/algorand/types.ts

@@ -95,34 +95,39 @@ declare class CoreAlgorandOperation {
 }
 
 export type CoreCurrencySpecifics = Record<string, never>;
+
 export type AlgorandResources = {
   rewards: BigNumber;
-  rewardsAccumulated: BigNumber;
+  // Ledger Live only supports a limited list of ASA (defined here https://github.com/LedgerHQ/ledgerjs/blob/master/packages/cryptoassets/data/asa.js)
+  // This is the actual number of ASA opted-in for the Algo account
+  nbAssets: number;
 };
 export type AlgorandResourcesRaw = {
   rewards: string;
-  rewardsAccumulated: string;
+  nbAssets: number;
 };
-export type AlgorandOperationMode = "send" | "optIn" | "claimReward" | "optOut";
+export type AlgorandOperationMode = "send" | "optIn" | "claimReward";
 export type {
   CoreAlgorandOperation,
   CoreAlgorandAccount,
   CoreAlgorandTransaction,
 };
-export type Transaction = TransactionCommon & {
+export type AlgorandTransaction = TransactionCommon & {
   family: "algorand";
   mode: AlgorandOperationMode;
   fees: BigNumber | null | undefined;
   assetId: string | null | undefined;
   memo: string | null | undefined;
 };
-export type TransactionRaw = TransactionCommonRaw & {
+export type AlgorandTransactionRaw = TransactionCommonRaw & {
   family: "algorand";
   mode: AlgorandOperationMode;
   fees: string | null | undefined;
   assetId: string | null | undefined;
   memo: string | null | undefined;
 };
+export type Transaction = AlgorandTransaction;
+export type TransactionRaw = AlgorandTransactionRaw;
 export type AlgorandOperation = Operation & {
   extra: AlgorandExtraTxInfo;
 };

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

@@ -18,8 +18,9 @@ const prepareTransaction = async (
   const feePerByte = inferFeePerByte(t, networkInfo);
 
   if (
-    t.networkInfo === networkInfo &&
-    (feePerByte === t.feePerByte || feePerByte.eq(t.feePerByte || 0))
+    (t.networkInfo === networkInfo &&
+      (feePerByte === t.feePerByte || feePerByte.eq(t.feePerByte || 0))) ||
+    t.feesStrategy === "custom"
   ) {
     // nothing changed
     return t;

package/src/families/bitcoin/js-synchronisation.ts

@@ -91,8 +91,8 @@ const mapTxToOperations = (
   tx: TX,
   currencyId: string,
   accountId: string,
-  accountAddresses: string[],
-  changeAddresses: string[]
+  accountAddresses: Set<string>,
+  changeAddresses: Set<string>
 ): $Shape<Operation[]> => {
   const operations: Operation[] = [];
   const hash = tx.hash;
@@ -116,7 +116,7 @@ const mapTxToOperations = (
       );
 
       if (input.value) {
-        if (accountAddresses.includes(input.address)) {
+        if (accountAddresses.has(input.address)) {
           // This address is part of the account
           value = value.plus(input.value);
           accountInputs.push(input);
@@ -137,11 +137,12 @@ const mapTxToOperations = (
 
   for (const output of tx.outputs) {
     if (output.address) {
-      if (!accountAddresses.includes(output.address)) {
+      if (!accountAddresses.has(output.address)) {
         // The output doesn't belong to this account
         if (
-          tx.outputs.length === 1 || // The transaction has only 1 output
-          output.output_index < changeOutputIndex // The output isn't the change output
+          accountInputs.length > 0 && // It's a SEND operation
+          (tx.outputs.length === 1 || // The transaction has only 1 output
+            output.output_index < changeOutputIndex) // The output isn't the change output
         ) {
           recipients.push(
             syncReplaceAddress
@@ -153,7 +154,7 @@ const mapTxToOperations = (
         // The output belongs to this account
         accountOutputs.push(output);
 
-        if (!changeAddresses.includes(output.address)) {
+        if (!changeAddresses.has(output.address)) {
           // The output isn't a change output of this account
           recipients.push(
             syncReplaceAddress
@@ -182,7 +183,7 @@ const mapTxToOperations = (
   if (accountInputs.length > 0) {
     // It's a SEND operation
     for (const output of accountOutputs) {
-      if (changeAddresses.includes(output.address)) {
+      if (changeAddresses.has(output.address)) {
         value = value.minus(output.value);
       }
     }
@@ -213,7 +214,7 @@ const mapTxToOperations = (
     let finalAmount = new BigNumber(0);
 
     for (const output of accountOutputs) {
-      if (!filterChangeAddresses || !changeAddresses.includes(output.address)) {
+      if (!filterChangeAddresses || !changeAddresses.has(output.address)) {
         finalAmount = finalAmount.plus(output.value);
         accountOutputCount += 1;
       }
@@ -323,17 +324,18 @@ const getAccountShape: GetAccountShape = async (info) => {
   const { txs: transactions } = await wallet.getAccountTransactions(
     walletAccount
   );
+
+  const accountAddresses: Set<string> = new Set<string>();
   const accountAddressesWithInfo = await walletAccount.xpub.getXpubAddresses();
-  const accountAddresses = accountAddressesWithInfo
-    ? accountAddressesWithInfo.map((a) => a.address)
-    : [];
+  accountAddressesWithInfo.forEach((a) => accountAddresses.add(a.address));
+
+  const changeAddresses: Set<string> = new Set<string>();
   const changeAddressesWithInfo =
     await walletAccount.xpub.storage.getUniquesAddresses({
       account: 1,
     });
-  const changeAddresses = changeAddressesWithInfo
-    ? changeAddressesWithInfo.map((a) => a.address)
-    : [];
+  changeAddressesWithInfo.forEach((a) => changeAddresses.add(a.address));
+
   const newOperations = transactions
     ?.map((tx) =>
       mapTxToOperations(