@ledgerhq/live-common 21.22.0 → 21.24.0

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;

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

@@ -0,0 +1,433 @@
+import { BigNumber } from "bignumber.js";
+import type {
+  CryptoCurrency,
+  TokenCurrency,
+  Account,
+  TokenAccount,
+  Operation,
+  OperationType,
+  SyncConfig,
+} from "../../types";
+import { findTokenById, listTokensForCryptoCurrency } from "../../currencies";
+import {
+  encodeAccountId,
+  emptyHistoryCache,
+  inferSubOperations,
+} from "../../account";
+import { encodeOperationId } from "../../operation";
+import { promiseAllBatched } from "../../promise";
+import type { GetAccountShape } from "../../bridge/jsHelpers";
+import { makeSync, makeScanAccounts, mergeOps } from "../../bridge/jsHelpers";
+
+import {
+  AlgoTransaction,
+  AlgoPaymentInfo,
+  AlgoAssetTransferInfo,
+  AlgoAsset,
+} from "./api";
+import { AlgoTransactionType, getAccount, getAccountTransactions } from "./api";
+import { addPrefixToken, extractTokenId } from "./tokens";
+import { computeAlgoMaxSpendable } from "./logic";
+
+const getASAOperationAmount = (
+  transaction: AlgoTransaction,
+  accountAddress: string
+): BigNumber => {
+  let assetAmount = new BigNumber(0);
+  if (transaction.type === AlgoTransactionType.ASSET_TRANSFER) {
+    const details = transaction.details as AlgoAssetTransferInfo;
+    const assetSender = details.assetSenderAddress
+      ? details.assetSenderAddress
+      : transaction.senderAddress;
+
+    // Account is either sender or recipient (if both the balance is unchanged)
+    if (
+      (assetSender === accountAddress) !==
+      (details.assetRecipientAddress == accountAddress)
+    ) {
+      assetAmount = assetAmount.plus(details.assetAmount);
+    }
+    // Account is either sender or close-to, but not both
+    if (
+      (assetSender === accountAddress) !==
+      (details.assetCloseToAddress &&
+        details.assetCloseToAddress === accountAddress)
+    ) {
+      if (details.assetCloseAmount) {
+        assetAmount = assetAmount.plus(details.assetCloseAmount);
+      }
+    }
+  }
+  return assetAmount;
+};
+
+const getOperationAmounts = (
+  transaction: AlgoTransaction,
+  accountAddress: string
+): { amount: BigNumber; rewards: BigNumber } => {
+  let amount = new BigNumber(0);
+  let rewards = new BigNumber(0);
+
+  if (transaction.senderAddress === accountAddress) {
+    const senderRewards = transaction.senderRewards;
+    amount = amount.minus(senderRewards).plus(transaction.fee);
+    rewards = rewards.plus(senderRewards);
+  }
+
+  if (transaction.type === AlgoTransactionType.PAYMENT) {
+    const details = transaction.details as AlgoPaymentInfo;
+    if (transaction.senderAddress == details.recipientAddress) {
+      return {
+        amount,
+        rewards,
+      };
+    }
+    if (transaction.senderAddress === accountAddress) {
+      amount = amount.plus(details.amount);
+    }
+    if (details.recipientAddress == accountAddress) {
+      const recipientRewards = transaction.recipientRewards;
+      amount = amount.plus(details.amount).plus(recipientRewards);
+      rewards = rewards.plus(recipientRewards);
+    }
+    if (
+      transaction.closeRewards &&
+      details.closeAmount &&
+      details.closeToAddress === accountAddress
+    ) {
+      const closeRewards = transaction.closeRewards;
+      amount = amount.plus(details.closeAmount).plus(closeRewards);
+      rewards = rewards.plus(closeRewards);
+    }
+  }
+
+  return {
+    amount,
+    rewards,
+  };
+};
+
+const getASAOperationType = (
+  transaction: AlgoTransaction,
+  accountAddress: string
+): OperationType => {
+  return transaction.senderAddress === accountAddress ? "OUT" : "IN";
+};
+
+const getOperationType = (
+  transaction: AlgoTransaction,
+  accountAddress: string
+): OperationType => {
+  if (transaction.type === AlgoTransactionType.ASSET_TRANSFER) {
+    const details = transaction.details as AlgoAssetTransferInfo;
+    if (
+      details.assetAmount.isZero() &&
+      transaction.senderAddress == details.assetRecipientAddress
+    ) {
+      return "OPT_IN";
+    } else if (
+      details.assetCloseToAddress &&
+      transaction.senderAddress == accountAddress
+    ) {
+      return "OPT_OUT";
+    } else {
+      return "FEES";
+    }
+  }
+
+  return transaction.senderAddress === accountAddress ? "OUT" : "IN";
+};
+
+const getOperationSenders = (transaction: AlgoTransaction): string[] => {
+  return [transaction.senderAddress];
+};
+
+const getOperationRecipients = (transaction: AlgoTransaction): string[] => {
+  const recipients: string[] = [];
+  if (transaction.type === AlgoTransactionType.PAYMENT) {
+    const details = transaction.details as AlgoPaymentInfo;
+    recipients.push(details.recipientAddress);
+    if (details.closeToAddress) {
+      recipients.push(details.closeToAddress);
+    }
+  } else if (transaction.type === AlgoTransactionType.ASSET_TRANSFER) {
+    const details = transaction.details as AlgoAssetTransferInfo;
+
+    recipients.push(details.assetRecipientAddress);
+    if (details.assetCloseToAddress) {
+      recipients.push(details.assetCloseToAddress);
+    }
+  }
+  return recipients;
+};
+
+const getOperationAssetId = (
+  transaction: AlgoTransaction
+): string | undefined => {
+  if (transaction.type === AlgoTransactionType.ASSET_TRANSFER) {
+    const details = transaction.details as AlgoAssetTransferInfo;
+    return details.assetId;
+  }
+};
+
+const mapTransactionToOperation = (
+  tx: AlgoTransaction,
+  accountId: string,
+  accountAddress: string,
+  subAccounts?: TokenAccount[]
+): Partial<Operation> => {
+  const hash = tx.id;
+  const blockHeight = tx.round;
+  const date = new Date(parseInt(tx.timestamp) * 1000);
+  const fee = tx.fee;
+  const memo = tx.note;
+  const senders: string[] = getOperationSenders(tx);
+  const recipients: string[] = getOperationRecipients(tx);
+  const { amount, rewards } = getOperationAmounts(tx, accountAddress);
+  const type = getOperationType(tx, accountAddress);
+  const assetId = getOperationAssetId(tx);
+
+  const subOperations = subAccounts
+    ? inferSubOperations(tx.id, subAccounts)
+    : undefined;
+
+  return {
+    id: encodeOperationId(accountId, hash, type),
+    hash,
+    date,
+    type,
+    value: amount,
+    fee,
+    senders,
+    recipients,
+    blockHeight,
+    accountId,
+    subOperations,
+    extra: {
+      rewards,
+      memo,
+      assetId,
+    },
+  };
+};
+
+const mapTransactionToASAOperation = (
+  tx: AlgoTransaction,
+  accountId: string,
+  accountAddress: string
+): Partial<Operation> => {
+  const hash = tx.id;
+  const blockHeight = tx.round;
+  const date = new Date(parseInt(tx.timestamp) * 1000);
+  const fee = tx.fee;
+  const senders: string[] = getOperationSenders(tx);
+  const recipients: string[] = getOperationRecipients(tx);
+  const type = getASAOperationType(tx, accountAddress);
+  const amount = getASAOperationAmount(tx, accountAddress);
+
+  return {
+    id: encodeOperationId(accountId, hash, type),
+    hash,
+    date,
+    type,
+    value: amount,
+    fee,
+    senders,
+    recipients,
+    blockHeight,
+    accountId,
+    extra: {},
+  };
+};
+
+const getAccountShape: GetAccountShape = async (
+  info,
+  syncConfig
+): Promise<Partial<Account>> => {
+  const { address, initialAccount, currency, derivationMode } = info;
+  const oldOperations = initialAccount?.operations || [];
+  const startAt = oldOperations.length
+    ? (oldOperations[0].blockHeight || 0) + 1
+    : 0;
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+
+  const { round, balance, pendingRewards, assets } = await getAccount(address);
+
+  const nbAssets = assets.length;
+
+  // NOTE Actual spendable amount depends on the transaction
+  const spendableBalance = computeAlgoMaxSpendable({
+    accountBalance: balance,
+    nbAccountAssets: nbAssets,
+    mode: "send",
+  });
+
+  const newTransactions: AlgoTransaction[] = await getAccountTransactions(
+    address,
+    startAt
+  );
+
+  const subAccounts = await buildSubAccounts({
+    currency,
+    accountId,
+    initialAccount,
+    initialAccountAddress: address,
+    assets,
+    newTransactions,
+    syncConfig,
+  });
+
+  const newOperations = newTransactions.map((tx) =>
+    mapTransactionToOperation(tx, accountId, address, subAccounts)
+  );
+
+  const operations = mergeOps(oldOperations, newOperations as Operation[]);
+
+  const shape = {
+    id: accountId,
+    blockHeight: round,
+    balance,
+    spendableBalance,
+    operations,
+    operationsCount: operations.length,
+    subAccounts,
+    algorandResources: {
+      rewards: pendingRewards,
+      nbAssets,
+    },
+  };
+
+  return shape;
+};
+
+async function buildSubAccount({
+  parentAccountId,
+  parentAccountAddress,
+  token,
+  initialTokenAccount,
+  newTransactions,
+  balance,
+}: {
+  parentAccountId: string;
+  parentAccountAddress: string;
+  token: TokenCurrency;
+  initialTokenAccount: TokenAccount;
+  newTransactions: AlgoTransaction[];
+  balance: BigNumber;
+}) {
+  const extractedId = extractTokenId(token.id);
+  const tokenAccountId = parentAccountId + "+" + extractedId;
+
+  const oldOperations = initialTokenAccount?.operations || [];
+
+  const newOperations = newTransactions
+    .filter((tx) => tx.type === AlgoTransactionType.ASSET_TRANSFER)
+    .filter((tx) => {
+      const details = tx.details as AlgoAssetTransferInfo;
+      return Number(details.assetId) === Number(extractedId);
+    })
+    .filter((tx) => getOperationType(tx, parentAccountAddress) != "OPT_IN")
+    .map((tx) =>
+      mapTransactionToASAOperation(tx, tokenAccountId, parentAccountAddress)
+    );
+
+  const operations = mergeOps(oldOperations, newOperations as Operation[]);
+
+  const tokenAccount: TokenAccount = {
+    type: "TokenAccount",
+    id: tokenAccountId,
+    parentId: parentAccountId,
+    starred: false,
+    token,
+    operationsCount: operations.length,
+    operations,
+    pendingOperations: [],
+    balance,
+    spendableBalance: balance,
+    swapHistory: [],
+    creationDate:
+      operations.length > 0
+        ? operations[operations.length - 1].date
+        : new Date(),
+    balanceHistoryCache: emptyHistoryCache,
+  };
+  return tokenAccount;
+}
+
+async function buildSubAccounts({
+  currency,
+  accountId,
+  initialAccount,
+  initialAccountAddress,
+  assets,
+  newTransactions,
+  syncConfig,
+}: {
+  currency: CryptoCurrency;
+  accountId: string;
+  initialAccount: Account | null | undefined;
+  initialAccountAddress: string;
+  assets: AlgoAsset[];
+  newTransactions: AlgoTransaction[];
+  syncConfig: SyncConfig;
+}): Promise<TokenAccount[] | undefined> {
+  const { blacklistedTokenIds = [] } = syncConfig;
+  if (listTokensForCryptoCurrency(currency).length === 0) return undefined;
+  const tokenAccounts: TokenAccount[] = [];
+  const existingAccountByTicker = {}; // used for fast lookup
+  const existingAccountTickers: string[] = []; // used to keep track of ordering
+
+  if (initialAccount && initialAccount.subAccounts) {
+    for (const existingSubAccount of initialAccount.subAccounts) {
+      if (existingSubAccount.type === "TokenAccount") {
+        const { ticker, id } = existingSubAccount.token;
+
+        if (!blacklistedTokenIds.includes(id)) {
+          existingAccountTickers.push(ticker);
+          existingAccountByTicker[ticker] = existingSubAccount;
+        }
+      }
+    }
+  }
+
+  // filter by token existence
+  await promiseAllBatched(3, assets, async (asset) => {
+    const token = findTokenById(addPrefixToken(asset.assetId));
+
+    if (token && !blacklistedTokenIds.includes(token.id)) {
+      const initialTokenAccount = existingAccountByTicker[token.ticker];
+      const tokenAccount = await buildSubAccount({
+        parentAccountId: accountId,
+        parentAccountAddress: initialAccountAddress,
+        initialTokenAccount,
+        token,
+        newTransactions,
+        balance: asset.balance,
+      });
+      if (tokenAccount) tokenAccounts.push(tokenAccount);
+    }
+  });
+  // Preserve order of tokenAccounts from the existing token accounts
+  tokenAccounts.sort((a, b) => {
+    const i = existingAccountTickers.indexOf(a.token.ticker);
+    const j = existingAccountTickers.indexOf(b.token.ticker);
+    if (i === j) return 0;
+    if (i < 0) return 1;
+    if (j < 0) return -1;
+    return i - j;
+  });
+  return tokenAccounts;
+}
+
+const postSync = (_initial: Account, parent: Account) => {
+  return parent;
+};
+
+export const scanAccounts = makeScanAccounts(getAccountShape);
+export const sync = makeSync(getAccountShape, postSync);

package/src/families/algorand/libcore-buildTransaction.ts

@@ -2,7 +2,7 @@ import { FeeNotLoaded } from "@ledgerhq/errors";
 import type { Account } from "../../types";
 import { libcoreAmountToBigNumber } from "../../libcore/buildBigNumber";
 import type { Core, CoreAccount } from "../../libcore/types";
-import type { CoreAlgorandTransaction, Transaction } from "./types";
+import type { CoreAlgorandTransaction, AlgorandTransaction } from "./types";
 import { extractTokenId } from "./tokens";
 
 const setInfo = async (
@@ -64,7 +64,7 @@ export async function algorandBuildTransaction({
   account: Account;
   core: Core;
   coreAccount: CoreAccount;
-  transaction: Transaction;
+  transaction: AlgorandTransaction;
   isPartial: boolean;
   isCancelled: () => boolean;
 }): Promise<CoreAlgorandTransaction | null | undefined> {

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

@@ -1,15 +1,15 @@
 import type { Account } from "../../types";
 import type { Core, CoreCurrency, CoreAccount } from "../../libcore/types";
-import type { Transaction } from "./types";
+import type { AlgorandTransaction } from "./types";
 import buildTransaction from "./libcore-buildTransaction";
 import { BigNumber } from "bignumber.js";
 
-async function cosmos(args: {
+async function algorand(args: {
   account: Account;
   core: Core;
   coreAccount: CoreAccount;
   coreCurrency: CoreCurrency;
-  transaction: Transaction;
+  transaction: AlgorandTransaction;
   isPartial: boolean;
   isCancelled: () => boolean;
 }) {
@@ -22,4 +22,4 @@ async function cosmos(args: {
   };
 }
 
-export default cosmos;
+export default algorand;

package/src/families/algorand/libcore-postBuildAccount.ts

@@ -5,19 +5,14 @@ import type { AlgorandResources } from "./types";
 import { AlgorandOperationTypeEnum } from "./types";
 
 const getAlgorandResources = async (
-  account: Account,
   coreAccount
 ): Promise<AlgorandResources> => {
   const algorandAccount = await coreAccount.asAlgorandAccount();
   const rewardsBigInt = await algorandAccount.getPendingRewards();
-  const rewardsAccumulatedBigInt = await algorandAccount.getTotalRewards();
   const rewards = await libcoreAmountToBigNumber(rewardsBigInt);
-  const rewardsAccumulated = await libcoreAmountToBigNumber(
-    rewardsAccumulatedBigInt
-  );
   return {
     rewards,
-    rewardsAccumulated,
+    nbAssets: 0, // unused in libcore implem
   };
 };
 
@@ -39,7 +34,7 @@ const postBuildAccount = async ({
   account: Account;
   coreAccount: CoreAccount;
 }): Promise<Account> => {
-  account.algorandResources = await getAlgorandResources(account, coreAccount);
+  account.algorandResources = await getAlgorandResources(coreAccount);
   account.spendableBalance = await getAlgorandSpendableBalance(coreAccount);
   return account;
 };

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

@@ -1,7 +1,7 @@
 import Algorand from "@ledgerhq/hw-app-algorand";
 import { makeSignOperation } from "../../libcore/signOperation";
 import buildTransaction from "./libcore-buildTransaction";
-import type { Transaction, CoreAlgorandTransaction } from "./types";
+import type { AlgorandTransaction, CoreAlgorandTransaction } from "./types";
 import type { Operation } from "../../types";
 import { BigNumber } from "bignumber.js";
 
@@ -98,7 +98,7 @@ async function signTransaction({
   };
 }
 
-export default makeSignOperation<Transaction, CoreAlgorandTransaction>({
+export default makeSignOperation<AlgorandTransaction, CoreAlgorandTransaction>({
   buildTransaction,
   signTransaction,
 });