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

package/src/families/elrond/js-signOperation.ts

@@ -1,188 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { Observable } from "rxjs";
-import { FeeNotLoaded } from "@ledgerhq/errors";
-import { Address } from "@elrondnetwork/erdjs/out";
-import type { ElrondProtocolTransaction, ElrondTransactionMode, Transaction } from "./types";
-import { withDevice } from "../../hw/deviceAccess";
-import { encodeOperationId } from "../../operation";
-import Elrond from "./hw-app-elrond";
-import { buildTransactionToSign } from "./js-buildTransaction";
-import { CHAIN_ID } from "./constants";
-import { Account, Operation, OperationType, SignOperationFnSignature } from "@ledgerhq/types-live";
-import { BinaryUtils } from "./utils/binary.utils";
-import { decodeTokenAccountId } from "../../account";
-import { extractTokenId } from "./logic";
-
-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);
-  }
-}
-
-const buildOptimisticOperation = (
-  account: Account,
-  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;
-};
-
-/**
- * Sign Transaction with Ledger hardware
- */
-const signOperation: SignOperationFnSignature<Transaction> = ({ 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/js-synchronisation.ts

@@ -1,74 +0,0 @@
-import { TokenAccount } from "@ledgerhq/types-live";
-import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
-import { inferSubOperations } from "@ledgerhq/coin-framework/serialization/index";
-import type { GetAccountShape } from "../../bridge/jsHelpers";
-import { makeScanAccounts, makeSync, mergeOps } from "../../bridge/jsHelpers";
-import { getAccount, getAccountDelegations, getEGLDOperations, hasESDTTokens } from "./api";
-import elrondBuildESDTTokenAccounts from "./js-buildSubAccounts";
-import { reconciliateSubAccounts } from "./js-reconciliation";
-import { computeDelegationBalance } from "./logic";
-
-const getAccountShape: GetAccountShape = 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/elrond/js-transaction.ts

@@ -1,90 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import type { ElrondAccount, Transaction } from "./types";
-import { getFees } from "./api";
-import { GAS, MIN_GAS_LIMIT } from "./constants";
-import { ElrondEncodeTransaction } from "./encode";
-import { isAmountSpentFromBalance } from "./logic";
-
-/**
- * Create an empty t
- *
- * @returns {Transaction}
- */
-export const createTransaction = (): Transaction => {
-  return {
-    family: "elrond",
-    mode: "send",
-    amount: new BigNumber(0),
-    recipient: "",
-    useAllAmount: false,
-    fees: new BigNumber(50000),
-    gasLimit: MIN_GAS_LIMIT,
-  };
-};
-
-/**
- * Prepare t before checking status
- *
- * @param {ElrondAccount} a
- * @param {Transaction} t
- */
-export const prepareTransaction = async (
-  a: ElrondAccount,
-  t: Transaction,
-): Promise<Transaction> => {
-  const preparedTx: Transaction = t;
-
-  const tokenAccount =
-    (t.subAccountId && a.subAccounts && a.subAccounts.find(ta => ta.id === t.subAccountId)) || null;
-
-  if (tokenAccount) {
-    preparedTx.data = ElrondEncodeTransaction.ESDTTransfer(t, tokenAccount);
-    preparedTx.gasLimit = GAS.ESDT_TRANSFER;
-  } else {
-    switch (t.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(t);
-        break;
-      case "send":
-        break;
-      default:
-        throw new Error("Unsupported transaction mode: " + t.mode);
-    }
-  }
-
-  if (t.useAllAmount) {
-    // Set the max amount
-    preparedTx.amount = tokenAccount ? tokenAccount.balance : a.spendableBalance;
-
-    // Compute estimated fees for that amount
-    preparedTx.fees = await getFees(preparedTx);
-
-    // Adjust max amount according to computed fees
-    if (!tokenAccount && isAmountSpentFromBalance(t.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/hedera/js-broadcast.ts

@@ -1,26 +0,0 @@
-import { Account, Operation, SignedOperation } from "@ledgerhq/types-live";
-import { Transaction } from "@hashgraph/sdk";
-import { broadcastTransaction } from "./api/network";
-import { patchOperationWithHash } from "../../operation";
-import { base64ToUrlSafeBase64 } from "./utils";
-
-export default async function broadcast({
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  account,
-  signedOperation,
-}: {
-  account: Account;
-  signedOperation: SignedOperation;
-}): Promise<Operation> {
-  const { signature, operation } = signedOperation;
-
-  // NOTE: expecting a serialized transaction to be signedOperation.signature (in hex)
-  const hederaTransaction = Transaction.fromBytes(Buffer.from(signature, "base64"));
-
-  const response = await broadcastTransaction(hederaTransaction);
-
-  const base64Hash = Buffer.from(response.transactionHash).toString("base64");
-  const base64HashUrlSafe = base64ToUrlSafeBase64(base64Hash);
-
-  return patchOperationWithHash(operation, base64HashUrlSafe);
-}

package/src/families/hedera/js-estimateMaxSpendable.ts

@@ -1,31 +0,0 @@
-import BigNumber from "bignumber.js";
-import type { Account, AccountLike } from "@ledgerhq/types-live";
-import { getMainAccount } from "../../account/index";
-import type { Transaction } from "./types";
-import { getEstimatedFees } from "./utils";
-
-export default async function estimateMaxSpendable({
-  account,
-  parentAccount,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  transaction,
-}: {
-  account: AccountLike;
-  parentAccount?: Account | null | undefined;
-  transaction?: Transaction | null | undefined;
-}): Promise<BigNumber> {
-  const balance = account.balance;
-
-  const mainAccount = getMainAccount(account, parentAccount);
-  const estimatedFees = await getEstimatedFees(mainAccount);
-
-  let maxSpendable = balance.minus(estimatedFees);
-
-  // set max spendable to 0 if negative
-  // for cases where the user's account balance is smaller than the estimated fee
-  if (maxSpendable.isLessThan(0)) {
-    maxSpendable = new BigNumber(0);
-  }
-
-  return Promise.resolve(maxSpendable);
-}

package/src/families/hedera/js-getTransactionStatus.ts

@@ -1,55 +0,0 @@
-import {
-  AmountRequired,
-  NotEnoughBalance,
-  InvalidAddress,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  RecipientRequired,
-} from "@ledgerhq/errors";
-import { AccountId } from "@hashgraph/sdk";
-import type { Transaction, TransactionStatus } from "./types";
-import type { Account } from "@ledgerhq/types-live";
-import { calculateAmount, getEstimatedFees } from "./utils";
-
-export default async function getTransactionStatus(
-  account: Account,
-  transaction: Transaction,
-): Promise<TransactionStatus> {
-  const errors: Record<string, Error> = {};
-
-  if (!transaction.recipient || transaction.recipient.length === 0) {
-    errors.recipient = new RecipientRequired("");
-  } else {
-    if (account.freshAddress === transaction.recipient) {
-      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource("");
-    }
-
-    try {
-      AccountId.fromString(transaction.recipient);
-    } catch (err) {
-      errors.recipient = new InvalidAddress("", {
-        currencyName: account.currency.name,
-      });
-    }
-  }
-
-  const { amount, totalSpent } = await calculateAmount({
-    transaction,
-    account,
-  });
-
-  if (transaction.amount.eq(0) && !transaction.useAllAmount) {
-    errors.amount = new AmountRequired();
-  } else if (account.balance.isLessThan(totalSpent)) {
-    errors.amount = new NotEnoughBalance("");
-  }
-
-  const estimatedFees = await getEstimatedFees(account);
-
-  return {
-    amount,
-    errors,
-    estimatedFees,
-    totalSpent,
-    warnings: {},
-  };
-}

package/src/families/hedera/js-receive.ts

@@ -1,47 +0,0 @@
-import { WrongDeviceForAccount } from "@ledgerhq/errors";
-import { Observable } from "rxjs";
-import { withDevice } from "../../hw/deviceAccess";
-import { isSegwitDerivationMode } from "@ledgerhq/coin-framework/derivation";
-import getAddress from "../../hw/getAddress";
-import type { Account, DerivationMode } from "@ledgerhq/types-live";
-
-const receive = (
-  account: Account,
-  {
-    deviceId,
-  }: {
-    deviceId: string;
-  },
-): Observable<{
-  address: string;
-  path: string;
-}> =>
-  withDevice(deviceId)(transport => {
-    return new Observable(o => {
-      void (async function () {
-        try {
-          const r = await getAddress(transport, {
-            derivationMode: account.derivationMode as DerivationMode,
-            currency: account.currency,
-            path: account.freshAddressPath,
-            segwit: isSegwitDerivationMode(account.derivationMode as DerivationMode),
-          });
-
-          if (r.publicKey !== account.seedIdentifier) {
-            throw new WrongDeviceForAccount();
-          }
-
-          o.next({
-            address: account.freshAddress,
-            path: account.freshAddressPath,
-          });
-
-          o.complete();
-        } catch (err) {
-          o.error(err);
-        }
-      })();
-    });
-  });
-
-export default receive;

package/src/families/hedera/js-signOperation.ts

@@ -1,82 +0,0 @@
-import { Observable } from "rxjs";
-import { PublicKey } from "@hashgraph/sdk";
-import { Account, Operation, SignOperationFnSignature } from "@ledgerhq/types-live";
-import { withDevice } from "../../hw/deviceAccess";
-import { Transaction } from "./types";
-import { buildUnsignedTransaction } from "./api/network";
-import { getEstimatedFees } from "./utils";
-import Hedera from "./hw-app-hedera";
-import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-
-const signOperation: SignOperationFnSignature<Transaction> = ({ account, transaction, deviceId }) =>
-  withDevice(deviceId)(transport => {
-    return new Observable(o => {
-      void (async function () {
-        try {
-          o.next({
-            type: "device-signature-requested",
-          });
-
-          const hederaTransaction = await buildUnsignedTransaction({
-            account,
-            transaction,
-          });
-
-          const accountPublicKey = PublicKey.fromString(account.seedIdentifier);
-
-          await hederaTransaction.signWith(accountPublicKey, async bodyBytes => {
-            return await new Hedera(transport).signTransaction(bodyBytes);
-          });
-
-          o.next({
-            type: "device-signature-granted",
-          });
-
-          const operation = await buildOptimisticOperation({
-            account,
-            transaction,
-          });
-
-          o.next({
-            type: "signed",
-            signedOperation: {
-              operation,
-              // NOTE: this needs to match the inverse operation in js-broadcast
-              signature: Buffer.from(hederaTransaction.toBytes()).toString("base64"),
-            },
-          });
-
-          o.complete();
-        } catch (err) {
-          o.error(err);
-        }
-      })();
-    });
-  });
-
-async function buildOptimisticOperation({
-  account,
-  transaction,
-}: {
-  account: Account;
-  transaction: Transaction;
-}): Promise<Operation> {
-  const operation: Operation = {
-    id: encodeOperationId(account.id, "", "OUT"),
-    hash: "",
-    type: "OUT",
-    value: transaction.amount,
-    fee: await getEstimatedFees(account),
-    blockHash: null,
-    blockHeight: null,
-    senders: [account.freshAddress.toString()],
-    recipients: [transaction.recipient],
-    accountId: account.id,
-    date: new Date(),
-    extra: {},
-  };
-
-  return operation;
-}
-
-export default signOperation;

package/src/families/hedera/js-transaction.ts

@@ -1,40 +0,0 @@
-import BigNumber from "bignumber.js";
-import type { Account } from "@ledgerhq/types-live";
-import type { Transaction } from "./types";
-import { calculateAmount } from "./utils";
-
-/**
- * Creates an empty transaction.
- *
- * @returns {Transaction}
- */
-export function createTransaction(_account: Account): Transaction {
-  return {
-    family: "hedera",
-    amount: new BigNumber(0),
-    recipient: "",
-    useAllAmount: false,
-  };
-}
-
-/**
- * Gather any more neccessary information for a transaction,
- * potentially from a network.
- *
- * Hedera has fully client-side transactions and the fee
- * is not possible to estimate ahead-of-time.
- *
- * @returns  {Transaction}
- */
-export async function prepareTransaction(
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  account: Account,
-  transaction: Transaction,
-): Promise<Transaction> {
-  // explicitly calculate transaction amount to account for `useAllAmount` flag (send max flow)
-  // i.e. if `useAllAmount` has been toggled to true, this is where it will update the transaction to reflect that action
-  const { amount } = await calculateAmount({ account, transaction });
-  transaction.amount = amount;
-
-  return transaction;
-}

package/src/families/stellar/js-broadcast.ts

@@ -1,19 +0,0 @@
-import { patchOperationWithHash } from "../../operation";
-import type { Operation, SignedOperation } from "@ledgerhq/types-live";
-import { broadcastTransaction as apiBroadcast } from "./api";
-
-/**
- * Broadcast a signed transaction
- * @param {signature: string, operation: string} signedOperation
- */
-const broadcast = async ({
-  signedOperation,
-}: {
-  signedOperation: SignedOperation;
-}): Promise<Operation> => {
-  const { signature, operation } = signedOperation;
-  const hash = await apiBroadcast(signature);
-  return patchOperationWithHash(operation, hash);
-};
-
-export default broadcast;