@ledgerhq/live-common 27.0.1-next.0 → 27.1.0-next.2

package/src/families/celo/datasets/celo.scanAccounts.1.ts

@@ -1,20 +1,380 @@
-import type { CurrenciesData } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+} from "@ledgerhq/errors";
+import "../../../__tests__/test-helpers/setup";
+import TransactionModule from "../transaction";
+import { CeloAllFundsWarning } from "../errors";
+import type {
+  AccountRaw,
+  CurrenciesData,
+  TransactionStatusCommon,
+} from "@ledgerhq/types-live";
 import type { Transaction } from "../types";
 
+// This account is registered for staking and has available funds, locked voting funds,
+// locked non-voting funds, and withdrawable funds.
+const LEDGER_CELO_ACCOUNT_1 = "0xcfD48e0FAf9f19377509cE68a6A6F4D9C85ff8AB";
+// This account has no funds and isn't registered for staking.
+const LEDGER_CELO_ACCOUNT_2 = "0x2cC7E5913bADa8FA2895bDeF7F4C2E36C2368Abb";
+const VALIDATOR_ACCOUNT_1 = "0x0861a61Bf679A30680510EcC238ee43B82C5e843";
+
 const dataset: CurrenciesData<Transaction> = {
   scanAccounts: [
     {
-      name: "celo seed 1",
+      name: "Celo 1",
       apdus: `
       => e00200000d038000002c8000ce1080000000
-      <= 41040bd7f9f57b882469eeace7c1b393563e5e1748be7717620a406b4f2d9a01514fe50fcb3366435a99ac21b4f7a807a6ca99782cdb0cb082c49fa6110eb385cadc28336533343162333437436245336232413131363765303643383461366233383543413343396634319000
+      <= 410453390dcc1e6f1be0fb34f837b278ed1b4c84097c7493c13a0d915c735af1d8aa445d2738a95e8f50bc22abd2e17cb868d4db22a623d99d861740eb93373d50a328383735443736394535333337363338363732386136374632463564326435666561374637356233399000
       => e002000015058000002c8000ce10800000000000000000000000
-      <= 4104d2705d8760cc776edeaef9a99895bcce6e9f19de51640aecf5dcf58be2eca4b9c95882a52c5525b838e69e2b719a6677dfb832b1c0a3f106c303412789621cc928314335443942343735303565314338653432433644443144314435623730423065664334324241309000
+      <= 4104eedca4417737f2dae0e12320edba0e845e4ced411e6e2978a9165dde3891099402ff4906ecaab03232f8273592287a94866f14f17b5e2bf6e31837278127919c28636644343865304641663966313933373735303963453638613641364634443943383566663841429000
       => e002000015058000002c8000ce10800000010000000000000000
-      <= 41040699e39aa6ee84133dec1f0346f95516ace36d521764823624a2bf0bdfd97bd4b3ddd8f42b08ba251a53ef25a0f658de9fbb57600d2165dab69d10ebf34388a928336337383462383934343964413330313443356261654532374232326263313833343746314639629000
+      <= 41042304dfd28a236eb03471986b90f0a3a111537b35766ae8ff78a9f588071f56ec127531a2498b36e856c759bc2734297a07f9f4b331153a8c9c21171f6488884e28326343374535393133624144613846413238393562446546374634433245333643323336384162629000
       `,
     },
   ],
+  accounts: [
+    {
+      // Ignoring the "balance is sum of ops" test since that
+      // doesn't seem to take into account staked tokens properly.
+      FIXME_tests: ["balance is sum of ops"],
+      raw: {
+        id: `js:2:celo:${LEDGER_CELO_ACCOUNT_1}:`,
+        seedIdentifier:
+          "0453390dcc1e6f1be0fb34f837b278ed1b4c84097c7493c13a0d915c735af1d8aa445d2738a95e8f50bc22abd2e17cb868d4db22a623d99d861740eb93373d50a3",
+        name: "Celo 1",
+        derivationMode: "",
+        index: 0,
+        freshAddress: LEDGER_CELO_ACCOUNT_1,
+        freshAddressPath: "44'/52752'/0'/0/0",
+        freshAddresses: [],
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "celo",
+        unitMagnitude: 18,
+        lastSyncDate: "",
+        balance: "399893159500000000",
+        celoResources: {
+          registrationStatus: true,
+          lockedBalance: "1000000",
+          nonvotingLockedBalance: "900000",
+          pendingWithdrawals: [],
+          votes: [
+            {
+              validatorGroup: VALIDATOR_ACCOUNT_1,
+              amount: "100000",
+              activatable: true,
+              revokable: true,
+              type: "active",
+              index: 0,
+            },
+          ],
+          electionAddress: "0x8D6677192144292870907E3Fa8A5527fE55A7ff6",
+          lockedGoldAddress: "0x6cC083Aed9e3ebe302A6336dBC7c921C9f03349E",
+        },
+      } as AccountRaw,
+      transactions: [
+        {
+          name: "Same as Recipient",
+          transaction: (t) => ({
+            ...t,
+            amount: new BigNumber(100),
+            recipient: LEDGER_CELO_ACCOUNT_1,
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Invalid Address",
+          transaction: (t) => ({
+            ...t,
+            amount: new BigNumber(100),
+            recipient: "dsadasdasdasdas",
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new InvalidAddress(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Amount Required",
+          transaction: TransactionModule.fromTransactionRaw({
+            family: "celo",
+            recipient: LEDGER_CELO_ACCOUNT_2,
+            amount: "0",
+            mode: "send",
+            fees: null,
+            index: 0,
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new AmountRequired(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Not enough balance",
+          transaction: TransactionModule.fromTransactionRaw({
+            family: "celo",
+            recipient: LEDGER_CELO_ACCOUNT_2,
+            amount: "399893159500000005",
+            mode: "send",
+            fees: null,
+            index: 0,
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "[send] use all amount - should warn all funds",
+          transaction: (t) => ({
+            ...t,
+            useAllAmount: true,
+            mode: "send",
+            recipient: LEDGER_CELO_ACCOUNT_2,
+          }),
+          expectedStatus: (account) => ({
+            errors: {},
+            warnings: {
+              amount: new CeloAllFundsWarning(),
+            },
+            totalSpent: account.spendableBalance,
+          }),
+        },
+        {
+          name: "Lock - success",
+          transaction: (t) => ({
+            ...t,
+            mode: "lock",
+            amount: new BigNumber(5000),
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {},
+              warnings: {},
+              amount: new BigNumber(5000),
+            };
+          },
+        },
+        {
+          name: "Unlock - success",
+          transaction: (t) => ({
+            ...t,
+            mode: "unlock",
+            amount: new BigNumber(50000),
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {},
+              warnings: {},
+              amount: new BigNumber(50000),
+            };
+          },
+        },
+        {
+          name: "Lock - amount required",
+          transaction: (t) => ({
+            ...t,
+            mode: "lock",
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {
+                amount: new AmountRequired(),
+              },
+              warnings: {},
+            };
+          },
+        },
+        {
+          name: "Unlock - amount required",
+          transaction: (t) => ({
+            ...t,
+            mode: "unlock",
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {
+                amount: new AmountRequired(),
+              },
+              warnings: {},
+            };
+          },
+        },
+        {
+          name: "Unlock - Not enough balance",
+          transaction: (t) => ({
+            ...t,
+            mode: "unlock",
+            amount: new BigNumber(200000000000000000),
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {
+                amount: new NotEnoughBalance(),
+              },
+              warnings: {},
+            };
+          },
+        },
+        {
+          name: "Vote - success",
+          transaction: (t) => ({
+            ...t,
+            mode: "vote",
+            useAllAmount: true,
+            recipient: VALIDATOR_ACCOUNT_1,
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {},
+              warnings: {},
+              amount: new BigNumber(100000000000000000),
+            };
+          },
+        },
+        {
+          name: "Vote - Not enough balance",
+          transaction: (t) => ({
+            ...t,
+            mode: "vote",
+            recipient: VALIDATOR_ACCOUNT_1,
+            amount: new BigNumber(200000000000000000),
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {
+                amount: new NotEnoughBalance(),
+              },
+              warnings: {},
+            };
+          },
+        },
+        {
+          name: "Activate Vote - success",
+          transaction: (t) => ({
+            ...t,
+            mode: "activate",
+            recipient: VALIDATOR_ACCOUNT_1,
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {},
+              warnings: {},
+            };
+          },
+        },
+        {
+          name: "Revoke Vote - success",
+          transaction: (t) => ({
+            ...t,
+            mode: "revoke",
+            recipient: VALIDATOR_ACCOUNT_1,
+            amount: new BigNumber(9000000),
+            index: 0,
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {},
+              warnings: {},
+            };
+          },
+        },
+        {
+          name: "Revoke Vote - Not enough balance",
+          transaction: (t) => ({
+            ...t,
+            mode: "revoke",
+            recipient: VALIDATOR_ACCOUNT_1,
+            amount: new BigNumber(20000000000000000000),
+            index: 0,
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {
+                amount: new NotEnoughBalance(),
+              },
+              warnings: {},
+            };
+          },
+        },
+        {
+          name: "Revoke Vote - voted amount should be used when revoke amount is set",
+          transaction: (t) => ({
+            ...t,
+            mode: "revoke",
+            recipient: VALIDATOR_ACCOUNT_1,
+            useAllAmount: true,
+            index: 0,
+          }),
+          expectedStatus: (): Partial<TransactionStatusCommon> => {
+            return {
+              errors: {},
+              warnings: {},
+            };
+          },
+        },
+      ],
+    },
+    {
+      FIXME_tests: ["balance is sum of ops"],
+      raw: {
+        id: `js:2:celo:${LEDGER_CELO_ACCOUNT_2}:`,
+        seedIdentifier:
+          "0453390dcc1e6f1be0fb34f837b278ed1b4c84097c7493c13a0d915c735af1d8aa445d2738a95e8f50bc22abd2e17cb868d4db22a623d99d861740eb93373d50a3",
+        name: "Celo 1",
+        derivationMode: "",
+        index: 0,
+        freshAddress: LEDGER_CELO_ACCOUNT_2,
+        freshAddressPath: "44'/52752'/0'/0/0",
+        freshAddresses: [],
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "celo",
+        unitMagnitude: 18,
+        lastSyncDate: "",
+        balance: "399893159500000000",
+        celoResources: {
+          registrationStatus: false,
+          lockedBalance: "0",
+          nonvotingLockedBalance: "0",
+          pendingWithdrawals: [],
+          votes: [],
+          electionAddress: "0x8D6677192144292870907E3Fa8A5527fE55A7ff6",
+          lockedGoldAddress: "0x6cC083Aed9e3ebe302A6336dBC7c921C9f03349E",
+        },
+      } as AccountRaw,
+      transactions: [
+        {
+          name: "Register Account - success",
+          transaction: (t) => ({
+            ...t,
+            mode: "register",
+          }),
+          expectedStatus: {
+            errors: {},
+            warnings: {},
+          },
+        },
+      ],
+    },
+  ],
 };
 
 export default dataset;

package/src/families/celo/errors.ts

@@ -0,0 +1,5 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const CeloAllFundsWarning = createCustomErrorClass(
+  "CeloAllFundsWarning"
+);

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

@@ -1,32 +1,185 @@
-import type { Transaction } from "./types";
+import type { CeloAccount, Transaction } from "./types";
 import { CeloTx } from "@celo/connect";
 import { celoKit } from "./api/sdk";
-import { Account } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { getPendingStakingOperationAmounts, getVote } from "./logic";
 
-const buildTransaction = async (account: Account, transaction: Transaction) => {
+const buildTransaction = async (
+  account: CeloAccount,
+  transaction: Transaction
+) => {
   const kit = celoKit();
-  const { amount } = transaction;
-  const value = transaction.useAllAmount
-    ? account.spendableBalance.minus(transaction.fees || 0)
-    : amount;
-
-  const celoToken = await kit.contracts.getGoldToken();
-
-  const celoTransaction = {
-    from: account.freshAddress,
-    to: celoToken.address,
-    data: celoToken
-      .transfer(transaction.recipient, value.toFixed())
-      .txo.encodeABI(),
-  };
 
-  return {
+  const value = transactionValue(account, transaction);
+
+  let celoTransaction: CeloTx;
+
+  if (transaction.mode === "lock") {
+    const lockedGold = await kit.contracts.getLockedGold();
+    celoTransaction = {
+      from: account.freshAddress,
+      value: value.toFixed(),
+      to: lockedGold.address,
+      data: lockedGold.lock().txo.encodeABI(),
+      gas: await lockedGold.lock().txo.estimateGas({
+        from: account.freshAddress,
+        value: value.toFixed(),
+      }),
+    };
+  } else if (transaction.mode === "unlock") {
+    const lockedGold = await kit.contracts.getLockedGold();
+    celoTransaction = {
+      from: account.freshAddress,
+      to: lockedGold.address,
+      data: lockedGold.unlock(value).txo.encodeABI(),
+      gas: await lockedGold.unlock(value).txo.estimateGas({
+        from: account.freshAddress,
+      }),
+    };
+  } else if (transaction.mode === "withdraw") {
+    const lockedGold = await kit.contracts.getLockedGold();
+
+    celoTransaction = {
+      from: account.freshAddress,
+      to: lockedGold.address,
+      data: lockedGold.withdraw(transaction.index || 0).txo.encodeABI(),
+      gas: await lockedGold.withdraw(transaction.index || 0).txo.estimateGas({
+        from: account.freshAddress,
+        value: value.toFixed(),
+      }),
+    };
+  } else if (transaction.mode === "vote") {
+    const election = await kit.contracts.getElection();
+    const vote = await election.vote(
+      transaction.recipient,
+      new BigNumber(value)
+    );
+
+    celoTransaction = {
+      from: account.freshAddress,
+      to: election.address,
+      data: vote.txo.encodeABI(),
+      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 revokes = await election.revoke(
+      voteSignerAccount,
+      transaction.recipient,
+      new BigNumber(value)
+    );
+
+    const revoke = revokes.find((transactionObject) => {
+      return (
+        (transactionObject.txo as any)._method.name ===
+        (transaction.index === 0 ? "revokePending" : "revokeActive")
+      );
+    });
+    if (!revoke) throw new Error("No votes to revoke");
+
+    celoTransaction = {
+      from: account.freshAddress,
+      to: election.address,
+      data: revoke.txo.encodeABI(),
+      gas: await revoke.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) throw new Error("No votes to activate");
+
+    celoTransaction = {
+      from: account.freshAddress,
+      to: election.address,
+      data: activate.txo.encodeABI(),
+      gas: await activate.txo.estimateGas({
+        from: account.freshAddress,
+      }),
+    };
+  } else if (transaction.mode === "register") {
+    const accounts = await kit.contracts.getAccounts();
+    celoTransaction = {
+      from: account.freshAddress,
+      to: accounts.address,
+      data: accounts.createAccount().txo.encodeABI(),
+      gas: await accounts
+        .createAccount()
+        .txo.estimateGas({ from: account.freshAddress }),
+    };
+  } else {
+    // Send
+    const celoToken = await kit.contracts.getGoldToken();
+    celoTransaction = {
+      from: account.freshAddress,
+      to: celoToken.address,
+      data: celoToken
+        .transfer(transaction.recipient, value.toFixed())
+        .txo.encodeABI(),
+    };
+
+    const gas = await kit.connection.estimateGasWithInflationFactor(
+      celoTransaction
+    );
+
+    celoTransaction = {
+      ...celoTransaction,
+      gas,
+    };
+  }
+  const tx: CeloTx = {
     ...celoTransaction,
     chainId: await kit.connection.chainId(),
     nonce: await kit.connection.nonce(account.freshAddress),
-    gas: await kit.connection.estimateGasWithInflationFactor(celoTransaction),
     gasPrice: await kit.connection.gasPrice(),
-  } as CeloTx;
+  };
+
+  return tx;
+};
+
+const transactionValue = (
+  account: CeloAccount,
+  transaction: Transaction
+): BigNumber => {
+  let value = transaction.amount;
+
+  if (transaction.useAllAmount) {
+    if (
+      (transaction.mode === "unlock" || transaction.mode === "vote") &&
+      account.celoResources
+    ) {
+      // Deduct the amount of pending vote transactions from
+      // the total non-voting locked balance to get the true non-voting locked balance.
+      const pendingOperationAmounts =
+        getPendingStakingOperationAmounts(account);
+      const pendingOperationAmount =
+        transaction.mode === "vote"
+          ? pendingOperationAmounts.vote
+          : new BigNumber(0);
+      value = account.celoResources.nonvotingLockedBalance.minus(
+        pendingOperationAmount
+      );
+    } else if (transaction.mode === "revoke" && account.celoResources) {
+      const revoke = getVote(account, transaction.recipient, transaction.index);
+      if (revoke?.amount) value = revoke.amount;
+    } else {
+      value = account.spendableBalance.minus(transaction.fees || 0);
+    }
+  }
+
+  return value;
 };
 
 export default buildTransaction;

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

@@ -7,6 +7,8 @@ const createTransaction = (): Transaction => ({
   recipient: "",
   useAllAmount: false,
   fees: null,
+  mode: "send",
+  index: null,
 });
 
 export default createTransaction;

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

@@ -1,4 +1,4 @@
-import { Transaction } from "./types";
+import { CeloAccount, Transaction } from "./types";
 import { BigNumber } from "bignumber.js";
 import { getMainAccount } from "../../account";
 import getTransactionStatus from "./js-getTransactionStatus";
@@ -15,7 +15,7 @@ const estimateMaxSpendable = async ({
   parentAccount: Account;
   transaction: Transaction;
 }): Promise<BigNumber> => {
-  const mainAccount = getMainAccount(account, parentAccount);
+  const mainAccount = getMainAccount(account, parentAccount) as CeloAccount;
   const t = await prepareTransaction(mainAccount, {
     ...createTransaction(),
     ...transaction,