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

package/src/families/celo/api/hubble.ts

@@ -3,6 +3,9 @@ import network from "../../../network";
 import { getEnv } from "../../../env";
 import { Operation, OperationType } from "@ledgerhq/types-live";
 import { encodeOperationId } from "../../../operation";
+import { CeloValidatorGroup, FigmentIndexerTransaction } from "../types";
+import { isDefaultValidatorGroup } from "../logic";
+import { celoKit } from "./sdk";
 
 const DEFAULT_TRANSACTIONS_LIMIT = 200;
 const getUrl = (route): string => `${getEnv("API_CELO_INDEXER")}${route || ""}`;
@@ -28,12 +31,36 @@ const fetchStatus = async () => {
   return data;
 };
 
+const fetchValidatorGroups = async () => {
+  const { data } = await network({
+    method: "GET",
+    url: getUrl(`/validator_groups`),
+  });
+  return data.items;
+};
+
 const getOperationType = (type: string): OperationType => {
   switch (type) {
     case "InternalTransferSent":
       return "OUT";
     case "InternalTransferReceived":
       return "IN";
+    case "GoldLocked":
+      return "LOCK";
+    case "GoldUnlocked":
+      return "UNLOCK";
+    case "GoldWithdrawn":
+      return "WITHDRAW";
+    case "ValidatorGroupVoteCastSent":
+      return "VOTE";
+    case "ValidatorGroupActiveVoteRevokedSent":
+      return "REVOKE";
+    case "ValidatorGroupPendingVoteRevokedSent":
+      return "REVOKE";
+    case "ValidatorGroupVoteActivatedSent":
+      return "ACTIVATE";
+    case "AccountCreated":
+      return "REGISTER";
     case "AccountSlashed":
       return "SLASH";
     default:
@@ -44,44 +71,87 @@ const getOperationType = (type: string): OperationType => {
 const transactionToOperation = (
   address: string,
   accountId: string,
-  transaction
+  transaction: FigmentIndexerTransaction
 ): Operation => {
   const type: OperationType = getOperationType(transaction.kind);
-  const hasFailed = transaction.data.success
-    ? !transaction.data.success
+  const hasFailed = transaction.data?.success
+    ? !transaction.data?.success
     : false;
-  const senders = transaction.data.from ? [transaction.data.from] : [];
-  const recipients = transaction.data.to ? [transaction.data.to] : [];
+  const data = transaction.data;
+  const sender = data?.Account || data?.from;
+  const recipient = data?.Group || data?.to || data?.Raw?.address;
+  const fee = new BigNumber(transaction.data?.gas_used || 0).times(
+    new BigNumber(transaction.data?.gas_price || 0)
+  );
+
+  const value = [
+    "LOCK",
+    "UNLOCK",
+    "ACTIVATE",
+    "VOTE",
+    "REVOKE",
+    "REGISTER",
+  ].includes(type)
+    ? new BigNumber(fee)
+    : new BigNumber(transaction.amount);
 
   return {
     id: encodeOperationId(accountId, transaction.transaction_hash, type),
     hash: transaction.transaction_hash,
     accountId,
-    fee: new BigNumber(0),
-    value: new BigNumber(transaction.amount),
+    fee,
+    value,
     type,
     blockHeight: transaction.height,
     date: new Date(transaction.time),
-    senders,
-    recipients,
+    senders: sender ? [sender] : [],
+    recipients: recipient ? [recipient] : [],
     hasFailed,
     blockHash: null,
-    extra: {},
+    extra: {
+      celoOperationValue: new BigNumber(transaction.amount),
+      ...(["ACTIVATE", "VOTE", "REVOKE"].includes(type)
+        ? {
+            celoSourceValidator: recipient,
+          }
+        : {}),
+    },
   };
 };
 
-export const getAccountDetails = async (address: string, accountId: string) => {
+export const getAccountDetails = async (
+  address: string,
+  accountId: string
+): Promise<{
+  blockHeight: any;
+  balance: BigNumber;
+  spendableBalance: BigNumber;
+  operations: Operation[];
+  lockedBalance: BigNumber;
+  nonvotingLockedBalance: BigNumber;
+}> => {
   const accountDetails = await fetchAccountDetails(address);
   const spendableBalance = new BigNumber(accountDetails.gold_balance);
   const lockedBalance = new BigNumber(accountDetails.total_locked_gold);
+  const nonvotingLockedBalance = new BigNumber(
+    accountDetails.total_nonvoting_locked_gold
+  );
   const balance = spendableBalance.plus(lockedBalance);
   const indexerStatus = await fetchStatus();
+  const kit = celoKit();
+  const lockedGold = await kit.contracts.getLockedGold();
 
-  const allTransactions = accountDetails.internal_transfers.concat(
-    accountDetails.transactions
-  );
-  const operations = allTransactions.map((transaction) =>
-    transactionToOperation(address, accountId, transaction)
+  const allTransactions = accountDetails.internal_transfers
+    .filter(
+      (transfer) =>
+        transfer.data?.to != lockedGold.address &&
+        transfer.data?.from != lockedGold.address
+    )
+    .concat(accountDetails.transactions);
+
+  const operations: Operation[] = allTransactions.map(
+    (transaction: FigmentIndexerTransaction) =>
+      transactionToOperation(address, accountId, transaction)
   );
 
   return {
@@ -89,5 +159,32 @@ export const getAccountDetails = async (address: string, accountId: string) => {
     balance,
     spendableBalance,
     operations,
+    lockedBalance,
+    nonvotingLockedBalance,
   };
 };
+
+export const getValidatorGroups = async (): Promise<CeloValidatorGroup[]> => {
+  const validatorGroups = await fetchValidatorGroups();
+
+  const result = validatorGroups.map((validatorGroup) => ({
+    address: validatorGroup.address,
+    name: validatorGroup.name || validatorGroup.address,
+    votes: new BigNumber(validatorGroup.active_votes).plus(
+      new BigNumber(validatorGroup.pending_votes)
+    ),
+  }));
+  return customValidatorGroupsOrder(result);
+};
+
+const customValidatorGroupsOrder = (validatorGroups): CeloValidatorGroup[] => {
+  const defaultValidatorGroup = validatorGroups.find(isDefaultValidatorGroup);
+
+  const sortedValidatorGroups = [...validatorGroups]
+    .sort((a, b) => b.votes.minus(a.votes))
+    .filter((group) => !isDefaultValidatorGroup(group));
+
+  return defaultValidatorGroup
+    ? [defaultValidatorGroup, ...sortedValidatorGroups]
+    : sortedValidatorGroups;
+};

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

@@ -1 +1 @@
-export { getAccountDetails } from "./hubble";
+export { getAccountDetails, getValidatorGroups } from "./hubble";

package/src/families/celo/api/sdk.ts

@@ -1,8 +1,96 @@
 import { ContractKit, newKit } from "@celo/contractkit";
 import { getEnv } from "../../../env";
+import { CeloVote } from "../types";
+import { makeLRUCache } from "../../../cache";
 
 let kit: ContractKit;
 export const celoKit = () => {
   if (!kit) kit = newKit(getEnv("API_CELO_NODE"));
   return kit;
 };
+
+/**
+ * Fetch account registered status. To lock any Celo, account needs to be registered first
+ */
+export const getAccountRegistrationStatus = async (
+  address: string
+): Promise<boolean> => {
+  const accounts = await celoKit().contracts.getAccounts();
+  return await accounts.isAccount(address);
+};
+
+/**
+ * Fetch pending withdrawals, with an index
+ */
+export const getPendingWithdrawals = async (address: string) => {
+  const lockedGold = await celoKit().contracts.getLockedGold();
+  const pendingWithdrawals = await lockedGold.getPendingWithdrawals(address);
+  const pendingWithdrawalsWithIndexes = pendingWithdrawals
+    .map((withdrawal, index) => ({
+      ...withdrawal,
+      index,
+    }))
+    .sort((a, b) => a.time.minus(b.time).toNumber());
+  return pendingWithdrawalsWithIndexes;
+};
+
+/**
+ * Fetch all votes
+ */
+export const getVotes = async (address: string): Promise<CeloVote[]> => {
+  const election = await celoKit().contracts.getElection();
+  const voter = await election.getVoter(await voteSignerAccount(address));
+  const activates = await getActivateTransactionObjects(address);
+  const activatableValidatorGroups = activates.map(
+    (activate) => activate.txo.arguments[0]
+  );
+
+  const votes: CeloVote[] = [];
+  voter.votes.forEach((vote) => {
+    let activeVoteRevokable = true;
+    if (vote.pending.gt(0)) {
+      // If there's a pending vote, it has to be revoked first
+      activeVoteRevokable = false;
+      votes.push({
+        validatorGroup: vote.group,
+        amount: vote.pending,
+        // Not all pending votes can be activated, 24h has to pass
+        activatable: activatableValidatorGroups.includes(vote.group),
+        revokable: true,
+        index: 0,
+        type: "pending",
+      });
+    }
+    if (vote.active.gt(0))
+      votes.push({
+        validatorGroup: vote.group,
+        amount: vote.active,
+        activatable: false,
+        revokable: activeVoteRevokable,
+        index: 1,
+        type: "active",
+      });
+  });
+
+  return votes;
+};
+
+const getActivateTransactionObjects = async (address: string) => {
+  const election = await celoKit().contracts.getElection();
+  return await election.activate(await voteSignerAccount(address));
+};
+
+/**
+ * Fetch and cache address of a vote signer account
+ * Cache it for 1h since vote signer is usually the same account as our address
+ */
+export const voteSignerAccount = makeLRUCache(
+  async (address: string): Promise<string> => {
+    const accounts = await celoKit().contracts.getAccounts();
+    return await accounts.voteSignerToAccount(address);
+  },
+  (address) => address,
+  {
+    maxAge: 60 * 60 * 1000, // 1 hour
+  }
+);

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

@@ -2,6 +2,7 @@ import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
 import type { Transaction } from "../types";
 import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
 import { sync, scanAccounts } from "../js-synchronisation";
+import { getPreloadStrategy, preload, hydrate } from "../preload";
 import signOperation from "../js-signOperation";
 import getTransactionStatus from "../js-getTransactionStatus";
 import broadcast from "../js-broadcast";
@@ -13,10 +14,8 @@ const updateTransaction = (t, patch) => ({ ...t, ...patch });
 
 const receive = makeAccountBridgeReceive();
 
-const preload = async () => Promise.resolve({});
-const hydrate = (): void => {};
-
 const currencyBridge: CurrencyBridge = {
+  getPreloadStrategy,
   preload,
   hydrate,
   scanAccounts,

package/src/families/celo/cli-transaction.ts

@@ -3,11 +3,26 @@ import type {
   AccountLike,
   AccountLikeArray,
 } from "@ledgerhq/types-live";
+
+import { from } from "rxjs";
+import { map } from "rxjs/operators";
+import { getValidatorGroups } from "../celo/api";
 import invariant from "invariant";
 import flatMap from "lodash/flatMap";
 import type { Transaction } from "../celo/types";
 
-const options = [];
+const options = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send, lock, unlock, withdraw, vote, revoke, activate, register",
+  },
+  {
+    name: "transactionIndex",
+    type: String,
+    desc: "transaction index of a pending withdraw in case of withdraw mode",
+  },
+];
 
 function inferAccounts(account: Account): AccountLikeArray {
   invariant(account.currency.family === "celo", "celo family");
@@ -21,20 +36,49 @@ function inferTransactions(
     account: AccountLike;
     transaction: Transaction;
     mainAccount: Account;
-  }>
+  }>,
+  opts: Record<string, any>
 ): Transaction[] {
+  const mode = opts.mode || "send";
+  invariant(
+    [
+      "send",
+      "lock",
+      "unlock",
+      "withdraw",
+      "vote",
+      "revoke",
+      "activate",
+      "register",
+    ].includes(mode),
+    `Unexpected mode: ${mode}`
+  );
+
   return flatMap(transactions, ({ transaction }) => {
     invariant(transaction.family === "celo", "celo family");
 
     return {
       ...transaction,
       family: "celo",
+      mode,
+      index: opts.transactionIndex || null,
     } as Transaction;
   });
 }
 
+const celoValidatorGroups = {
+  args: [],
+  job: () =>
+    from(getValidatorGroups()).pipe(
+      map((validatorGroup) => JSON.stringify(validatorGroup))
+    ),
+};
+
 export default {
   options,
   inferAccounts,
   inferTransactions,
+  commands: {
+    celoValidatorGroups,
+  },
 };