@ledgerhq/live-common 21.36.2 → 22.0.0

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

@@ -1,345 +0,0 @@
-import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
-import { BigNumber } from "bignumber.js";
-import invariant from "invariant";
-import {
-  AmountRequired,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  NotEnoughBalance,
-  FeeNotLoaded,
-  FeeTooHigh,
-  NotEnoughBalanceBecauseDestinationNotCreated,
-  NotEnoughBalanceInParentAccount,
-} from "@ledgerhq/errors";
-import { AlgorandASANotOptInInRecipient } from "../../../errors";
-import { validateRecipient } from "../../../bridge/shared";
-import type { AccountBridge, CurrencyBridge, Account } from "../../../types";
-import type { AlgorandResources, AlgorandTransaction } from "../types";
-import { AlgorandOperationTypeEnum } from "../types";
-import { scanAccounts } from "../../../libcore/scanAccounts";
-import { sync } from "../../../libcore/syncAccount";
-import type { CacheRes } from "../../../cache";
-import { makeLRUCache } from "../../../cache";
-import { getMainAccount } from "../../../account";
-import broadcast from "../libcore-broadcast";
-import signOperation from "../libcore-signOperation";
-import { getFeesForTransaction } from "../../../libcore/getFeesForTransaction";
-import { withLibcore } from "../../../libcore/access";
-import { getCoreAccount } from "../../../libcore/getCoreAccount";
-import { libcoreAmountToBigNumber } from "../../../libcore/buildBigNumber";
-import { extractTokenId } from "../tokens";
-import { ALGORAND_MAX_MEMO_SIZE } from "../logic";
-import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
-import { ClaimRewardsFeesWarning } from "../../../errors";
-const receive = makeAccountBridgeReceive();
-export const calculateFees: CacheRes<
-  Array<{
-    a: Account;
-    t: AlgorandTransaction;
-  }>,
-  {
-    estimatedFees: BigNumber;
-    estimatedGas: BigNumber | null | undefined;
-  }
-> = makeLRUCache(
-  async ({
-    a,
-    t,
-  }): Promise<{
-    estimatedFees: BigNumber;
-    estimatedGas: BigNumber | null | undefined;
-  }> => {
-    return await getFeesForTransaction({
-      account: a,
-      transaction: t,
-    });
-  },
-  ({ a, t }) =>
-    `${a.id}_${t.amount.toString()}_${t.recipient}_${String(t.useAllAmount)}_${
-      t.memo ? t.memo.toString() : ""
-    }_${t.mode}_${t.assetId || ""}`
-);
-
-const getSpendableMaxForOptIn = async (account) =>
-  await withLibcore(async (core) => {
-    const { coreAccount } = await getCoreAccount(core, account);
-    const algorandAccount = await coreAccount.asAlgorandAccount();
-    const spendableBalanceBigInt = await algorandAccount.getSpendableBalance(
-      AlgorandOperationTypeEnum.ASSET_OPT_IN
-    );
-    const spendableBalance = await libcoreAmountToBigNumber(
-      spendableBalanceBigInt
-    );
-    return spendableBalance;
-  });
-
-const createTransaction = (): AlgorandTransaction => ({
-  family: "algorand",
-  amount: new BigNumber(0),
-  fees: null,
-  recipient: "",
-  useAllAmount: false,
-  memo: null,
-  mode: "send",
-  assetId: null,
-});
-
-const updateTransaction = (t, patch) => {
-  return { ...t, ...patch };
-};
-
-const recipientHasAsset = async (assetId, recipient, account) =>
-  await withLibcore(async (core) => {
-    const { coreAccount } = await getCoreAccount(core, account);
-    const algorandAccount = await coreAccount.asAlgorandAccount();
-    const hasAsset = await algorandAccount.hasAsset(recipient, assetId);
-    return hasAsset;
-  });
-
-const getAmountValid = async (recipient, amount, account) =>
-  await withLibcore(async (core) => {
-    const { coreAccount } = await getCoreAccount(core, account);
-    const algorandAccount = await coreAccount.asAlgorandAccount();
-    const isValid = await algorandAccount.isAmountValid(
-      recipient,
-      amount.toString()
-    );
-    return isValid;
-  });
-
-/*
- * 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
- */
-const getTransactionStatus = async (a: Account, t) => {
-  const errors: any = {};
-  const warnings: any = {};
-  const tokenAccount = !t.subAccountId
-    ? null
-    : a.subAccounts && a.subAccounts.find((ta) => ta.id === t.subAccountId);
-
-  if (t.mode === "send" && a.freshAddress === t.recipient) {
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-  } else {
-    const { recipientError, recipientWarning } = await validateRecipient(
-      a.currency,
-      t.recipient
-    );
-
-    if (recipientError) {
-      errors.recipient = recipientError;
-    }
-
-    if (recipientWarning) {
-      warnings.recipient = recipientWarning;
-    }
-  }
-
-  const estimatedFees = t.fees || new BigNumber(0);
-  let amount = t.amount;
-  let totalSpent = estimatedFees;
-
-  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(
-          extractTokenId(tokenAccount.token.id),
-          t.recipient,
-          a
-        ))
-      ) {
-        errors.recipient = new AlgorandASANotOptInInRecipient();
-      }
-
-      amount = t.useAllAmount
-        ? tokenAccount
-          ? tokenAccount.balance
-          : a.spendableBalance.minus(estimatedFees)
-        : amount;
-
-      if (amount.lt(0)) {
-        amount = new BigNumber(0);
-      }
-
-      totalSpent = tokenAccount ? amount : amount.plus(estimatedFees);
-
-      if (
-        !errors.recipient &&
-        !(await getAmountValid(t.recipient, amount, a))
-      ) {
-        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(a.spendableBalance)) // if spendable balance lower than total
-      ) {
-        errors.amount = new NotEnoughBalance();
-      }
-
-      // if spendable balance lower than fees for token
-      if (
-        !errors.amount &&
-        tokenAccount &&
-        a.spendableBalance.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");
-      }
-
-      const spendableBalance = await getSpendableMaxForOptIn(a);
-
-      if (spendableBalance.lt(estimatedFees)) {
-        errors.amount = new NotEnoughBalance();
-      }
-
-      break;
-    }
-
-    case "claimReward": {
-      if (a.spendableBalance.lt(totalSpent)) {
-        errors.amount = new NotEnoughBalance();
-      }
-
-      invariant(a.algorandResources, "Algorand family");
-
-      if (
-        estimatedFees.gt((a.algorandResources as 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,
-  });
-};
-
-const sameFees = (a, b) => (!a || !b ? a === b : a.eq(b));
-
-const prepareTransaction = async (a, t) => {
-  let fees = t.fees;
-  let amount = t.amount;
-  let recipient = t.recipient;
-
-  if (t.mode === "optIn" || t.mode === "claimReward") {
-    recipient = a.freshAddress;
-    amount = new BigNumber(0);
-  }
-
-  if (recipient || t.mode !== "send") {
-    let errors: Error | undefined | null | boolean = (
-      await validateRecipient(a.currency, recipient)
-    ).recipientError;
-    errors = errors || (t.mode === "optIn" && !t.assetId);
-
-    if (!errors) {
-      const res = await calculateFees({
-        a,
-        t,
-      });
-      fees = res.estimatedFees;
-    }
-  }
-
-  if (
-    !sameFees(t.fees, fees) ||
-    !sameFees(t.amount, amount) ||
-    t.recipient !== recipient
-  ) {
-    return { ...t, fees, amount, recipient };
-  }
-
-  return t;
-};
-
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-  transaction,
-}) => {
-  const mainAccount = getMainAccount(account, parentAccount);
-  const t = await prepareTransaction(mainAccount, {
-    ...createTransaction(),
-    subAccountId: account.type === "Account" ? null : account.id,
-    ...transaction,
-    recipient:
-      transaction?.recipient || getAbandonSeedAddress(mainAccount.currency.id),
-    useAllAmount: true,
-  });
-  const s = await getTransactionStatus(mainAccount, t);
-  return s.amount;
-};
-
-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/buildASAOperation.ts

@@ -1,66 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { AlgorandOperationTypeEnum } from "./types";
-import type { Operation, OperationType } from "../../types";
-import type { CoreOperation } from "../../libcore/types";
-import { encodeOperationId } from "../../operation";
-const OperationTypeMap = {
-  "0": "OUT",
-  "1": "IN",
-};
-export async function buildASAOperation(arg: {
-  coreOperation: CoreOperation;
-  accountId: string;
-  tokenId: string;
-}) {
-  const { coreOperation, accountId, tokenId } = arg;
-  const algorandOperation = await coreOperation.asAlgorandOperation();
-  const transaction = await algorandOperation.getTransaction();
-  const hash = await transaction.getId();
-  const algoOpeType = await algorandOperation.getAlgorandOperationType();
-
-  if (
-    ![
-      AlgorandOperationTypeEnum.ASSET_OPT_OUT,
-      AlgorandOperationTypeEnum.ASSET_TRANSFER,
-    ].includes(algoOpeType)
-  ) {
-    return null;
-  }
-
-  const transferInfo = await transaction.getAssetTransferInfo();
-
-  if ((await transferInfo.getAssetId()) !== tokenId) {
-    return null;
-  }
-
-  const operationType = await coreOperation.getOperationType();
-  const type = OperationTypeMap[operationType];
-  const id = encodeOperationId(accountId, hash, type);
-  const blockHeight = parseInt(await transaction.getRound());
-  const value = await algorandOperation.getAssetAmount();
-  const receiver =
-    algoOpeType === 8
-      ? [
-          await transferInfo.getRecipientAddress(),
-          await transferInfo.getCloseAddress(),
-        ]
-      : [await transferInfo.getRecipientAddress()];
-  const fee = await transaction.getFee();
-  const sender = await transaction.getSender();
-  const date = new Date(await coreOperation.getDate());
-  const op: Operation = {
-    id,
-    type: type as OperationType,
-    value: new BigNumber(value),
-    hash,
-    fee: new BigNumber(fee),
-    senders: [sender],
-    recipients: receiver,
-    blockHeight,
-    blockHash: null,
-    accountId,
-    date,
-    extra: {},
-  };
-  return op;
-}

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

@@ -1,18 +0,0 @@
-import type { Operation } from "../../types";
-import { makeBroadcast } from "../../libcore/broadcast";
-import { patchOperationWithHash } from "../../operation";
-
-async function broadcast({
-  coreAccount,
-  signedOperation: { operation, signature },
-}): Promise<Operation> {
-  const algorandAccount = await coreAccount.asAlgorandAccount();
-  let hash = "";
-  hash = await algorandAccount.broadcastRawTransaction(signature);
-  const op = patchOperationWithHash(operation, hash);
-  return op;
-}
-
-export default makeBroadcast({
-  broadcast,
-});

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

@@ -1,69 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { CoreOperation } from "../../libcore/types";
-import type { Operation } from "../../types";
-import { AlgorandOperationTypeEnum } from "./types";
-
-const getAssetId = async (transaction) => {
-  if ((await transaction.getType()) === "axfer") {
-    const assetInfo = await transaction.getAssetTransferInfo();
-    return assetInfo.getAssetId();
-  }
-
-  return null;
-};
-
-const getOperationType = async (algorandOperation, transaction) => {
-  const operationType = await algorandOperation.getAlgorandOperationType();
-  let type;
-
-  if ((await transaction.getType()) === "axfer") {
-    type = "FEES";
-  }
-
-  if (operationType === AlgorandOperationTypeEnum.ASSET_OPT_IN) {
-    type = "OPT_IN";
-  }
-
-  if (operationType === AlgorandOperationTypeEnum.ASSET_OPT_OUT) {
-    type = "OPT_OUT";
-  }
-
-  return type;
-};
-
-async function algorandBuildOperation({
-  coreOperation,
-}: {
-  coreOperation: CoreOperation;
-}) {
-  const algorandLikeOperation = await coreOperation.asAlgorandOperation();
-  const algorandLikeTransaction = await algorandLikeOperation.getTransaction();
-  const hash = await algorandLikeTransaction.getId();
-  const out: Partial<Operation> = {
-    hash,
-  };
-  const type = await getOperationType(
-    algorandLikeOperation,
-    algorandLikeTransaction
-  );
-
-  if (type) {
-    out.type = type;
-  }
-
-  const assetId = await getAssetId(algorandLikeTransaction);
-
-  if (assetId) {
-    out.extra = { ...out.extra, assetId: assetId };
-  }
-
-  const rewards = await algorandLikeOperation.getRewards();
-
-  if (rewards) {
-    out.extra = { ...out.extra, rewards: new BigNumber(rewards) };
-  }
-
-  return out;
-}
-
-export default algorandBuildOperation;

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

@@ -1,132 +0,0 @@
-import type {
-  CryptoCurrency,
-  TokenAccount,
-  Account,
-  SyncConfig,
-} from "../../types";
-import type { CoreAccount, CoreOperation } from "../../libcore/types";
-import { minimalOperationsBuilder } from "../../reconciliation";
-import { buildASAOperation } from "./buildASAOperation";
-import { BigNumber } from "bignumber.js";
-import { findTokenById, listTokensForCryptoCurrency } from "../../currencies";
-import { emptyHistoryCache } from "../../account";
-import { promiseAllBatched } from "../../promise";
-import { extractTokenId, addPrefixToken } from "./tokens";
-const OperationOrderKey = {
-  date: 0,
-};
-
-async function buildAlgorandTokenAccount({
-  parentAccountId,
-  token,
-  coreAccount,
-  existingTokenAccount,
-  balance,
-}) {
-  const extractedId = extractTokenId(token.id);
-  const id = parentAccountId + "+" + extractedId;
-
-  const getAllOperations = async () => {
-    const query = await coreAccount.queryOperations();
-    await query.complete();
-    await query.addOrder(OperationOrderKey.date, false);
-    const coreOperations = await query.execute();
-    const operations = await minimalOperationsBuilder(
-      (existingTokenAccount && existingTokenAccount.operations) || [],
-      coreOperations,
-      (coreOperation: CoreOperation) =>
-        buildASAOperation({
-          coreOperation,
-          accountId: id,
-          tokenId: extractedId,
-        })
-    );
-    return operations;
-  };
-
-  const operations = await getAllOperations();
-  const tokenAccount: TokenAccount = {
-    type: "TokenAccount",
-    id,
-    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, // calculated in the jsHelpers
-  };
-  return tokenAccount;
-}
-
-async function algorandBuildTokenAccounts({
-  currency,
-  coreAccount,
-  accountId,
-  existingAccount,
-  syncConfig,
-}: {
-  currency: CryptoCurrency;
-  coreAccount: CoreAccount;
-  accountId: string;
-  existingAccount: Account | null | undefined;
-  syncConfig: SyncConfig;
-}): Promise<TokenAccount[] | null | undefined> {
-  const { blacklistedTokenIds = [] } = syncConfig;
-  if (listTokensForCryptoCurrency(currency).length === 0) return undefined;
-  const tokenAccounts: TokenAccount[] = [];
-  const algorandAccount = await coreAccount.asAlgorandAccount();
-  const accountASA = await algorandAccount.getAssetsBalances();
-  const existingAccountByTicker = {}; // used for fast lookup
-
-  const existingAccountTickers: string[] = []; // used to keep track of ordering
-
-  if (existingAccount && existingAccount.subAccounts) {
-    for (const existingSubAccount of existingAccount.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, accountASA, async (asa) => {
-    const token = findTokenById(addPrefixToken(await asa.getAssetId()));
-
-    if (token && !blacklistedTokenIds.includes(token.id)) {
-      const existingTokenAccount = existingAccountByTicker[token.ticker];
-      const tokenAccount = await buildAlgorandTokenAccount({
-        parentAccountId: accountId,
-        existingTokenAccount,
-        token,
-        coreAccount,
-        balance: new BigNumber(await asa.getAmount()),
-      });
-      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;
-}
-
-export default algorandBuildTokenAccounts;