@ledgerhq/live-common 27.0.0 → 27.1.0-next.1

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

@@ -1,38 +1,137 @@
-import type { Account } from "@ledgerhq/types-live";
 import { BigNumber } from "bignumber.js";
-import { Transaction } from "../../generated/types";
+import type { CeloAccount, Transaction } from "./types";
 import { celoKit } from "./api/sdk";
+import { getPendingStakingOperationAmounts, getVote } from "./logic";
 
 const getFeesForTransaction = async ({
   account,
   transaction,
 }: {
-  account: Account;
+  account: CeloAccount;
   transaction: Transaction;
 }): Promise<BigNumber> => {
-  const { amount } = transaction;
+  const { amount, index } = transaction;
   const kit = celoKit();
 
   // A workaround - estimating gas throws an error if value > funds
-  const value = transaction.useAllAmount
-    ? account.spendableBalance
-    : BigNumber.minimum(amount, account.spendableBalance);
+  let value: BigNumber = new BigNumber(0);
 
-  const celoToken = await kit.contracts.getGoldToken();
+  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 celoTransaction = {
-    from: account.freshAddress,
-    to: celoToken.address,
-    data: celoToken
-      .transfer(transaction.recipient, value.toFixed())
-      .txo.encodeABI(),
-  };
+  if (
+    (transaction.mode === "unlock" || transaction.mode === "vote") &&
+    account.celoResources
+  ) {
+    value = transaction.useAllAmount
+      ? totalNonVotingLockedBalance
+      : BigNumber.minimum(amount, totalNonVotingLockedBalance);
+  } else if (transaction.mode === "revoke" && account.celoResources) {
+    const vote = getVote(account, transaction.recipient, transaction.index);
+    if (vote) {
+      value = transaction.useAllAmount
+        ? vote.amount
+        : BigNumber.minimum(amount, vote.amount);
+    }
+  } else {
+    value = transaction.useAllAmount
+      ? totalSpendableBalance
+      : BigNumber.minimum(amount, totalSpendableBalance);
+  }
 
-  const gasPrice = new BigNumber(await kit.connection.gasPrice());
-  const gas = await kit.connection.estimateGasWithInflationFactor(
-    celoTransaction
-  );
+  let gas: number | null = null;
+  if (transaction.mode === "lock") {
+    gas = await lockedGold
+      .lock()
+      .txo.estimateGas({ from: account.freshAddress, value: value.toFixed() });
+  } else if (transaction.mode === "unlock") {
+    const lockedGold = await kit.contracts.getLockedGold();
+
+    gas = await lockedGold
+      .unlock(value)
+      .txo.estimateGas({ from: account.freshAddress });
+  } else if (transaction.mode === "withdraw") {
+    const lockedGold = await kit.contracts.getLockedGold();
+
+    gas = await lockedGold
+      .withdraw(index || 0)
+      .txo.estimateGas({ from: account.freshAddress });
+  } else if (transaction.mode === "vote") {
+    const election = await kit.contracts.getElection();
+
+    const vote = await election.vote(
+      transaction.recipient,
+      new BigNumber(value)
+    );
+
+    gas = await vote.txo.estimateGas({ from: account.freshAddress });
+  } else if (transaction.mode === "revoke") {
+    const election = await kit.contracts.getElection();
+    const accounts = await kit.contracts.getAccounts();
+    const voteSignerAccount = await accounts.voteSignerToAccount(
+      account.freshAddress
+    );
+    const revokeTxs = await election.revoke(
+      voteSignerAccount,
+      transaction.recipient,
+      new BigNumber(value)
+    );
+
+    const revokeTx = revokeTxs.find((transactionObject) => {
+      return (
+        (transactionObject.txo as any)._method.name ===
+        (transaction.index === 0 ? "revokePending" : "revokeActive")
+      );
+    });
+    if (!revokeTx) return new BigNumber(0);
 
+    gas = await revokeTx.txo.estimateGas({ from: account.freshAddress });
+  } else if (transaction.mode === "activate") {
+    const election = await kit.contracts.getElection();
+    const accounts = await kit.contracts.getAccounts();
+    const voteSignerAccount = await accounts.voteSignerToAccount(
+      account.freshAddress
+    );
+
+    const activates = await election.activate(voteSignerAccount);
+
+    const activate = activates.find(
+      (a) => a.txo.arguments[0] === transaction.recipient
+    );
+    if (!activate) return new BigNumber(0);
+
+    gas = await activate.txo.estimateGas({ from: account.freshAddress });
+  } else if (transaction.mode === "register") {
+    const accounts = await kit.contracts.getAccounts();
+
+    gas = await accounts
+      .createAccount()
+      .txo.estimateGas({ from: account.freshAddress });
+  } else {
+    const celoToken = await kit.contracts.getGoldToken();
+
+    const celoTransaction = {
+      from: account.freshAddress,
+      to: celoToken.address,
+      data: celoToken
+        .transfer(transaction.recipient, value.toFixed())
+        .txo.encodeABI(),
+    };
+
+    gas = await kit.connection.estimateGasWithInflationFactor(celoTransaction);
+  }
+
+  const gasPrice = new BigNumber(await kit.connection.gasPrice());
   return gasPrice.times(gas);
 };
 

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

@@ -1,4 +1,4 @@
-import { Transaction, TransactionStatus } from "./types";
+import { CeloAccount, Transaction, TransactionStatus } from "./types";
 import {
   AmountRequired,
   FeeNotLoaded,
@@ -9,10 +9,17 @@ import {
 } from "@ledgerhq/errors";
 import { BigNumber } from "bignumber.js";
 import { isValidAddress } from "@celo/utils/lib/address";
-import { Account } from "@ledgerhq/types-live";
+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: Account,
+  account: CeloAccount,
   transaction: Transaction
 ): Promise<TransactionStatus> => {
   const errors: any = {};
@@ -27,34 +34,82 @@ const getTransactionStatus = async (
     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 = useAllAmount
-    ? account.spendableBalance.minus(estimatedFees)
-    : new BigNumber(transaction.amount);
+  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 (amount.lte(0) && !transaction.useAllAmount) {
-    errors.amount = new AmountRequired();
+  if (
+    !errors.amount &&
+    (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 (amount.lte(0) && !useAllAmount) {
+      errors.amount = new AmountRequired();
+    }
   }
 
   const totalSpent = amount.plus(estimatedFees);
 
-  if (totalSpent.gt(account.spendableBalance)) {
-    errors.amount = new NotEnoughBalance();
+  if (transaction.mode === "unlock" || transaction.mode === "vote") {
+    if (totalNonVotingLockedBalance && amount.gt(totalNonVotingLockedBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  } else if (transaction.mode === "revoke") {
+    const revoke = getVote(account, transaction.recipient, transaction.index);
+    if (revoke?.amount && amount.gt(revoke.amount))
+      errors.amount = new NotEnoughBalance();
+  } else {
+    if (totalSpent.gt(totalSpendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
   }
 
-  if (!errors.amount && account.spendableBalance.lt(estimatedFees)) {
+  if (!errors.amount && totalSpendableBalance.lt(estimatedFees)) {
     errors.amount = new NotEnoughBalance();
   }
 
-  if (!transaction.recipient) {
-    errors.recipient = new RecipientRequired();
-  } else if (!isValidAddress(transaction.recipient)) {
-    errors.recipient = new InvalidAddress("", {
-      currencyName: account.currency.name,
-    });
+  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({

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

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

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

@@ -1,16 +1,29 @@
 import { BigNumber } from "bignumber.js";
 import { Observable } from "rxjs";
 import { FeeNotLoaded } from "@ledgerhq/errors";
-import type { Transaction } from "./types";
+import type { Transaction, CeloOperationMode, CeloAccount } 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",
+};
 import type {
   Account,
   Operation,
+  OperationType,
   SignOperationEvent,
 } from "@ledgerhq/types-live";
 
@@ -19,9 +32,13 @@ const buildOptimisticOperation = (
   transaction: Transaction,
   fee: BigNumber
 ): Operation => {
-  const type = "OUT";
+  const type = (MODE_TO_TYPE[transaction.mode] ??
+    MODE_TO_TYPE.default) as OperationType;
 
-  const value = new BigNumber(transaction.amount).plus(fee);
+  const value =
+    type === "OUT" || type === "LOCK"
+      ? new BigNumber(transaction.amount).plus(fee)
+      : new BigNumber(transaction.amount);
 
   const operation: Operation = {
     id: encodeOperationId(account.id, "", type),
@@ -35,7 +52,7 @@ const buildOptimisticOperation = (
     recipients: [transaction.recipient].filter(Boolean),
     accountId: account.id,
     date: new Date(),
-    extra: { additionalField: transaction.amount },
+    extra: {},
   };
 
   return operation;
@@ -94,7 +111,7 @@ const signOperation = ({
 
           const celo = new CeloApp(transport);
           const unsignedTransaction = await buildTransaction(
-            account,
+            account as CeloAccount,
             transaction
           );
           const { chainId, to } = unsignedTransaction;

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

@@ -2,10 +2,21 @@ 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",
@@ -19,7 +30,18 @@ const getAccountShape: GetAccountShape = async (info) => {
     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,
@@ -27,6 +49,16 @@ const getAccountShape: GetAccountShape = async (info) => {
     spendableBalance,
     operationsCount: operations.length,
     blockHeight,
+    celoResources: {
+      registrationStatus: accountRegistrationStatus,
+      lockedBalance,
+      nonvotingLockedBalance,
+      pendingWithdrawals,
+      votes,
+      electionAddress: election.address,
+      lockedGoldAddress: lockedGold.address,
+      maxNumGroupsVotedFor: electionConfig.maxNumGroupsVotedFor,
+    },
   };
   return { ...shape, operations };
 };

package/src/families/celo/logic.ts

@@ -0,0 +1,184 @@
+import {
+  CeloAccount,
+  CeloPendingWithdrawal,
+  CeloValidatorGroup,
+  CeloVote,
+  CeloVoteStatus,
+  PendingStakingOperationAmounts,
+} from "./types";
+import { BigNumber } from "bignumber.js";
+import { Operation } from "@ledgerhq/types-live";
+
+export const PRELOAD_MAX_AGE = 10 * 60 * 1000; // 10 minutes, used for max age in preload strategy
+const LEDGER_BY_FIGMENT_VALIDATOR_GROUP_ADDRESS =
+  "0x0861a61Bf679A30680510EcC238ee43B82C5e843";
+
+export const availablePendingWithdrawals = (
+  account: CeloAccount
+): CeloPendingWithdrawal[] => {
+  const { pendingWithdrawals } = account.celoResources || {};
+
+  return (pendingWithdrawals || []).filter(
+    (withdrawal) => new Date(withdrawal.time.toNumber() * 1000) < new Date()
+  );
+};
+
+export const withdrawableBalance = (account: CeloAccount): BigNumber =>
+  availablePendingWithdrawals(account).reduce(
+    (sum, withdrawal) => sum.plus(withdrawal.value),
+    new BigNumber(0)
+  );
+
+export const hasWithdrawableBalance = (account: CeloAccount): boolean =>
+  withdrawableBalance(account).isGreaterThan(0);
+
+export const defaultValidatorGroupAddress = (): string =>
+  LEDGER_BY_FIGMENT_VALIDATOR_GROUP_ADDRESS;
+
+export const isDefaultValidatorGroupAddress = (address: string): boolean =>
+  address === LEDGER_BY_FIGMENT_VALIDATOR_GROUP_ADDRESS;
+
+export const isDefaultValidatorGroup = (
+  validatorGroup: CeloValidatorGroup
+): boolean => isDefaultValidatorGroupAddress(validatorGroup.address);
+
+export const activatableVotes = (account: CeloAccount): CeloVote[] => {
+  const { votes } = account.celoResources || {};
+
+  return (votes || []).filter((vote) => vote.activatable);
+};
+
+export const hasActivatableVotes = (account: CeloAccount): boolean =>
+  activatableVotes(account).length > 0;
+
+export const revokableVotes = (account: CeloAccount): CeloVote[] => {
+  const { votes } = account.celoResources || {};
+
+  return (votes || []).filter((vote) => vote.revokable);
+};
+
+export const hasRevokableVotes = (account: CeloAccount): boolean =>
+  revokableVotes(account).length > 0;
+
+export const getVote = (
+  account: CeloAccount,
+  validatorGroupAddress: string,
+  index: number | null | undefined
+): CeloVote | undefined => {
+  const { votes } = account.celoResources || {};
+  return votes?.find(
+    (revoke) =>
+      revoke.validatorGroup === validatorGroupAddress && revoke.index == index
+  );
+};
+
+export const voteStatus = (vote: CeloVote): CeloVoteStatus =>
+  vote.type === "pending" && vote.activatable
+    ? "awaitingActivation"
+    : vote.type;
+
+export const fallbackValidatorGroup = (
+  address: string
+): CeloValidatorGroup => ({
+  address: address,
+  name: address,
+  votes: new BigNumber(0),
+});
+
+export const isAccountRegistrationPending = (
+  accountId: string,
+  accounts: CeloAccount[]
+): boolean => {
+  // If there's a pending "REGISTER" operation and the
+  // account's registration status is false, then
+  // we know that the account is truly not registered yet.
+  const account = accounts.find(
+    (currentAccount) => accountId === currentAccount.id
+  );
+
+  const isAccountRegistrationPending =
+    !!account &&
+    account.pendingOperations.some(
+      (currentAccount) => currentAccount.type === "REGISTER"
+    ) &&
+    !account.celoResources?.registrationStatus;
+
+  return isAccountRegistrationPending;
+};
+
+const isOperationTrulyPending = (
+  operation: Operation,
+  activeOperations: Operation[]
+): boolean => {
+  if (
+    activeOperations.some(
+      (activeOperation) => activeOperation.hash === operation.hash
+    )
+  ) {
+    return false;
+  }
+
+  return true;
+};
+
+const initialPendingStakingOperationAmounts: PendingStakingOperationAmounts = {
+  vote: new BigNumber(0),
+  lock: new BigNumber(0),
+};
+
+export const getPendingStakingOperationAmounts = (
+  account: CeloAccount
+): PendingStakingOperationAmounts => {
+  const operationAmounts = account.pendingOperations.reduce(
+    (acc, currentOperation) => {
+      if (
+        currentOperation.type !== "VOTE" &&
+        currentOperation.type !== "LOCK"
+      ) {
+        return acc;
+      }
+      if (isOperationTrulyPending(currentOperation, account.operations)) {
+        const value = new BigNumber(currentOperation.value);
+        switch (currentOperation.type) {
+          case "VOTE":
+            return {
+              ...acc,
+              vote: acc.vote.plus(value),
+            };
+          case "LOCK":
+            return {
+              ...acc,
+              lock: acc.lock.plus(value),
+            };
+        }
+      }
+
+      return acc;
+    },
+    initialPendingStakingOperationAmounts
+  );
+
+  return operationAmounts;
+};
+
+const getValidatorGroupsByVotingActivity = (
+  validatorGroups: CeloValidatorGroup[],
+  votes: CeloVote[],
+  withVotes: boolean
+): CeloValidatorGroup[] => {
+  return validatorGroups.filter(
+    (v) => votes.some((d) => d.validatorGroup === v.address) === withVotes
+  );
+};
+
+export const getValidatorGroupsWithVotes = (
+  validatorGroups: CeloValidatorGroup[],
+  votes: CeloVote[] | null
+): CeloValidatorGroup[] =>
+  getValidatorGroupsByVotingActivity(validatorGroups, votes || [], true);
+
+export const getValidatorGroupsWithoutVotes = (
+  validatorGroups: CeloValidatorGroup[],
+  votes: CeloVote[] | null = []
+): CeloValidatorGroup[] =>
+  getValidatorGroupsByVotingActivity(validatorGroups, votes || [], false);