@ledgerhq/coin-celo 1.1.0-next.0

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

@@ -0,0 +1,370 @@
+import BigNumber from "bignumber.js";
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+} from "@ledgerhq/errors";
+import TransactionModule from "../bridge/transaction";
+import { CeloAllFundsWarning } from "../errors";
+import type { AccountRaw, CurrenciesData, TransactionStatusCommon } from "@ledgerhq/types-live";
+import type { Transaction } from "../types/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 1",
+      apdus: `
+      => e00200000d038000002c8000ce1080000000
+      <= 410453390dcc1e6f1be0fb34f837b278ed1b4c84097c7493c13a0d915c735af1d8aa445d2738a95e8f50bc22abd2e17cb868d4db22a623d99d861740eb93373d50a328383735443736394535333337363338363732386136374632463564326435666561374637356233399000
+      => e002000015058000002c8000ce10800000000000000000000000
+      <= 4104eedca4417737f2dae0e12320edba0e845e4ced411e6e2978a9165dde3891099402ff4906ecaab03232f8273592287a94866f14f17b5e2bf6e31837278127919c28636644343865304641663966313933373735303963453638613641364634443943383566663841429000
+      => e002000015058000002c8000ce10800000010000000000000000
+      <= 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",
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "celo",
+        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: () => ({
+            errors: {},
+            warnings: {
+              amount: new CeloAllFundsWarning(),
+            },
+          }),
+        },
+        {
+          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",
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "celo",
+        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/errors.ts

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

package/src/logic.ts

@@ -0,0 +1,146 @@
+import {
+  CeloAccount,
+  CeloPendingWithdrawal,
+  CeloValidatorGroup,
+  CeloVote,
+  CeloVoteStatus,
+  PendingStakingOperationAmounts,
+} from "./types/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 = (account: 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 isAccountRegistrationPending =
+    !!account &&
+    account.pendingOperations.some(currentAccount => currentAccount.type === "REGISTER") &&
+    !account.celoResources?.registrationStatus;
+
+  return isAccountRegistrationPending;
+};
+
+const isOperationTrulyPending = (operation: Operation, activeOperations: Operation[]): boolean => {
+  return !activeOperations.some(activeOperation => activeOperation.hash === operation.hash);
+};
+
+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;
+    },
+    {
+      vote: new BigNumber(0),
+      lock: new BigNumber(0),
+    },
+  );
+
+  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);

package/src/network/hubble.ts

@@ -0,0 +1,183 @@
+import network from "@ledgerhq/live-network/network";
+import { OperationType } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { getEnv } from "@ledgerhq/live-env";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { isDefaultValidatorGroup } from "../logic";
+import { CeloOperation, CeloValidatorGroup, FigmentIndexerTransaction } from "../types/types";
+import { celoKit } from "../network/sdk";
+
+const DEFAULT_TRANSACTIONS_LIMIT = 200;
+const getUrl = (route: string): string => `${getEnv("API_CELO_INDEXER")}${route || ""}`;
+
+// Indexer returns both account data and transactions in one call.
+// Transactions are just limited, there's no block height offset
+const fetchAccountDetails = async (
+  address: string,
+  transactionsLimit: number = DEFAULT_TRANSACTIONS_LIMIT,
+) => {
+  const { data } = await network({
+    method: "GET",
+    url: getUrl(`/account_details/${address}?limit=${transactionsLimit}`),
+  });
+  return data;
+};
+
+const fetchStatus = async () => {
+  const { data } = await network({
+    method: "GET",
+    url: getUrl(`/status`),
+  });
+  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:
+      return "NONE";
+  }
+};
+
+const transactionToOperation = (
+  accountId: string,
+  transaction: FigmentIndexerTransaction,
+): CeloOperation => {
+  const type: OperationType = getOperationType(transaction.kind);
+  const hasFailed = transaction.data?.success ? !transaction.data?.success : false;
+  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,
+    value,
+    type,
+    blockHeight: transaction.height,
+    date: new Date(transaction.time),
+    senders: sender ? [sender] : [],
+    recipients: recipient ? [recipient] : [],
+    hasFailed,
+    blockHash: null,
+    extra: {
+      celoOperationValue: new BigNumber(transaction.amount),
+      ...(["ACTIVATE", "VOTE", "REVOKE"].includes(type)
+        ? {
+            celoSourceValidator: recipient ? recipient : "",
+          }
+        : {}),
+    },
+  };
+};
+
+export const getAccountDetails = async (
+  address: string,
+  accountId: string,
+): Promise<{
+  blockHeight: any;
+  balance: BigNumber;
+  spendableBalance: BigNumber;
+  operations: CeloOperation[];
+  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
+    .filter(
+      (transfer: { data: { to: string; from: string } }) =>
+        transfer.data?.to != lockedGold.address && transfer.data?.from != lockedGold.address,
+    )
+    .concat(accountDetails.transactions);
+
+  const operations: CeloOperation[] = allTransactions.map(
+    (transaction: FigmentIndexerTransaction) => transactionToOperation(accountId, transaction),
+  );
+
+  return {
+    blockHeight: indexerStatus.last_indexed_height,
+    balance,
+    spendableBalance,
+    operations,
+    lockedBalance,
+    nonvotingLockedBalance,
+  };
+};
+
+export const getValidatorGroups = async (): Promise<CeloValidatorGroup[]> => {
+  const validatorGroups = await fetchValidatorGroups();
+
+  const result = validatorGroups.map(
+    (validatorGroup: {
+      address: string;
+      name: string;
+      active_votes: BigNumber.Value;
+      pending_votes: BigNumber.Value;
+    }) => ({
+      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: any[]): 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/network/index.ts

@@ -0,0 +1,3 @@
+export { getAccountDetails, getValidatorGroups } from "./hubble";
+export * from "./validators";
+export * from "./sdk";