@ledgerhq/live-common 34.2.0 → 34.3.0-next.0

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

@@ -1,14 +1,15 @@
 import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
-import type { Transaction } from "../types";
-import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
 import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import type { ElrondAccount, Transaction, TransactionStatus } from "../types";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
 import { getPreloadStrategy, preload, hydrate } from "../preload";
-import { sync, scanAccounts } from "../js-synchronisation";
-import { createTransaction, prepareTransaction } from "../js-transaction";
-import getTransactionStatus from "../js-getTransactionStatus";
-import estimateMaxSpendable from "../js-estimateMaxSpendable";
-import signOperation from "../js-signOperation";
-import broadcast from "../js-broadcast";
+import { getTransactionStatus } from "../getTransactionStatus";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { prepareTransaction } from "../prepareTransaction";
+import { sync, scanAccounts } from "../synchronisation";
+import { createTransaction } from "../createTransaction";
+import { signOperation } from "../signOperation";
+import { broadcast } from "../broadcast";
 import {
   assignFromAccountRaw,
   assignToAccountRaw,
@@ -23,7 +24,7 @@ const currencyBridge: CurrencyBridge = {
   hydrate,
   scanAccounts,
 };
-const accountBridge: AccountBridge<Transaction> = {
+const accountBridge: AccountBridge<Transaction, ElrondAccount, TransactionStatus> = {
   estimateMaxSpendable,
   createTransaction,
   updateTransaction: defaultUpdateTransaction,

package/src/families/elrond/bridge.integration.test.ts

@@ -37,12 +37,10 @@ const elrond: CurrenciesData<Transaction> = {
         index: 0,
         freshAddress: `${TEST_ADDRESS}`,
         freshAddressPath: "44'/508'/0'/0'/0'",
-        freshAddresses: [],
         blockHeight: 0,
         operations: [],
         pendingOperations: [],
         currencyId: "elrond",
-        unitMagnitude: 18,
         lastSyncDate: "",
         balance: "299569965",
         subAccounts: [

package/src/families/elrond/broadcast.ts

@@ -0,0 +1,16 @@
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "../../operation";
+import { broadcastTransaction } from "./api";
+import { Transaction } from "./types";
+
+/**
+ * Broadcast the signed transaction
+ * @param {signature: string, operation: string} signedOperation
+ */
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({ signedOperation }) => {
+  const hash = await broadcastTransaction(signedOperation);
+
+  return patchOperationWithHash(signedOperation.operation, hash);
+};
+
+export default broadcast;

package/src/families/elrond/buildOptimisticOperation.ts

@@ -0,0 +1,115 @@
+import BigNumber from "bignumber.js";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { Address } from "@elrondnetwork/erdjs/out";
+import { Operation, OperationType } from "@ledgerhq/types-live";
+import { BinaryUtils } from "./utils/binary.utils";
+import { encodeOperationId } from "../../operation";
+import {
+  ElrondAccount,
+  ElrondProtocolTransaction,
+  ElrondTransactionMode,
+  Transaction,
+} from "./types";
+
+function getOptimisticOperationType(transactionMode: ElrondTransactionMode): OperationType {
+  switch (transactionMode) {
+    case "delegate":
+      return "DELEGATE";
+    case "unDelegate":
+      return "UNDELEGATE";
+    case "withdraw":
+      return "WITHDRAW_UNBONDED";
+    case "claimRewards":
+      return "REWARD";
+    case "reDelegateRewards":
+      return "DELEGATE";
+    default:
+      return "OUT";
+  }
+}
+
+function getOptimisticOperationDelegationAmount(transaction: Transaction): BigNumber | undefined {
+  let dataDecoded;
+  switch (transaction.mode) {
+    case "delegate":
+      return transaction.amount;
+
+    case "unDelegate":
+      dataDecoded = BinaryUtils.base64Decode(transaction.data ?? "");
+      return new BigNumber(`0x${dataDecoded.split("@")[1]}`);
+
+    default:
+      return new BigNumber(0);
+  }
+}
+
+export const buildOptimisticOperation = (
+  account: ElrondAccount,
+  transaction: Transaction,
+  unsignedTx: ElrondProtocolTransaction,
+): Operation => {
+  const senders = [account.freshAddress];
+  const recipients = [transaction.recipient];
+  const { subAccountId, fees } = transaction;
+
+  if (!fees) {
+    throw new FeeNotLoaded();
+  }
+
+  const type = getOptimisticOperationType(transaction.mode);
+
+  const tokenAccount =
+    (subAccountId &&
+      account.subAccounts &&
+      account.subAccounts.find(ta => ta.id === subAccountId)) ||
+    null;
+
+  const value =
+    tokenAccount || transaction.mode !== "send"
+      ? fees
+      : transaction.amount.plus(transaction.fees || new BigNumber(0));
+
+  const delegationAmount = getOptimisticOperationDelegationAmount(transaction);
+
+  const operation: Operation = {
+    id: encodeOperationId(account.id, "", type),
+    hash: "",
+    type,
+    value,
+    fee: fees,
+    blockHash: null,
+    blockHeight: null,
+    senders,
+    recipients,
+    accountId: account.id,
+    transactionSequenceNumber: unsignedTx.nonce,
+    date: new Date(),
+    contract: new Address(transaction.recipient).isContractAddress()
+      ? transaction.recipient
+      : undefined,
+    extra: {
+      amount: delegationAmount,
+    },
+  };
+
+  if (tokenAccount && subAccountId) {
+    operation.subOperations = [
+      {
+        id: encodeOperationId(subAccountId, "", "OUT"),
+        hash: "",
+        type: "OUT",
+        value: transaction.amount,
+        fee: new BigNumber(0),
+        blockHash: null,
+        blockHeight: null,
+        senders,
+        recipients,
+        accountId: subAccountId,
+        date: new Date(),
+        extra: {},
+      },
+    ];
+  }
+
+  return operation;
+};

package/src/families/elrond/buildSubAccounts.ts

@@ -0,0 +1,153 @@
+import { findTokenById, listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { Account, SyncConfig, TokenAccount } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { emptyHistoryCache, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
+import { mergeOps } from "../../bridge/jsHelpers";
+import { getESDTOperations, getAccountESDTTokens } from "./api";
+import { addPrefixToken, extractTokenId } from "./logic";
+
+async function buildElrondESDTTokenAccount({
+  parentAccountId,
+  accountAddress,
+  token,
+  balance,
+}: {
+  parentAccountId: string;
+  accountAddress: string;
+  token: TokenCurrency;
+  balance: BigNumber;
+}) {
+  const tokenAccountId = encodeTokenAccountId(parentAccountId, token);
+  const tokenIdentifierHex = extractTokenId(token.id);
+  const tokenIdentifier = Buffer.from(tokenIdentifierHex, "hex").toString();
+
+  const operations = await getESDTOperations(tokenAccountId, accountAddress, tokenIdentifier, 0);
+
+  const tokenAccount: TokenAccount = {
+    type: "TokenAccount",
+    id: tokenAccountId,
+    parentId: parentAccountId,
+    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 syncESDTTokenAccountOperations(
+  tokenAccount: TokenAccount,
+  address: string,
+): Promise<TokenAccount> {
+  const oldOperations = tokenAccount?.operations || [];
+  // Needed for incremental synchronisation
+  const startAt = oldOperations.length ? Math.floor(oldOperations[0].date.valueOf() / 1000) : 0;
+
+  const tokenIdentifierHex = extractTokenId(tokenAccount.token.id);
+  const tokenIdentifier = Buffer.from(tokenIdentifierHex, "hex").toString();
+
+  // Merge new operations with the previously synced ones
+  const newOperations = await getESDTOperations(tokenAccount.id, address, tokenIdentifier, startAt);
+  const operations = mergeOps(oldOperations, newOperations);
+
+  if (operations === oldOperations) return tokenAccount;
+
+  const copy = { ...tokenAccount };
+  copy.operations = operations;
+  copy.operationsCount = operations.length;
+  return copy;
+}
+
+async function elrondBuildESDTTokenAccounts({
+  currency,
+  accountId,
+  accountAddress,
+  existingAccount,
+  syncConfig,
+}: {
+  currency: CryptoCurrency;
+  accountId: string;
+  accountAddress: string;
+  existingAccount: Account | null | undefined;
+  syncConfig: SyncConfig;
+}): Promise<TokenAccount[] | undefined> {
+  const { blacklistedTokenIds = [] } = syncConfig;
+  if (listTokensForCryptoCurrency(currency).length === 0) {
+    return undefined;
+  }
+
+  const tokenAccounts: TokenAccount[] = [];
+
+  const existingAccountByTicker: { [key: string]: TokenAccount } = {}; // 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;
+        }
+      }
+    }
+  }
+
+  const accountESDTs = await getAccountESDTTokens(accountAddress);
+  for (const esdt of accountESDTs) {
+    const esdtIdentifierHex = Buffer.from(esdt.identifier).toString("hex");
+    const token = findTokenById(addPrefixToken(esdtIdentifierHex));
+
+    if (token && !blacklistedTokenIds.includes(token.id)) {
+      let tokenAccount = existingAccountByTicker[token.ticker];
+      if (!tokenAccount) {
+        tokenAccount = await buildElrondESDTTokenAccount({
+          parentAccountId: accountId,
+          accountAddress,
+          token,
+          balance: new BigNumber(esdt.balance),
+        });
+      } else {
+        const inputTokenAccount = tokenAccount;
+        tokenAccount = await syncESDTTokenAccountOperations(inputTokenAccount, accountAddress);
+        const balance = new BigNumber(esdt.balance);
+        if (!balance.eq(tokenAccount.balance)) {
+          // only recreate the object if balance changed
+          if (inputTokenAccount === tokenAccount) {
+            tokenAccount = { ...tokenAccount };
+          }
+          tokenAccount.balance = balance;
+          tokenAccount.spendableBalance = balance;
+        }
+      }
+
+      if (tokenAccount) {
+        tokenAccounts.push(tokenAccount);
+        existingAccountTickers.push(token.ticker);
+        existingAccountByTicker[token.ticker] = 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 elrondBuildESDTTokenAccounts;

package/src/families/elrond/config.ts

@@ -1,7 +1,7 @@
 import { ConfigInfo } from "@ledgerhq/live-config/LiveConfig";
 
 export const elrondConfig: Record<string, ConfigInfo> = {
-  config_currency_elrondConfig: {
+  config_currency_elrond: {
     type: "object",
     default: {
       status: {

package/src/families/elrond/createTransaction.ts

@@ -0,0 +1,21 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { MIN_GAS_LIMIT } from "./constants";
+import { Transaction } from "./types";
+
+/**
+ * Create an empty t
+ *
+ * @returns {Transaction}
+ */
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => {
+  return {
+    family: "elrond",
+    mode: "send",
+    amount: new BigNumber(0),
+    recipient: "",
+    useAllAmount: false,
+    fees: new BigNumber(50000),
+    gasLimit: MIN_GAS_LIMIT,
+  };
+};

package/src/families/elrond/datasets/elrond1.ts

@@ -8,11 +8,9 @@ export const elrond1: AccountRaw = {
   index: 0,
   freshAddress: "erd1rnq7m8kdrpyfany4fweqtydsk4pgx0l6dtl6tvcad5wesagruxts62e9rk",
   freshAddressPath: "44'/508'/0'/0'/0'",
-  freshAddresses: [],
   pendingOperations: [],
   operations: [],
   currencyId: "elrond",
-  unitMagnitude: 18,
   balance: "",
   blockHeight: 0,
   lastSyncDate: "",

package/src/families/elrond/deviceTransactionConfig.ts

@@ -2,7 +2,7 @@ import type { DeviceTransactionField } from "../../transaction";
 import type { TransactionStatus, Transaction } from "./types";
 import BigNumber from "bignumber.js";
 import { formatCurrencyUnit } from "../../currencies";
-import { decodeTokenAccountId, getAccountUnit } from "../../account";
+import { decodeTokenAccountId, getAccountCurrency } from "../../account";
 import { Account } from "@ledgerhq/types-live";
 import { isAmountSpentFromBalance } from "./logic";
 
@@ -48,7 +48,7 @@ function getDeviceTransactionConfig({
       fields.push({
         type: "text",
         label: "Amount",
-        value: formatCurrencyUnit(getAccountUnit(account), new BigNumber(0), {
+        value: formatCurrencyUnit(getAccountCurrency(account).units[0], new BigNumber(0), {
           showCode: true,
           disableRounding: true,
         }),

package/src/families/elrond/estimateMaxSpendable.ts

@@ -0,0 +1,43 @@
+import { BigNumber } from "bignumber.js";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { findSubAccountById, getMainAccount } from "../../account";
+import type { Transaction } from "./types";
+import { getFees } from "./api";
+import { createTransaction } from "./createTransaction";
+
+/**
+ * Returns the maximum possible amount for transaction
+ *
+ * @param {Object} param - the account, parentAccount and transaction
+ */
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const tx: Transaction = {
+    ...createTransaction(account),
+    subAccountId: account.type === "Account" ? null : account.id,
+    ...transaction,
+    useAllAmount: true,
+  };
+
+  const tokenAccount = tx.subAccountId
+    ? findSubAccountById(mainAccount, tx.subAccountId)
+    : undefined;
+
+  if (tokenAccount) {
+    return tokenAccount.balance;
+  }
+
+  const fees = await getFees(tx);
+
+  if (fees.gt(mainAccount.spendableBalance)) {
+    return new BigNumber(0);
+  }
+
+  return mainAccount.spendableBalance.minus(fees);
+};
+
+export default estimateMaxSpendable;

package/src/families/elrond/formatters.ts

@@ -1,6 +1,6 @@
 import invariant from "invariant";
 import type { Operation } from "@ledgerhq/types-live";
-import { getAccountUnit } from "../../account";
+import { getAccountCurrency } from "../../account";
 import { formatCurrencyUnit } from "../../currencies";
 import type { Unit } from "@ledgerhq/types-cryptoassets";
 import type { ElrondAccount, ElrondOperation } from "./types";
@@ -9,7 +9,7 @@ import BigNumber from "bignumber.js";
 function formatAccountSpecifics(account: ElrondAccount): string {
   const { elrondResources } = account;
   invariant(elrondResources, "elrond account expected");
-  const unit = getAccountUnit(account);
+  const unit = getAccountCurrency(account).units[0];
   const formatConfig = {
     disableRounding: true,
     alwaysShowSign: false,
@@ -44,12 +44,12 @@ function formatAccountSpecifics(account: ElrondAccount): string {
       delegated && delegated.gt(0)
         ? `\n  delegated: ${unit ? formatCurrencyUnit(unit, delegated, formatConfig) : delegated}`
         : undelegating && undelegating.gt(0)
-        ? `\n  undelegating: ${
-            unit ? formatCurrencyUnit(unit, undelegating, formatConfig) : undelegating
-          }`
-        : rewards && rewards.gt(0)
-        ? `\n  rewards: ${unit ? formatCurrencyUnit(unit, rewards, formatConfig) : rewards}`
-        : "";
+          ? `\n  undelegating: ${
+              unit ? formatCurrencyUnit(unit, undelegating, formatConfig) : undelegating
+            }`
+          : rewards && rewards.gt(0)
+            ? `\n  rewards: ${unit ? formatCurrencyUnit(unit, rewards, formatConfig) : rewards}`
+            : "";
   }
 
   return str;

package/src/families/elrond/getTransactionStatus.ts

@@ -0,0 +1,151 @@
+import BigNumber from "bignumber.js";
+import {
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  FeeNotLoaded,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  FeeTooHigh,
+  AmountRequired,
+} from "@ledgerhq/errors";
+import { formatCurrencyUnit } from "../../currencies";
+import { getAccountCurrency } from "../../account";
+import { DECIMALS_LIMIT, MIN_DELEGATION_AMOUNT } from "./constants";
+import type { ElrondAccount, Transaction, TransactionStatus } from "./types";
+import { isValidAddress, isSelfTransaction, isAmountSpentFromBalance } from "./logic";
+import {
+  ElrondDecimalsLimitReached,
+  ElrondMinDelegatedAmountError,
+  ElrondMinUndelegatedAmountError,
+  ElrondDelegationBelowMinimumError,
+  NotEnoughEGLDForFees,
+} from "./errors";
+import { AccountBridge } from "@ledgerhq/types-live";
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  ElrondAccount,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+
+  if (!transaction.recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (isSelfTransaction(account, transaction)) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  } else if (!isValidAddress(transaction.recipient)) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  if (!transaction.fees) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  if (
+    !errors.amount &&
+    transaction.amount.eq(0) &&
+    !transaction.useAllAmount &&
+    !["unDelegate", "withdraw", "reDelegateRewards", "claimRewards"].includes(transaction.mode)
+  ) {
+    errors.amount = new AmountRequired();
+  }
+
+  let totalSpent = new BigNumber(0); // Will be in token amount for token transacations
+  let totalSpentEgld = new BigNumber(0); // Amount spent in main currency (EGLD)
+
+  const tokenAccount =
+    (transaction.subAccountId &&
+      account.subAccounts &&
+      account.subAccounts.find(ta => ta.id === transaction.subAccountId)) ||
+    null;
+
+  if (tokenAccount) {
+    totalSpent = transaction.amount;
+    totalSpentEgld = transaction.fees || new BigNumber(0);
+
+    if (!errors.amount && transaction.amount.gt(tokenAccount.balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+
+    if (!errors.amount && !totalSpentEgld.decimalPlaces(DECIMALS_LIMIT).isEqualTo(totalSpentEgld)) {
+      errors.amount = new ElrondDecimalsLimitReached();
+    }
+  } else {
+    totalSpent = totalSpentEgld = isAmountSpentFromBalance(transaction.mode)
+      ? transaction.fees?.plus(transaction.amount) || transaction.amount
+      : transaction.fees || new BigNumber(0);
+
+    if (
+      transaction.mode === "send" &&
+      transaction.fees &&
+      transaction.amount.div(10).lt(transaction.fees)
+    ) {
+      warnings.feeTooHigh = new FeeTooHigh();
+    }
+
+    // All delegate and undelegate transactions must have an amount >= 1 EGLD
+    if (!errors.amount && transaction.amount.lt(MIN_DELEGATION_AMOUNT)) {
+      const formattedAmount = formatCurrencyUnit(
+        getAccountCurrency(account).units[0],
+        MIN_DELEGATION_AMOUNT,
+        {
+          showCode: true,
+        },
+      );
+      if (transaction.mode === "delegate") {
+        errors.amount = new ElrondMinDelegatedAmountError("", {
+          formattedAmount,
+        });
+      } else if (transaction.mode === "unDelegate") {
+        errors.amount = new ElrondMinUndelegatedAmountError("", {
+          formattedAmount,
+        });
+      }
+    }
+
+    // When undelegating, unless undelegating all, the delegation must remain >= 1 EGLD
+    const delegationBalance = account.elrondResources.delegations.find(
+      d => d.contract === transaction.recipient,
+    )?.userActiveStake;
+
+    const delegationRemainingBalance = new BigNumber(delegationBalance || 0).minus(
+      transaction.amount,
+    );
+
+    const delegationBalanceForbidden =
+      delegationRemainingBalance.gt(0) && delegationRemainingBalance.lt(MIN_DELEGATION_AMOUNT);
+
+    if (!errors.amount && transaction.mode === "unDelegate" && delegationBalanceForbidden) {
+      const formattedAmount = formatCurrencyUnit(
+        getAccountCurrency(account).units[0],
+        MIN_DELEGATION_AMOUNT,
+        {
+          showCode: true,
+        },
+      );
+      errors.amount = new ElrondDelegationBelowMinimumError("", {
+        formattedAmount,
+      });
+    }
+  }
+
+  if (!errors.amount && totalSpentEgld.gt(account.spendableBalance)) {
+    errors.amount =
+      tokenAccount || !["delegate", "send"].includes(transaction.mode)
+        ? new NotEnoughEGLDForFees()
+        : new NotEnoughBalance();
+  }
+
+  return {
+    errors,
+    warnings,
+    estimatedFees: transaction.fees || new BigNumber(0),
+    amount: transaction.amount,
+    totalSpent,
+  };
+};
+
+export default getTransactionStatus;