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

package/src/families/celo/estimateMaxSpendable.ts

@@ -0,0 +1,22 @@
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { CeloAccount, Transaction } from "./types";
+import getTransactionStatus from "./getTransactionStatus";
+import prepareTransaction from "./prepareTransaction";
+import createTransaction from "./createTransaction";
+import { getMainAccount } from "../../account";
+
+export const estimateMaxSpendable: AccountBridge<
+  Transaction,
+  CeloAccount
+>["estimateMaxSpendable"] = async ({ account, parentAccount, transaction }) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const t = await prepareTransaction(mainAccount, {
+    ...createTransaction(account),
+    ...transaction,
+    useAllAmount: true,
+  });
+  const { amount } = await getTransactionStatus(mainAccount, t);
+  return amount;
+};
+
+export default estimateMaxSpendable;

package/src/families/celo/getTransactionStatus.ts

@@ -0,0 +1,120 @@
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { BigNumber } from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { isValidAddress } from "@celo/utils/lib/address";
+import { getPendingStakingOperationAmounts, getVote } from "./logic";
+import { CeloAccount, Transaction, TransactionStatus } from "./types";
+import { CeloAllFundsWarning } from "./errors";
+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);
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  CeloAccount,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  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 {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};
+
+export default getTransactionStatus;

package/src/families/celo/prepareTransaction.ts

@@ -0,0 +1,33 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { isValidAddress } from "@celo/utils/lib/address";
+import getFeesForTransaction from "./getFeesForTransaction";
+import { CeloAccount, Transaction } from "./types";
+
+const sameFees = (a, b) => (!a || !b ? a === b : a.eq(b));
+
+export const prepareTransaction: AccountBridge<
+  Transaction,
+  CeloAccount
+>["prepareTransaction"] = async (account, 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/signOperation.ts

@@ -0,0 +1,110 @@
+import { BigNumber } from "bignumber.js";
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { rlpEncodedTx, encodeTransaction } from "@celo/wallet-base";
+import { tokenInfoByAddressAndChainId } from "@celo/wallet-ledger/lib/tokens";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import type { Transaction, CeloAccount } from "./types";
+import { withDevice } from "../../hw/deviceAccess";
+import buildTransaction from "./buildTransaction";
+import { CeloApp } from "./hw-app-celo";
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const signOperation: AccountBridge<Transaction, CeloAccount>["signOperation"] = ({
+  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, 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,
+            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;
+        };
+      }),
+  );
+
+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"),
+  };
+};
+
+export default signOperation;

package/src/families/celo/synchronisation.ts

@@ -0,0 +1,62 @@
+import { getAccountRegistrationStatus, getPendingWithdrawals, getVotes } from "./api/sdk";
+import { makeSync, makeScanAccounts, mergeOps } from "../../bridge/jsHelpers";
+import type { GetAccountShape } from "../../bridge/jsHelpers";
+import { encodeAccountId } from "../../account";
+import { getAccountDetails } from "./api";
+import { CeloAccount } from "./types";
+import { celoKit } from "./api/sdk";
+
+const kit = celoKit();
+
+const getAccountShape: GetAccountShape<CeloAccount> = 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 });

package/src/families/cosmos/banner.test.ts

@@ -8,7 +8,7 @@ import { BigNumber } from "bignumber.js";
 import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 import { liveConfig } from "../../config/sharedConfig";
 
-jest.mock("./js-prepareTransaction", () => ({
+jest.mock("./prepareTransaction", () => ({
   calculateFees: jest.fn(() => Promise.resolve({})),
 }));
 

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

@@ -1,26 +1,32 @@
-import createTransaction from "../js-createTransaction";
-import estimateMaxSpendable from "../js-estimateMaxSpendable";
-import getTransactionStatus from "../js-getTransactionStatus";
-import prepareTransaction from "../js-prepareTransaction";
-import signOperation from "../js-signOperation";
-import { sync, scanAccounts } from "../js-synchronisation";
-import updateTransaction from "../js-updateTransaction";
-import type { CosmosCurrencyConfig, CosmosValidatorItem, Transaction } from "../types";
-import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
-import { asSafeCosmosPreloadData, setCosmosPreloadData } from "../preloadedData";
-import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
-import { CosmosAPI } from "../api/Cosmos";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import type {
+  CosmosAccount,
+  CosmosCurrencyConfig,
+  CosmosValidatorItem,
+  Transaction,
+  TransactionStatus,
+} from "../types";
+import { asSafeCosmosPreloadData, setCosmosPreloadData } from "../preloadedData";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
 import { CosmosValidatorsManager } from "../CosmosValidatorsManager";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import getTransactionStatus from "../getTransactionStatus";
+import { getCurrencyConfiguration } from "../../../config";
+import { prepareTransaction } from "../prepareTransaction";
+import { updateTransaction } from "../updateTransaction";
+import { createTransaction } from "../createTransaction";
+import { sync, scanAccounts } from "../synchronisation";
+import { signOperation } from "../signOperation";
+import cryptoFactory from "../chain/chain";
+import { CosmosAPI } from "../api/Cosmos";
 import {
   assignFromAccountRaw,
   assignToAccountRaw,
   fromOperationExtraRaw,
   toOperationExtraRaw,
 } from "../serialization";
-import { getCurrencyConfiguration } from "../../../config";
-import cryptoFactory from "../chain/chain";
 
 const receive = makeAccountBridgeReceive();
 
@@ -64,7 +70,7 @@ const currencyBridge: CurrencyBridge = {
   scanAccounts,
 };
 
-const accountBridge: AccountBridge<Transaction> = {
+const accountBridge: AccountBridge<Transaction, CosmosAccount, TransactionStatus> = {
   createTransaction,
   updateTransaction,
   prepareTransaction,

package/src/families/cosmos/bridge/mock.ts

@@ -103,7 +103,7 @@ const prepareTransaction = async (a: CosmosAccount, t: Transaction): Promise<Tra
     return {
       ...t,
       gas: new BigNumber(1),
-      fees: new BigNumber(500),
+      fees: new BigNumber(375),
       networkInfo: {
         family: "cosmos",
         fees: new BigNumber(500),