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

package/src/families/celo/preload.ts

@@ -0,0 +1,78 @@
+import { BigNumber } from "bignumber.js";
+import { Observable, Subject } from "rxjs";
+import { log } from "@ledgerhq/logs";
+import { PRELOAD_MAX_AGE } from "./logic";
+import type { CeloPreloadData, CeloValidatorGroup } from "./types";
+import { getValidatorGroups } from "./validators";
+
+let currentCeloPreloadedData: CeloPreloadData = {
+  validatorGroups: [],
+};
+
+function fromHydrateValidator(
+  validatorGroupRaw: Record<string, any>
+): CeloValidatorGroup {
+  return {
+    address: validatorGroupRaw.address,
+    name: validatorGroupRaw.name,
+    votes: new BigNumber(validatorGroupRaw.votes),
+  };
+}
+
+function fromHydratePreloadData(data: any): CeloPreloadData {
+  let validatorGroups = [];
+  if (typeof data === "object" && data) {
+    if (Array.isArray(data.validatorGroups)) {
+      validatorGroups = data.validatorGroups.map(fromHydrateValidator);
+    }
+  }
+
+  return {
+    validatorGroups,
+  };
+}
+
+const updates = new Subject<CeloPreloadData>();
+export function getCurrentCeloPreloadData(): CeloPreloadData {
+  return currentCeloPreloadedData;
+}
+function setCeloPreloadData(data: CeloPreloadData) {
+  if (data === currentCeloPreloadedData) return;
+  currentCeloPreloadedData = data;
+  updates.next(data);
+}
+export function getCeloPreloadDataUpdates(): Observable<CeloPreloadData> {
+  return updates.asObservable();
+}
+
+export const getPreloadStrategy = () => ({
+  preloadMaxAge: PRELOAD_MAX_AGE,
+});
+
+export const preload = async (): Promise<CeloPreloadData> => {
+  const { validatorGroups: previousValidatorGroups } = currentCeloPreloadedData;
+  let validatorGroups = previousValidatorGroups;
+
+  if (!validatorGroups || !validatorGroups.length) {
+    log("celo/preload", "refreshing celo validatorGroups...");
+
+    try {
+      validatorGroups = await getValidatorGroups();
+    } catch (error) {
+      log("celo/preload", "failed to fetch validatorGroups", {
+        error,
+      });
+    }
+  }
+
+  return { validatorGroups };
+};
+
+export const hydrate = (data: unknown) => {
+  const hydrated = fromHydratePreloadData(data);
+  log(
+    "celo/preload",
+    "hydrate " + hydrated.validatorGroups.length + " celo validatorGroups"
+  );
+  setCeloPreloadData(hydrated);
+};

package/src/families/celo/react.ts

@@ -0,0 +1,35 @@
+import { useState, useEffect, useMemo } from "react";
+import {
+  getCurrentCeloPreloadData,
+  getCeloPreloadDataUpdates,
+} from "./preload";
+import type { CeloPreloadData, CeloValidatorGroup } from "./types";
+
+export function useCeloPreloadData(): CeloPreloadData {
+  const [state, setState] = useState(getCurrentCeloPreloadData);
+  useEffect(() => {
+    const sub = getCeloPreloadDataUpdates().subscribe((data) => {
+      setState(data);
+    });
+    return () => sub.unsubscribe();
+  }, []);
+  return state;
+}
+
+export function useValidatorGroups(search: string): CeloValidatorGroup[] {
+  const { validatorGroups } = useCeloPreloadData();
+
+  return useMemo(() => {
+    if (validatorGroups.length === 0 || !search) {
+      return validatorGroups;
+    }
+
+    const lowercaseSearch = search.toLowerCase();
+
+    return validatorGroups.filter(
+      (vg) =>
+        vg.name.toLowerCase().includes(lowercaseSearch) ||
+        vg.address.toLowerCase().includes(lowercaseSearch)
+    );
+  }, [validatorGroups, search]);
+}

package/src/families/celo/serialization.ts

@@ -0,0 +1,61 @@
+// @flow
+import type { CeloResources, CeloResourcesRaw } from "./types";
+import { BigNumber } from "bignumber.js";
+
+export function toCeloResourcesRaw(r: CeloResources): CeloResourcesRaw {
+  const {
+    registrationStatus,
+    lockedBalance,
+    nonvotingLockedBalance,
+    pendingWithdrawals,
+    votes,
+    electionAddress,
+    lockedGoldAddress,
+    maxNumGroupsVotedFor,
+  } = r ?? {};
+  return {
+    registrationStatus,
+    lockedBalance: lockedBalance?.toString(),
+    nonvotingLockedBalance: nonvotingLockedBalance?.toString(),
+    pendingWithdrawals: pendingWithdrawals?.map((withdrawal) => ({
+      value: withdrawal.value.toString(),
+      time: withdrawal.time.toString(),
+      index: withdrawal.index.toString(),
+    })),
+    votes: votes?.map((vote) => ({
+      validatorGroup: vote.validatorGroup.toString(),
+      amount: vote.amount.toString(),
+      activatable: vote.activatable,
+      revokable: vote.revokable,
+      type: vote.type,
+      index: vote.index,
+    })),
+    electionAddress,
+    lockedGoldAddress,
+    maxNumGroupsVotedFor: maxNumGroupsVotedFor?.toString(),
+  };
+}
+
+export function fromCeloResourcesRaw(r: CeloResourcesRaw): CeloResources {
+  return {
+    registrationStatus: r.registrationStatus,
+    lockedBalance: new BigNumber(r.lockedBalance),
+    nonvotingLockedBalance: new BigNumber(r.nonvotingLockedBalance),
+    pendingWithdrawals: r.pendingWithdrawals?.map((u) => ({
+      value: new BigNumber(u.value),
+      time: new BigNumber(u.time),
+      index: Number(u.index),
+    })),
+    votes: r.votes?.map((vote) => ({
+      validatorGroup: vote.validatorGroup,
+      amount: new BigNumber(vote.amount),
+      activatable: vote.activatable,
+      revokable: vote.revokable,
+      type: vote.type,
+      index: vote.index,
+    })),
+    electionAddress: r.electionAddress,
+    lockedGoldAddress: r.lockedGoldAddress,
+    maxNumGroupsVotedFor: new BigNumber(r.maxNumGroupsVotedFor),
+  };
+}

package/src/families/celo/specs/createActivateVoteMutation.ts

@@ -0,0 +1,44 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../../currencies";
+import { MutationSpec } from "../../../bot/types";
+import type { CeloAccount, Transaction } from "../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createActivateVoteMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Activate Vote",
+  maxRun: 5,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    const { celoResources } = account as CeloAccount;
+    invariant(
+      celoResources?.registrationStatus,
+      "Celo: Activate Vote | Account is not registered"
+    );
+    invariant(
+      maxSpendable.gt(minimalAmount),
+      "Celo:  Activate Vote | balance is too low"
+    );
+
+    const activatableVote = celoResources?.votes?.find(
+      (vote) => vote.activatable
+    );
+
+    invariant(!!activatableVote, "Celo: Activate Vote | No activatable votes");
+
+    const transaction = {
+      recipient: activatableVote!.validatorGroup,
+    };
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          memo: "LedgerLiveBot",
+          mode: "activate",
+        },
+        transaction,
+      ],
+    };
+  },
+});

package/src/families/celo/specs/createLockMutation.ts

@@ -0,0 +1,46 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../../currencies";
+import { MutationSpec } from "../../../bot/types";
+import type { CeloAccount, Transaction } from "../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.005");
+
+export const createLockMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Lock",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    const { celoResources } = account as CeloAccount;
+    invariant(
+      celoResources?.registrationStatus,
+      "Celo: Lock Vote | Account is not registered"
+    );
+
+    invariant(
+      maxSpendable.gt(minimalAmount),
+      "Celo:  Lock | balance is too low"
+    );
+
+    const amount = minimalAmount
+      .times(Math.random())
+      .integerValue()
+      .precision(8);
+
+    invariant(amount.gt(0), "Celo: Lock | Not enough funds to lock tokens");
+
+    const transaction = {
+      amount,
+    };
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          memo: "LedgerLiveBot",
+          mode: "lock",
+        },
+        transaction,
+      ],
+    };
+  },
+});

package/src/families/celo/specs/createRegisterAccountMutation.ts

@@ -0,0 +1,34 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../../currencies";
+import { MutationSpec } from "../../../bot/types";
+import type { CeloAccount, Transaction } from "../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createRegisterAccountMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Register Account",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    const { celoResources } = account as CeloAccount;
+
+    invariant(
+      !celoResources?.registrationStatus,
+      "Celo: Register Account | Celo account is already registered"
+    );
+    invariant(
+      maxSpendable.gt(minimalAmount),
+      "Celo: Register Account | Celo account balance is too low to register account"
+    );
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          memo: "LedgerLiveBot",
+          mode: "register",
+        },
+      ],
+    };
+  },
+});

package/src/families/celo/specs/createRevokeVoteMutation.ts

@@ -0,0 +1,43 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../../currencies";
+import { MutationSpec } from "../../../bot/types";
+import type { CeloAccount, Transaction } from "../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createRevokeVoteMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: RevokeVote",
+  maxRun: 5,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    invariant(
+      maxSpendable.gt(minimalAmount),
+      "Celo:  Revoke Vote | balance is too low"
+    );
+
+    const { celoResources } = account as CeloAccount;
+    invariant(
+      celoResources?.registrationStatus,
+      "Celo: RevokeVote | Account is not registered"
+    );
+
+    const revokableVote = celoResources?.votes?.find((vote) => vote.revokable);
+
+    invariant(!!revokableVote, "Celo: RevokeVote |  Revokable vote not found");
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          memo: "LedgerLiveBot",
+          mode: "revoke",
+          recipient: revokableVote!.validatorGroup,
+          group: revokableVote!.validatorGroup,
+          address: (account as CeloAccount).celoResources?.electionAddress,
+          index: revokableVote!.index,
+          amount: revokableVote!.amount,
+        },
+      ],
+    };
+  },
+});

package/src/families/celo/specs/createSendMutation.ts

@@ -0,0 +1,44 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../../currencies";
+import { pickSiblings } from "../../../bot/specs";
+import { MutationSpec } from "../../../bot/types";
+import type { Transaction } from "../types";
+
+const maxAccount = 3;
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createSend50PercentMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Move 50% to another account",
+  maxRun: 1,
+  transaction: ({ account, siblings, bridge, maxSpendable }) => {
+    invariant(
+      maxSpendable.gt(minimalAmount),
+      "Celo:  Move 50% | balance is too low"
+    );
+    const sibling = pickSiblings(siblings, maxAccount);
+    const recipient = sibling.freshAddress;
+    const amount = maxSpendable.div(2).integerValue();
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [{ recipient }, { amount }],
+    };
+  },
+});
+
+export const createSendMaxMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Send max to another account",
+  maxRun: 1,
+  transaction: ({ account, siblings, bridge, maxSpendable }) => {
+    invariant(
+      maxSpendable.gt(minimalAmount),
+      "Celo: Send Max | Balance is too low"
+    );
+    const sibling = pickSiblings(siblings, maxAccount);
+    const recipient = sibling.freshAddress;
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [{ recipient }, { useAllAmount: true }],
+    };
+  },
+});

package/src/families/celo/specs/createUnlockMutation.ts

@@ -0,0 +1,44 @@
+import invariant from "invariant";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../../currencies";
+import { MutationSpec } from "../../../bot/types";
+import type { CeloAccount, Transaction } from "../types";
+import BigNumber from "bignumber.js";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createUnlockMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Unlock",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    invariant(
+      maxSpendable.gt(minimalAmount),
+      "Celo:  Unlock | balance is too low"
+    );
+
+    const { celoResources } = account as CeloAccount;
+    invariant(
+      celoResources?.registrationStatus,
+      "Celo: Unlock | Account is not registered"
+    );
+    const nonvotingLockedBalance =
+      celoResources?.nonvotingLockedBalance || new BigNumber(0);
+    invariant(
+      nonvotingLockedBalance.gt(0),
+      "Celo: Unlock | No non voting locked balance"
+    );
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          memo: "LedgerLiveBot",
+          mode: "unlock",
+        },
+        {
+          amount: nonvotingLockedBalance.dividedBy(2).integerValue(),
+        },
+      ],
+    };
+  },
+});

package/src/families/celo/specs/createVoteMutation.ts

@@ -0,0 +1,67 @@
+import invariant from "invariant";
+import BigNumber from "bignumber.js";
+import sampleSize from "lodash/sampleSize";
+import { MutationSpec } from "../../../bot/types";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../../currencies";
+import { getCurrentCeloPreloadData } from "../preload";
+import { getValidatorGroupsWithoutVotes } from "../logic";
+import type { CeloAccount, CeloResources, Transaction } from "../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createVoteMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Vote",
+  maxRun: 1,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    invariant(
+      maxSpendable.gt(minimalAmount),
+      "Celo:  Vote | balance is too low"
+    );
+
+    const { celoResources } = account as CeloAccount;
+    invariant(
+      celoResources?.registrationStatus,
+      "Celo: Vote | Account is not registered"
+    );
+
+    const nonvotingLockedBalance =
+      celoResources?.nonvotingLockedBalance || new BigNumber(0);
+    invariant(
+      nonvotingLockedBalance.gt(0),
+      "Celo: Vote | No non voting locked balance"
+    );
+
+    const votes = (celoResources as CeloResources).votes || [];
+    const { validatorGroups } = getCurrentCeloPreloadData();
+
+    // Get a random validator group that the account does not have locked tokens for.
+    const validatorGroupWithoutVotes = sampleSize(
+      getValidatorGroupsWithoutVotes(validatorGroups, votes),
+      1
+    )[0];
+
+    const amount = nonvotingLockedBalance
+      .times(0.5)
+      .precision(8)
+      .integerValue();
+
+    invariant(amount.gt(0), "Celo: Vote | Not enough funds to vote");
+
+    const transaction = {
+      recipient: validatorGroupWithoutVotes.address,
+      amount,
+    };
+
+    return {
+      transaction: bridge.createTransaction(account),
+      updates: [
+        {
+          memo: "LedgerLiveBot",
+          mode: "vote",
+        },
+        transaction,
+      ],
+    };
+  },
+});

package/src/families/celo/specs/createWithdrawMutation.ts

@@ -0,0 +1,44 @@
+import invariant from "invariant";
+import { MutationSpec } from "../../../bot/types";
+import { getCryptoCurrencyById, parseCurrencyUnit } from "../../../currencies";
+import { availablePendingWithdrawals } from "../logic";
+import type { CeloAccount, Transaction } from "../types";
+
+const currency = getCryptoCurrencyById("celo");
+const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
+
+export const createWithdrawMutation = (): MutationSpec<Transaction> => ({
+  name: "Celo: Withdraw",
+  maxRun: 5,
+  transaction: ({ account, bridge, maxSpendable }) => {
+    const celoAccount = account as CeloAccount;
+    const { celoResources } = celoAccount;
+    invariant(
+      celoResources?.registrationStatus,
+      "Celo: Withdraw | Account is not registered"
+    );
+
+    const pendingWithdrawals = availablePendingWithdrawals(celoAccount);
+
+    invariant(
+      pendingWithdrawals.length > 0,
+      "Celo: Withdraw | No withdrawable balance"
+    );
+
+    invariant(
+      maxSpendable.gt(minimalAmount),
+      "Celo:  Withdraw Vote | balance is too low"
+    );
+
+    return {
+      transaction: bridge.createTransaction(celoAccount),
+      updates: [
+        {
+          mode: "withdraw",
+          recipient: celoAccount.celoResources!.lockedGoldAddress!,
+          index: pendingWithdrawals[0].index,
+        },
+      ],
+    };
+  },
+});

package/src/families/celo/specs/index.ts

@@ -0,0 +1,8 @@
+export * from "./createSendMutation";
+export * from "./createLockMutation";
+export * from "./createUnlockMutation";
+export * from "./createRegisterAccountMutation";
+export * from "./createVoteMutation";
+export * from "./createActivateVoteMutation";
+export * from "./createRevokeVoteMutation";
+export * from "./createWithdrawMutation";

package/src/families/celo/specs.ts

@@ -1,14 +1,30 @@
-import invariant from "invariant";
-import type { Transaction } from "./types";
-import { getCryptoCurrencyById, parseCurrencyUnit } from "../../currencies";
-import { pickSiblings } from "../../bot/specs";
-import type { AppSpec } from "../../bot/types";
 import { DeviceModelId } from "@ledgerhq/devices";
+import { getCryptoCurrencyById } from "../../currencies";
+import {
+  createLockMutation,
+  createRegisterAccountMutation,
+  createSend50PercentMutation,
+  createSendMaxMutation,
+  createUnlockMutation,
+  createVoteMutation,
+  createActivateVoteMutation,
+  createRevokeVoteMutation,
+  createWithdrawMutation,
+} from "./specs/index";
+import type { AppSpec } from "../../bot/types";
+import type { Transaction } from "./types";
 import { acceptTransaction } from "./speculos-deviceActions";
 
 const currency = getCryptoCurrencyById("celo");
-const minimalAmount = parseCurrencyUnit(currency.units[0], "0.001");
-const maxAccount = 3;
+const send50PercentMutation = createSend50PercentMutation();
+const sendMaxMutation = createSendMaxMutation();
+const registerAccountMutation = createRegisterAccountMutation();
+const unlockMutation = createUnlockMutation();
+const lockMutation = createLockMutation();
+const voteMutation = createVoteMutation();
+const activateVoteMutation = createActivateVoteMutation();
+const revokeVoteMutation = createRevokeVoteMutation();
+const withdrawMutation = createWithdrawMutation();
 
 const celo: AppSpec<Transaction> = {
   name: "Celo",
@@ -20,33 +36,15 @@ const celo: AppSpec<Transaction> = {
   testTimeout: 2 * 60 * 1000,
   genericDeviceAction: acceptTransaction,
   mutations: [
-    {
-      name: "move 50% to another account",
-      maxRun: 2,
-      transaction: ({ account, siblings, bridge, maxSpendable }) => {
-        invariant(maxSpendable.gt(minimalAmount), "balance is too low");
-        const sibling = pickSiblings(siblings, maxAccount);
-        const recipient = sibling.freshAddress;
-        const amount = maxSpendable.div(2).integerValue();
-        return {
-          transaction: bridge.createTransaction(account),
-          updates: [{ recipient }, { amount }],
-        };
-      },
-    },
-    {
-      name: "send max to another account",
-      maxRun: 1,
-      transaction: ({ account, siblings, bridge, maxSpendable }) => {
-        invariant(maxSpendable.gt(minimalAmount), "balance is too low");
-        const sibling = pickSiblings(siblings, maxAccount);
-        const recipient = sibling.freshAddress;
-        return {
-          transaction: bridge.createTransaction(account),
-          updates: [{ recipient }, { useAllAmount: true }],
-        };
-      },
-    },
+    send50PercentMutation,
+    sendMaxMutation,
+    registerAccountMutation,
+    unlockMutation,
+    lockMutation,
+    voteMutation,
+    activateVoteMutation,
+    revokeVoteMutation,
+    withdrawMutation,
   ],
 };
 

package/src/families/celo/speculos-deviceActions.ts

@@ -2,6 +2,16 @@ import type { DeviceAction } from "../../bot/types";
 import type { Transaction } from "./types";
 import { deviceActionFlow } from "../../bot/specs";
 import { formatCurrencyUnit } from "../../currencies";
+const typeWording = {
+  send: "Send",
+  lock: "Lock",
+  unlock: "Unlock",
+  withdraw: "Withdraw",
+  vote: "Vote",
+  revoke: "Revoke",
+  activate: "Activate",
+  register: "Create Account",
+};
 
 export const acceptTransaction: DeviceAction<Transaction, any> =
   deviceActionFlow({
@@ -19,12 +29,10 @@ export const acceptTransaction: DeviceAction<Transaction, any> =
             formatCurrencyUnit(account.unit, status.amount, {
               disableRounding: true,
             });
-
           if (!formattedValue.includes(".")) {
             // if the value is pure integer, in the app it will automatically add an .0
             return formattedValue + ".0";
           }
-
           return formattedValue;
         },
       },
@@ -41,6 +49,17 @@ export const acceptTransaction: DeviceAction<Transaction, any> =
         title: "No Gateway Fee",
         button: "Rr",
       },
+      {
+        title: "Validator",
+        button: "Rr",
+      },
+      {
+        title: "Type",
+        button: "Rr",
+        expectedValue: ({ transaction }) => {
+          return typeWording[transaction.mode];
+        },
+      },
       {
         title: "Accept",
         button: "LRlr",