@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

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/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/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/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;

package/src/families/elrond/prepareTransaction.ts

@@ -0,0 +1,78 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "./types";
+import { getFees } from "./api";
+import { GAS } from "./constants";
+import { ElrondEncodeTransaction } from "./encode";
+import { isAmountSpentFromBalance } from "./logic";
+import { AccountBridge } from "@ledgerhq/types-live";
+
+/**
+ * Prepare t before checking status
+ *
+ * @param {ElrondAccount} account
+ * @param {Transaction} transactoin
+ */
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  // What's the point of this extra variable ?
+  const preparedTx = transaction;
+
+  const tokenAccount =
+    (transaction.subAccountId &&
+      account.subAccounts &&
+      account.subAccounts.find(ta => ta.id === transaction.subAccountId)) ||
+    null;
+
+  if (tokenAccount) {
+    preparedTx.data = ElrondEncodeTransaction.ESDTTransfer(transaction, tokenAccount);
+    preparedTx.gasLimit = GAS.ESDT_TRANSFER;
+  } else {
+    switch (transaction.mode) {
+      case "delegate":
+        preparedTx.gasLimit = GAS.DELEGATE;
+        preparedTx.data = ElrondEncodeTransaction.delegate();
+        break;
+      case "claimRewards":
+        preparedTx.gasLimit = GAS.CLAIM;
+        preparedTx.data = ElrondEncodeTransaction.claimRewards();
+        break;
+      case "withdraw":
+        preparedTx.gasLimit = GAS.DELEGATE;
+        preparedTx.data = ElrondEncodeTransaction.withdraw();
+        break;
+      case "reDelegateRewards":
+        preparedTx.gasLimit = GAS.DELEGATE;
+        preparedTx.data = ElrondEncodeTransaction.reDelegateRewards();
+        break;
+      case "unDelegate":
+        preparedTx.gasLimit = GAS.DELEGATE;
+        preparedTx.data = ElrondEncodeTransaction.unDelegate(transaction);
+        break;
+      case "send":
+        break;
+      default:
+        throw new Error("Unsupported transaction mode: " + transaction.mode);
+    }
+  }
+
+  if (transaction.useAllAmount) {
+    // Set the max amount
+    preparedTx.amount = tokenAccount ? tokenAccount.balance : account.spendableBalance;
+
+    // Compute estimated fees for that amount
+    preparedTx.fees = await getFees(preparedTx);
+
+    // Adjust max amount according to computed fees
+    if (!tokenAccount && isAmountSpentFromBalance(transaction.mode)) {
+      preparedTx.amount = preparedTx.amount.gt(preparedTx.fees)
+        ? preparedTx.amount.minus(preparedTx.fees)
+        : new BigNumber(0);
+    }
+  } else {
+    preparedTx.fees = await getFees(preparedTx);
+  }
+
+  return preparedTx;
+};

package/src/families/elrond/signOperation.ts

@@ -0,0 +1,86 @@
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { buildTransactionToSign } from "./buildTransaction";
+import type { ElrondAccount, Transaction } from "./types";
+import { decodeTokenAccountId } from "../../account";
+import { withDevice } from "../../hw/deviceAccess";
+import { extractTokenId } from "./logic";
+import { CHAIN_ID } from "./constants";
+import Elrond from "./hw-app-elrond";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const signOperation: AccountBridge<Transaction, ElrondAccount>["signOperation"] = ({
+  account,
+  deviceId,
+  transaction,
+}) =>
+  withDevice(deviceId)(
+    transport =>
+      new Observable(o => {
+        async function main() {
+          if (!transaction.fees) {
+            throw new FeeNotLoaded();
+          }
+          // Collect data for an ESDT transfer
+          const { subAccounts } = account;
+          const { subAccountId } = transaction;
+          const tokenAccount = !subAccountId
+            ? null
+            : subAccounts && subAccounts.find(ta => ta.id === subAccountId);
+
+          const elrond = new Elrond(transport);
+          await elrond.setAddress(account.freshAddressPath);
+
+          if (tokenAccount) {
+            const { token } = decodeTokenAccountId(tokenAccount.id);
+            if (token == null) {
+              throw new Error("Invalid token");
+            }
+
+            await elrond.provideESDTInfo(
+              token.ticker,
+              extractTokenId(token.id),
+              token.units[0].magnitude,
+              CHAIN_ID,
+              token.ledgerSignature,
+            );
+          }
+
+          const unsignedTx: string = await buildTransactionToSign(account, transaction);
+
+          o.next({
+            type: "device-signature-requested",
+          });
+
+          const r = await elrond.signTransaction(account.freshAddressPath, unsignedTx, true);
+
+          o.next({
+            type: "device-signature-granted",
+          });
+
+          const parsedUnsignedTx = JSON.parse(unsignedTx);
+
+          const operation = buildOptimisticOperation(account, transaction, parsedUnsignedTx);
+
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature: r,
+              rawData: parsedUnsignedTx,
+            },
+          });
+        }
+
+        main().then(
+          () => o.complete(),
+          e => o.error(e),
+        );
+      }),
+  );
+
+export default signOperation;

package/src/families/elrond/synchronisation.ts

@@ -0,0 +1,75 @@
+import { TokenAccount } from "@ledgerhq/types-live";
+import type { GetAccountShape } from "../../bridge/jsHelpers";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { makeScanAccounts, makeSync, mergeOps } from "../../bridge/jsHelpers";
+import { inferSubOperations } from "@ledgerhq/coin-framework/serialization/index";
+import { getAccount, getAccountDelegations, getEGLDOperations, hasESDTTokens } from "./api";
+import elrondBuildESDTTokenAccounts from "./buildSubAccounts";
+import { reconciliateSubAccounts } from "./reconciliation";
+import { computeDelegationBalance } from "./logic";
+import { ElrondAccount } from "./types";
+
+const getAccountShape: GetAccountShape<ElrondAccount> = async (info, syncConfig) => {
+  const { address, initialAccount, currency, derivationMode } = info;
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+  const oldOperations = initialAccount?.operations || [];
+  // Needed for incremental synchronisation
+  const startAt = oldOperations.length ? Math.floor(oldOperations[0].date.valueOf() / 1000) : 0;
+
+  const account = await getAccount(address);
+
+  const delegations = await getAccountDelegations(address);
+
+  let subAccounts: TokenAccount[] = [];
+  const hasTokens = await hasESDTTokens(address);
+  if (hasTokens) {
+    const tokenAccounts = await elrondBuildESDTTokenAccounts({
+      currency,
+      accountId: accountId,
+      accountAddress: address,
+      existingAccount: initialAccount,
+      syncConfig,
+    });
+
+    if (tokenAccounts) {
+      subAccounts = reconciliateSubAccounts(tokenAccounts, initialAccount);
+    }
+  }
+
+  const delegationBalance = computeDelegationBalance(delegations);
+
+  // Merge new operations with the previously synced ones
+  const newOperations = await getEGLDOperations(accountId, address, startAt, subAccounts);
+  const operations = mergeOps(oldOperations, newOperations);
+
+  return {
+    id: accountId,
+    balance: account.balance.plus(delegationBalance),
+    spendableBalance: account.balance,
+    operationsCount: operations.length,
+    blockHeight: account.blockHeight,
+    elrondResources: {
+      nonce: account.nonce,
+      delegations,
+      isGuarded: account.isGuarded,
+    },
+    subAccounts,
+    operations: operations.map(op => {
+      const subOperations = inferSubOperations(op.hash, subAccounts);
+
+      return {
+        ...op,
+        subOperations,
+      };
+    }),
+  };
+};
+
+export const scanAccounts = makeScanAccounts({ getAccountShape });
+export const sync = makeSync({ getAccountShape });

package/src/families/evm/config.ts

@@ -685,6 +685,38 @@ const evmConfig: CurrencyLiveConfigDefinition = {
       explorer: { type: "etherscan", uri: "https://api-sepolia.lineascan.build/api" },
     },
   },
+  config_currency_blast: {
+    type: "object",
+    default: {
+      status: { type: "active" },
+      node: { type: "external", uri: "https://rpc.blast.io" },
+      explorer: { type: "etherscan", uri: "https://api.blastscan.io/api" },
+    },
+  },
+  config_currency_blast_sepolia: {
+    type: "object",
+    default: {
+      status: { type: "active" },
+      node: { type: "external", uri: "https://sepolia.blast.io" },
+      explorer: { type: "etherscan", uri: "https://api-sepolia.blastscan.io/api" },
+    },
+  },
+  config_currency_scroll: {
+    type: "object",
+    default: {
+      status: { type: "active" },
+      node: { type: "external", uri: "https://rpc.scroll.io" },
+      explorer: { type: "etherscan", uri: "https://api.scrollscan.com/api" },
+    },
+  },
+  config_currency_scroll_sepolia: {
+    type: "object",
+    default: {
+      status: { type: "active" },
+      node: { type: "external", uri: "https://sepolia-rpc.scroll.io" },
+      explorer: { type: "etherscan", uri: "https://api-sepolia.scrollscan.com/api" },
+    },
+  },
 };
 
 export { evmConfig };