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

package/src/families/cardano/tx-helpers.ts

@@ -1,235 +0,0 @@
-import {
-  CertificateType,
-  StakeCredentialParamsType,
-  StakeDelegationParams,
-  StakeRegistrationParams,
-  StakeDeregistrationParams,
-  Withdrawal,
-} from "@cardano-foundation/ledgerjs-hw-app-cardano";
-import { str_to_path } from "@cardano-foundation/ledgerjs-hw-app-cardano/dist/utils/address";
-import { types as TyphonTypes, address as TyphonAddress } from "@stricahq/typhonjs";
-import groupBy from "lodash/groupBy";
-import {
-  AddressType,
-  AssetGroup,
-  TxInput,
-  TxOutput,
-  TxOutputDestination,
-  TxOutputDestinationType,
-} from "@cardano-foundation/ledgerjs-hw-app-cardano";
-import { getBipPathString } from "./logic";
-
-/**
- * returns the formatted transactionInput for ledger cardano app
- *
- * @param {TyphonTypes.Input} input
- * @param {number} accountIndex
- * @returns {TxInput}
- */
-export function prepareLedgerInput(input: TyphonTypes.Input, accountIndex: number): TxInput {
-  const paymentKeyPath =
-    input.address.paymentCredential.type === TyphonTypes.HashType.ADDRESS
-      ? input.address.paymentCredential.bipPath
-      : undefined;
-  return {
-    txHashHex: input.txId,
-    outputIndex: input.index,
-    path: paymentKeyPath
-      ? str_to_path(
-          getBipPathString({
-            account: accountIndex,
-            chain: paymentKeyPath.chain,
-            index: paymentKeyPath.index,
-          }),
-        )
-      : null,
-  };
-}
-
-/**
- * returns the formatted transactionOutput for ledger cardano app
- *
- * @param output
- * @param accountIndex
- * @returns {TxOutput}
- */
-export function prepareLedgerOutput(output: TyphonTypes.Output, accountIndex: number): TxOutput {
-  const isByronAddress = output.address instanceof TyphonAddress.ByronAddress;
-  let isDeviceOwnedAddress = false;
-  let destination: TxOutputDestination;
-
-  if (!isByronAddress) {
-    const address = output.address as TyphonTypes.ShelleyAddress;
-    isDeviceOwnedAddress =
-      address.paymentCredential &&
-      address.paymentCredential.type === TyphonTypes.HashType.ADDRESS &&
-      address.paymentCredential.bipPath !== undefined;
-  }
-
-  if (isDeviceOwnedAddress) {
-    const address = output.address as TyphonAddress.BaseAddress;
-
-    const paymentKeyPath = (address.paymentCredential as TyphonTypes.HashCredential)
-      .bipPath as TyphonTypes.BipPath;
-    const stakingKeyPath = (address.stakeCredential as TyphonTypes.HashCredential)
-      .bipPath as TyphonTypes.BipPath;
-
-    const paymentKeyPathString = getBipPathString({
-      account: accountIndex,
-      chain: paymentKeyPath.chain,
-      index: paymentKeyPath.index,
-    });
-    const stakingKeyPathString = getBipPathString({
-      account: accountIndex,
-      chain: stakingKeyPath.chain,
-      index: stakingKeyPath.index,
-    });
-
-    destination = {
-      type: TxOutputDestinationType.DEVICE_OWNED,
-      params: {
-        type: AddressType.BASE_PAYMENT_KEY_STAKE_KEY,
-        params: {
-          spendingPath: str_to_path(paymentKeyPathString),
-          stakingPath: str_to_path(stakingKeyPathString),
-        },
-      },
-    };
-  } else {
-    const address = output.address;
-    destination = {
-      type: TxOutputDestinationType.THIRD_PARTY,
-      params: {
-        addressHex: address.getHex(),
-      },
-    };
-  }
-
-  const tokenBundle: Array<AssetGroup> = Object.values(
-    groupBy(output.tokens, ({ policyId }) => policyId),
-  ).map(tokens => ({
-    policyIdHex: tokens[0].policyId,
-    tokens: tokens.map(token => ({
-      assetNameHex: token.assetName,
-      amount: token.amount.toString(),
-    })),
-  }));
-
-  return {
-    amount: output.amount.toString(),
-    destination,
-    tokenBundle,
-  };
-}
-
-export function prepareStakeRegistrationCertificate(
-  certificate: TyphonTypes.StakeRegistrationCertificate,
-): {
-  type: CertificateType.STAKE_REGISTRATION;
-  params: StakeRegistrationParams;
-} {
-  if (
-    certificate.stakeCredential.type === TyphonTypes.HashType.ADDRESS &&
-    certificate.stakeCredential.bipPath
-  ) {
-    return {
-      type: CertificateType.STAKE_REGISTRATION,
-      params: {
-        stakeCredential: {
-          type: StakeCredentialParamsType.KEY_PATH,
-          keyPath: str_to_path(
-            getBipPathString({
-              account: certificate.stakeCredential.bipPath.account,
-              chain: certificate.stakeCredential.bipPath.chain,
-              index: certificate.stakeCredential.bipPath.index,
-            }),
-          ),
-        },
-      },
-    };
-  } else {
-    throw new Error("Invalid stakeKey type");
-  }
-}
-
-export function prepareStakeDelegationCertificate(
-  certificate: TyphonTypes.StakeDelegationCertificate,
-): {
-  type: CertificateType.STAKE_DELEGATION;
-  params: StakeDelegationParams;
-} {
-  if (
-    certificate.stakeCredential.type === TyphonTypes.HashType.ADDRESS &&
-    certificate.stakeCredential.bipPath
-  ) {
-    return {
-      type: CertificateType.STAKE_DELEGATION,
-      params: {
-        stakeCredential: {
-          type: StakeCredentialParamsType.KEY_PATH,
-          keyPath: str_to_path(
-            getBipPathString({
-              account: certificate.stakeCredential.bipPath.account,
-              chain: certificate.stakeCredential.bipPath.chain,
-              index: certificate.stakeCredential.bipPath.index,
-            }),
-          ),
-        },
-        poolKeyHashHex: certificate.poolHash,
-      },
-    };
-  } else {
-    throw new Error("Invalid stakeKey type");
-  }
-}
-
-export function prepareStakeDeRegistrationCertificate(certificate: TyphonTypes.Certificate): {
-  type: CertificateType.STAKE_DEREGISTRATION;
-  params: StakeDeregistrationParams;
-} {
-  if (
-    certificate.stakeCredential.type === TyphonTypes.HashType.ADDRESS &&
-    certificate.stakeCredential.bipPath
-  ) {
-    return {
-      type: CertificateType.STAKE_DEREGISTRATION,
-      params: {
-        stakeCredential: {
-          type: StakeCredentialParamsType.KEY_PATH,
-          keyPath: str_to_path(
-            getBipPathString({
-              account: certificate.stakeCredential.bipPath.account,
-              chain: certificate.stakeCredential.bipPath.chain,
-              index: certificate.stakeCredential.bipPath.index,
-            }),
-          ),
-        },
-      },
-    };
-  } else {
-    throw new Error("Invalid stakeKey type");
-  }
-}
-
-export function prepareWithdrawal(withdrawal: TyphonTypes.Withdrawal): Withdrawal {
-  if (
-    withdrawal.rewardAccount.stakeCredential.type === TyphonTypes.HashType.ADDRESS &&
-    withdrawal.rewardAccount.stakeCredential.bipPath
-  ) {
-    return {
-      stakeCredential: {
-        type: StakeCredentialParamsType.KEY_PATH,
-        keyPath: str_to_path(
-          getBipPathString({
-            account: withdrawal.rewardAccount.stakeCredential.bipPath.account,
-            chain: withdrawal.rewardAccount.stakeCredential.bipPath.chain,
-            index: withdrawal.rewardAccount.stakeCredential.bipPath.index,
-          }),
-        ),
-      },
-      amount: withdrawal.amount.toString(),
-    };
-  } else {
-    throw new Error("Invalid stakeKey type");
-  }
-}

package/src/families/cardano/utils.ts

@@ -1,4 +0,0 @@
-// the IDs of ledger stake pools to shows in lld and llm
-export const LEDGER_POOL_IDS: Array<string> = [
-  "4a9c9902c9538da900b10b716d5d1b214487455fdb06028b32ffa180",
-];

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

@@ -1,10 +0,0 @@
-import { patchOperationWithHash } from "../../operation";
-import { celoKit } from "./api/sdk";
-
-const broadcast = async ({ signedOperation: { operation, signature } }) => {
-  const kit = celoKit();
-  const { transactionHash } = await kit.web3.eth.sendSignedTransaction(signature);
-  return patchOperationWithHash(operation, transactionHash);
-};
-
-export default broadcast;

package/src/families/celo/js-createTransaction.ts

@@ -1,14 +0,0 @@
-import { Transaction } from "./types";
-import { BigNumber } from "bignumber.js";
-
-const createTransaction = (): Transaction => ({
-  family: "celo",
-  amount: new BigNumber(0),
-  recipient: "",
-  useAllAmount: false,
-  fees: null,
-  mode: "send",
-  index: null,
-});
-
-export default createTransaction;

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

@@ -1,28 +0,0 @@
-import { CeloAccount, Transaction } from "./types";
-import { BigNumber } from "bignumber.js";
-import { getMainAccount } from "../../account";
-import getTransactionStatus from "./js-getTransactionStatus";
-import prepareTransaction from "./js-prepareTransaction";
-import createTransaction from "./js-createTransaction";
-import type { Account, AccountLike } from "@ledgerhq/types-live";
-
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-  transaction,
-}: {
-  account: AccountLike;
-  parentAccount: Account;
-  transaction: Transaction;
-}): Promise<BigNumber> => {
-  const mainAccount = getMainAccount(account, parentAccount) as CeloAccount;
-  const t = await prepareTransaction(mainAccount, {
-    ...createTransaction(),
-    ...transaction,
-    useAllAmount: true,
-  });
-  const s = await getTransactionStatus(mainAccount, t);
-  return s.amount;
-};
-
-export default estimateMaxSpendable;

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

@@ -1,118 +0,0 @@
-import { CeloAccount, Transaction, TransactionStatus } from "./types";
-import {
-  AmountRequired,
-  FeeNotLoaded,
-  InvalidAddress,
-  InvalidAddressBecauseDestinationIsAlsoSource,
-  NotEnoughBalance,
-  RecipientRequired,
-} from "@ledgerhq/errors";
-import { BigNumber } from "bignumber.js";
-import { isValidAddress } from "@celo/utils/lib/address";
-import { CeloAllFundsWarning } from "./errors";
-import { getPendingStakingOperationAmounts, getVote } from "./logic";
-import { celoKit } from "./api/sdk";
-
-const kit = celoKit();
-
-// Arbitrary buffer for paying fees of next transactions. 0.05 Celo for ~100 transactions
-const FEES_SAFETY_BUFFER = new BigNumber(5000000000000000);
-
-const getTransactionStatus = async (
-  account: CeloAccount,
-  transaction: Transaction,
-): Promise<TransactionStatus> => {
-  const errors: any = {};
-  const warnings: any = {};
-  const useAllAmount = !!transaction.useAllAmount;
-
-  if (account.freshAddress === transaction.recipient) {
-    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
-  }
-
-  if (!transaction.fees || !transaction.fees.gt(0)) {
-    errors.fees = new FeeNotLoaded();
-  }
-
-  const pendingOperationAmounts = getPendingStakingOperationAmounts(account);
-  const lockedGold = await kit.contracts.getLockedGold();
-  const nonvotingLockedGoldBalance = await lockedGold.getAccountNonvotingLockedGold(
-    account.freshAddress,
-  );
-  // Deduct pending vote operations from the non-voting locked balance
-  const totalNonVotingLockedBalance = nonvotingLockedGoldBalance.minus(
-    pendingOperationAmounts.vote,
-  );
-  // Deduct pending lock operations from the spendable balance
-  const totalSpendableBalance = account.spendableBalance.minus(pendingOperationAmounts.lock);
-  const estimatedFees = transaction.fees || new BigNumber(0);
-
-  let amount: BigNumber = new BigNumber(0);
-  if (useAllAmount && (transaction.mode === "unlock" || transaction.mode === "vote")) {
-    amount = totalNonVotingLockedBalance ?? new BigNumber(0);
-  } else if (useAllAmount && transaction.mode === "revoke") {
-    const revoke = getVote(account, transaction.recipient, transaction.index);
-    if (revoke?.amount) amount = revoke.amount;
-  } else if (useAllAmount) {
-    amount = totalSpendableBalance.minus(estimatedFees);
-  } else {
-    amount = new BigNumber(transaction.amount);
-  }
-
-  if (amount.lt(0)) amount = new BigNumber(0);
-
-  if (
-    (account.celoResources?.lockedBalance.gt(0) ||
-      !!account.celoResources?.pendingWithdrawals?.length) &&
-    (transaction.useAllAmount || totalSpendableBalance.minus(amount).lt(FEES_SAFETY_BUFFER)) &&
-    ["send", "lock"].includes(transaction.mode)
-  ) {
-    warnings.amount = new CeloAllFundsWarning();
-  }
-
-  if (!["register", "withdraw", "activate"].includes(transaction.mode)) {
-    if (!errors.amount && amount.lte(0) && !useAllAmount) {
-      errors.amount = new AmountRequired();
-    }
-  }
-
-  const totalSpent = amount.plus(estimatedFees);
-
-  if (transaction.mode === "unlock" || transaction.mode === "vote") {
-    if (!errors.amount && totalNonVotingLockedBalance && amount.gt(totalNonVotingLockedBalance)) {
-      errors.amount = new NotEnoughBalance();
-    }
-  } else if (transaction.mode === "revoke") {
-    const revoke = getVote(account, transaction.recipient, transaction.index);
-    if (!errors.amount && revoke?.amount && amount.gt(revoke.amount))
-      errors.amount = new NotEnoughBalance();
-  } else {
-    if (!errors.amount && totalSpent.gt(totalSpendableBalance)) {
-      errors.amount = new NotEnoughBalance();
-    }
-  }
-
-  if (!errors.amount && totalSpendableBalance.lt(estimatedFees)) {
-    errors.amount = new NotEnoughBalance();
-  }
-
-  if (transaction.mode === "send") {
-    if (!transaction.recipient) {
-      errors.recipient = new RecipientRequired();
-    } else if (!isValidAddress(transaction.recipient)) {
-      errors.recipient = new InvalidAddress("", {
-        currencyName: account.currency.name,
-      });
-    }
-  }
-
-  return Promise.resolve({
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-  });
-};
-
-export default getTransactionStatus;

package/src/families/celo/js-prepareTransaction.ts

@@ -1,29 +0,0 @@
-import { CeloAccount, Transaction } from "./types";
-import getFeesForTransaction from "./js-getFeesForTransaction";
-import { isValidAddress } from "@celo/utils/lib/address";
-import BigNumber from "bignumber.js";
-
-const sameFees = (a, b) => (!a || !b ? a === b : a.eq(b));
-
-const prepareTransaction = async (account: CeloAccount, transaction: Transaction) => {
-  if (transaction.recipient && !isValidAddress(transaction.recipient)) return transaction;
-
-  if (["send", "vote"].includes(transaction.mode) && !transaction.recipient) return transaction;
-
-  if (
-    transaction.mode === "vote" &&
-    !transaction.useAllAmount &&
-    new BigNumber(transaction.amount).lte(0)
-  )
-    return transaction;
-
-  const fees = await getFeesForTransaction({ account, transaction });
-
-  if (!sameFees(transaction.fees, fees)) {
-    return { ...transaction, fees };
-  }
-
-  return transaction;
-};
-
-export default prepareTransaction;

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

@@ -1,155 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { Observable } from "rxjs";
-import { FeeNotLoaded } from "@ledgerhq/errors";
-import type { OperationType, SignOperationFnSignature } from "@ledgerhq/types-live";
-import type { Transaction, CeloOperationMode, CeloAccount, CeloOperation } from "./types";
-import { encodeOperationId } from "../../operation";
-import { CeloApp } from "./hw-app-celo";
-import buildTransaction from "./js-buildTransaction";
-import { rlpEncodedTx, encodeTransaction } from "@celo/wallet-base";
-import { tokenInfoByAddressAndChainId } from "@celo/wallet-ledger/lib/tokens";
-import { withDevice } from "../../hw/deviceAccess";
-
-const MODE_TO_TYPE: { [key in CeloOperationMode | "default"]: string } = {
-  send: "OUT",
-  lock: "LOCK",
-  unlock: "UNLOCK",
-  withdraw: "WITHDRAW",
-  vote: "VOTE",
-  revoke: "REVOKE",
-  activate: "ACTIVATE",
-  register: "REGISTER",
-  default: "FEE",
-};
-
-const buildOptimisticOperation = (
-  account: CeloAccount,
-  transaction: Transaction,
-  fee: BigNumber,
-): CeloOperation => {
-  const type = (MODE_TO_TYPE[transaction.mode] ?? MODE_TO_TYPE.default) as OperationType;
-
-  const value =
-    type === "OUT" || type === "LOCK"
-      ? new BigNumber(transaction.amount).plus(fee)
-      : new BigNumber(transaction.amount);
-
-  const operation: CeloOperation = {
-    id: encodeOperationId(account.id, "", type),
-    hash: "",
-    type,
-    value,
-    fee,
-    blockHash: null,
-    blockHeight: null,
-    senders: [account.freshAddress],
-    recipients: [transaction.recipient].filter(Boolean),
-    accountId: account.id,
-    date: new Date(),
-    extra: {
-      celoOperationValue: new BigNumber(transaction.amount),
-      ...(["ACTIVATE", "VOTE", "REVOKE"].includes(type)
-        ? {
-            celoSourceValidator: transaction.recipient,
-          }
-        : {}),
-    },
-  };
-
-  return operation;
-};
-
-const trimLeading0x = (input: string) => (input.startsWith("0x") ? input.slice(2) : input);
-
-const parseSigningResponse = (
-  response: {
-    s: string;
-    v: string;
-    r: string;
-  },
-  chainId: number,
-): {
-  s: Buffer;
-  v: number;
-  r: Buffer;
-} => {
-  // EIP155
-  const sigV = parseInt(response.v, 16);
-  let eip155V = chainId * 2 + 35;
-  if (sigV !== eip155V && (sigV & eip155V) !== sigV) {
-    eip155V += 1;
-  }
-
-  return {
-    s: Buffer.from(response.s, "hex"),
-    v: eip155V,
-    r: Buffer.from(response.r, "hex"),
-  };
-};
-
-/**
- * Sign Transaction with Ledger hardware
- */
-const signOperation: SignOperationFnSignature<Transaction> = ({ account, deviceId, transaction }) =>
-  withDevice(deviceId)(
-    transport =>
-      new Observable(o => {
-        let cancelled;
-
-        async function main() {
-          if (!transaction.fees) {
-            throw new FeeNotLoaded();
-          }
-
-          const celo = new CeloApp(transport);
-          const unsignedTransaction = await buildTransaction(account as CeloAccount, transaction);
-          const { chainId, to } = unsignedTransaction;
-          const rlpEncodedTransaction = rlpEncodedTx(unsignedTransaction);
-
-          const tokenInfo = tokenInfoByAddressAndChainId(to!, chainId!);
-          if (tokenInfo) {
-            await celo.provideERC20TokenInformation(tokenInfo);
-          }
-
-          o.next({ type: "device-signature-requested" });
-
-          const response = await celo.signTransaction(
-            account.freshAddressPath,
-            trimLeading0x(rlpEncodedTransaction.rlpEncode),
-          );
-
-          if (cancelled) return;
-
-          const signature = parseSigningResponse(response, chainId!);
-
-          o.next({ type: "device-signature-granted" });
-
-          const encodedTransaction = await encodeTransaction(rlpEncodedTransaction, signature);
-
-          const operation = buildOptimisticOperation(
-            account as CeloAccount,
-            transaction,
-            transaction.fees ?? new BigNumber(0),
-          );
-
-          o.next({
-            type: "signed",
-            signedOperation: {
-              operation,
-              signature: encodedTransaction.raw,
-            },
-          });
-        }
-
-        main().then(
-          () => o.complete(),
-          e => o.error(e),
-        );
-
-        return () => {
-          cancelled = true;
-        };
-      }),
-  );
-
-export default signOperation;

package/src/families/celo/js-synchronisation.ts

@@ -1,61 +0,0 @@
-import { encodeAccountId } from "../../account";
-import type { GetAccountShape } from "../../bridge/jsHelpers";
-import { makeSync, makeScanAccounts, mergeOps } from "../../bridge/jsHelpers";
-import { getAccountDetails } from "./api";
-import { celoKit } from "./api/sdk";
-import { getAccountRegistrationStatus, getPendingWithdrawals, getVotes } from "./api/sdk";
-
-const kit = celoKit();
-
-const getAccountShape: GetAccountShape = async info => {
-  const { address, currency, initialAccount, derivationMode } = info;
-  const oldOperations = initialAccount?.operations || [];
-  const election = await kit.contracts.getElection();
-  const electionConfig = await election.getConfig();
-  const lockedGold = await kit.contracts.getLockedGold();
-
-  const accountId = encodeAccountId({
-    type: "js",
-    version: "2",
-    currencyId: currency.id,
-    xpubOrAddress: address,
-    derivationMode,
-  });
-  const {
-    blockHeight,
-    balance,
-    spendableBalance,
-    operations: newOperations,
-    lockedBalance,
-    nonvotingLockedBalance,
-  } = await getAccountDetails(address, accountId);
-
-  const accountRegistrationStatus = await getAccountRegistrationStatus(address);
-
-  const pendingWithdrawals = accountRegistrationStatus ? await getPendingWithdrawals(address) : [];
-
-  const votes = accountRegistrationStatus ? await getVotes(address) : [];
-
-  const operations = mergeOps(oldOperations, newOperations);
-  const shape = {
-    id: accountId,
-    balance,
-    spendableBalance,
-    operationsCount: operations.length,
-    blockHeight,
-    celoResources: {
-      registrationStatus: accountRegistrationStatus,
-      lockedBalance,
-      nonvotingLockedBalance,
-      pendingWithdrawals,
-      votes,
-      electionAddress: election.address,
-      lockedGoldAddress: lockedGold.address,
-      maxNumGroupsVotedFor: electionConfig.maxNumGroupsVotedFor,
-    },
-  };
-  return { ...shape, operations };
-};
-
-export const scanAccounts = makeScanAccounts({ getAccountShape });
-export const sync = makeSync({ getAccountShape });