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

package/src/families/celo/transaction.ts

@@ -11,10 +11,14 @@ import { getAccountUnit } from "../../account";
 import { formatCurrencyUnit } from "../../currencies";
 import { Account } from "@ledgerhq/types-live";
 export const formatTransaction = (t: Transaction, account: Account): string => `
-SEND ${formatCurrencyUnit(getAccountUnit(account), t.amount, {
-  showCode: true,
-  disableRounding: true,
-})}
+SEND ${
+  t.useAllAmount
+    ? "MAX CELO"
+    : formatCurrencyUnit(getAccountUnit(account), t.amount, {
+        showCode: true,
+        disableRounding: true,
+      })
+}
 TO ${t.recipient}`;
 
 const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
@@ -23,6 +27,8 @@ const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
     ...common,
     family: tr.family,
     fees: tr.fees ? new BigNumber(tr.fees) : null,
+    mode: tr.mode,
+    index: tr.index,
   };
 };
 
@@ -32,6 +38,8 @@ export const toTransactionRaw = (t: Transaction): TransactionRaw => {
     ...common,
     family: t.family,
     fees: t.fees?.toString() || null,
+    mode: t.mode,
+    index: t.index,
   };
 };
 

package/src/families/celo/types.ts

@@ -1,4 +1,6 @@
 import type {
+  Account,
+  AccountRaw,
   TransactionCommon,
   TransactionCommonRaw,
   TransactionStatusCommon,
@@ -6,15 +8,126 @@ import type {
 } from "@ledgerhq/types-live";
 import { BigNumber } from "bignumber.js";
 
+export type CeloOperationMode =
+  | "send"
+  | "lock"
+  | "unlock"
+  | "withdraw"
+  | "vote"
+  | "revoke"
+  | "activate"
+  | "register";
+
+export type CeloVoteType = "pending" | "active";
+export type CeloVoteStatus = CeloVoteType | "awaitingActivation";
+
+export type CeloPendingWithdrawal = {
+  value: BigNumber;
+  time: BigNumber;
+  index: number;
+};
+export type CeloPendingWithdrawalRaw = {
+  value: string;
+  time: string;
+  index: string;
+};
+export type CeloResources = {
+  registrationStatus: boolean;
+  lockedBalance: BigNumber;
+  nonvotingLockedBalance: BigNumber;
+  pendingWithdrawals: CeloPendingWithdrawal[] | null | undefined;
+  votes: CeloVote[] | null | undefined;
+  electionAddress: string | null | undefined;
+  lockedGoldAddress: string | null | undefined;
+  maxNumGroupsVotedFor: BigNumber;
+};
+export type CeloResourcesRaw = {
+  registrationStatus: boolean;
+  lockedBalance: string;
+  nonvotingLockedBalance: string;
+  pendingWithdrawals: CeloPendingWithdrawalRaw[] | null | undefined;
+  votes: CeloVoteRaw[] | null | undefined;
+  electionAddress: string | null | undefined;
+  lockedGoldAddress: string | null | undefined;
+  maxNumGroupsVotedFor: string;
+};
 export type Transaction = TransactionCommon & {
   family: "celo";
   fees: BigNumber | null | undefined;
+  mode: CeloOperationMode;
+  index: number | null | undefined;
 };
 export type TransactionRaw = TransactionCommonRaw & {
   family: "celo";
   fees: string | null | undefined;
+  mode: CeloOperationMode;
+  index: number | null | undefined;
+};
+export type CeloValidatorGroup = {
+  address: string;
+  name: string;
+  votes: BigNumber;
+};
+export type CeloVote = {
+  validatorGroup: string;
+  amount: BigNumber;
+  activatable: boolean;
+  revokable: boolean;
+  type: CeloVoteType;
+  index: number;
+};
+export type CeloVoteRaw = {
+  validatorGroup: string;
+  amount: string;
+  activatable: boolean;
+  revokable: boolean;
+  type: CeloVoteType;
+  index: number;
+};
+export type FigmentIndexerTransaction = {
+  id: number;
+  height: number;
+  time: string;
+  transaction_hash: string;
+  address: string;
+  amount: number;
+  kind: string;
+  data?: {
+    Raw?: {
+      data: string;
+      topics: Array<string>;
+      address: string;
+      removed: boolean;
+      logIndex: string;
+      blockHash: string;
+      blockNumber: string;
+      transactionHash: string;
+      transactionIndex: string;
+    };
+    gas: number;
+    Account?: string;
+    Group?: string;
+    success?: boolean;
+    from?: string;
+    to?: string;
+    gas_used: number;
+    gas_price: number;
+  };
+};
+
+export type CeloPreloadData = {
+  validatorGroups: CeloValidatorGroup[];
 };
 
 export type TransactionStatus = TransactionStatusCommon;
 
 export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type CeloAccount = Account & { celoResources: CeloResources };
+
+export type CeloAccountRaw = AccountRaw & { celoResources: CeloResourcesRaw };
+
+export type PendingStakingOperationAmounts = {
+  vote: BigNumber;
+  lock: BigNumber;
+};

package/src/families/celo/validators.ts

@@ -0,0 +1,2 @@
+import { getValidatorGroups } from "./api";
+export { getValidatorGroups };

package/src/families/cosmos/banner.test.ts

@@ -0,0 +1,160 @@
+import { getAccountBannerState } from "./banner";
+import * as preloadedData from "./preloadedData";
+import * as bridge from "../../bridge";
+import type { CosmosAccount, CosmosValidatorItem } from "./types";
+import data from "./preloadedData.mock";
+import { LEDGER_VALIDATOR_ADDRESS } from "./utils";
+import { BigNumber } from "bignumber.js";
+
+const ledgerValidator: CosmosValidatorItem | undefined = data.validators.find(
+  (x) => x.validatorAddress === LEDGER_VALIDATOR_ADDRESS
+);
+const expensiveValidator: CosmosValidatorItem | undefined =
+  data.validators.find(
+    (x) =>
+      x.validatorAddress ===
+      "cosmosvaloper1qs8tnw2t8l6amtzvdemnnsq9dzk0ag0z52uzay"
+  );
+const cheapValidator: CosmosValidatorItem | undefined = data.validators.find(
+  (x) =>
+    x.validatorAddress ===
+    "cosmosvaloper1qaa9zej9a0ge3ugpx3pxyx602lxh3ztqgfnp42"
+);
+
+const account: CosmosAccount = {
+  type: "Account",
+  id: "js:2:cosmos:cosmos1f9y7wdychcdhwvyrhff3zvs3gy3qxcu2th4g8u:",
+  starred: false,
+  used: false,
+  seedIdentifier:
+    "02d4c121ce2bb160ebf39aa0be0050b4d553e18872985ac3a4e21904fd1442defe",
+  derivationMode: "",
+  index: 1,
+  freshAddress: "cosmos1f9y7wdychcdhwvyrhff3zvs3gy3qxcu2th4g8u",
+  freshAddressPath: "44'/118'/1'/0/0",
+  name: "Cosmos 2 - Nano X Static Account",
+  freshAddresses: [],
+  blockHeight: 5417472,
+  creationDate: new Date("2022-08-02T16:09:08.906Z"),
+  balance: new BigNumber("200250"),
+  spendableBalance: new BigNumber("200250"),
+  operations: [],
+  operationsCount: 1,
+  pendingOperations: [],
+  unit: { name: "Atom", code: "ATOM", magnitude: 6 },
+  currency: {
+    type: "CryptoCurrency",
+    id: "cosmos",
+    coinType: 118,
+    name: "Cosmos",
+    managerAppName: "Cosmos",
+    ticker: "ATOM",
+    scheme: "cosmos",
+    color: "#16192f",
+    family: "cosmos",
+    units: [
+      { name: "Atom", code: "ATOM", magnitude: 6 },
+      { name: "microAtom", code: "uatom", magnitude: 0 },
+    ],
+    explorerViews: [
+      {
+        tx: "https://www.mintscan.io/cosmos/txs/$hash",
+        address: "https://www.mintscan.io/cosmos/validators/$address",
+      },
+    ],
+  },
+  lastSyncDate: new Date("2022-08-02T16:11:47.343Z"),
+  swapHistory: [],
+  balanceHistoryCache: {
+    HOUR: { balances: [0, 393248, 393248], latestDate: 1661162400000 },
+    DAY: { balances: [0, 393248], latestDate: 1661122800000 },
+    WEEK: { balances: [0, 393248], latestDate: 1661036400000 },
+  },
+  xpub: "cosmos1f9y7wdychcdhwvyrhff3zvs3gy3qxcu2th4g8u",
+  cosmosResources: {
+    delegations: [
+      {
+        amount: new BigNumber("50000"),
+        status: "bonded",
+        pendingRewards: new BigNumber("112"),
+        validatorAddress:
+          "cosmosvaloper1c4k24jzduc365kywrsvf5ujz4ya6mwympnc4en",
+      },
+    ],
+    redelegations: [],
+    unbondings: [],
+    delegatedBalance: new BigNumber("0"),
+    pendingRewardsBalance: new BigNumber("0"),
+    unbondingBalance: new BigNumber("0"),
+    withdrawAddress: "",
+  },
+};
+
+const validators = [expensiveValidator, cheapValidator, ledgerValidator];
+
+describe("cosmos/banner", () => {
+  describe("useCosmosFormattedDelegations", () => {
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+    it("should not display the banner", async () => {
+      jest
+        .spyOn(preloadedData, "getCurrentCosmosPreloadData")
+        .mockReturnValue({ validators } as {
+          validators: CosmosValidatorItem[];
+        });
+
+      jest.spyOn(bridge, "getAccountBridge").mockReturnValue({
+        estimateMaxSpendable: () => Promise.resolve(new BigNumber(0)),
+      } as any);
+      const result = await getAccountBannerState(account);
+      expect(1 + 1).toBe(2);
+      expect(result).toStrictEqual({
+        display: false,
+        redelegate: false,
+        validatorSrcAddress: "",
+        ledgerValidator,
+      });
+    });
+    it("should return display delegate mode", async () => {
+      jest
+        .spyOn(preloadedData, "getCurrentCosmosPreloadData")
+        .mockReturnValue({ validators } as {
+          validators: CosmosValidatorItem[];
+        });
+      jest.spyOn(bridge, "getAccountBridge").mockReturnValue({
+        estimateMaxSpendable: () => Promise.resolve(new BigNumber(5000)),
+      } as any);
+      const result = await getAccountBannerState(account);
+      expect(result).toStrictEqual({
+        display: true,
+        redelegate: false,
+        validatorSrcAddress: "",
+        ledgerValidator,
+      });
+    });
+    it("should return display redelegate mode", async () => {
+      jest
+        .spyOn(preloadedData, "getCurrentCosmosPreloadData")
+        .mockReturnValue({ validators } as {
+          validators: CosmosValidatorItem[];
+        });
+      jest.spyOn(bridge, "getAccountBridge").mockReturnValue({
+        estimateMaxSpendable: () => Promise.resolve(new BigNumber(5000)),
+      } as any);
+      account.cosmosResources.redelegations.push({
+        validatorSrcAddress: "xxxx",
+        validatorDstAddress: expensiveValidator?.validatorAddress as string,
+        amount: new BigNumber(1000),
+        completionDate: new Date(),
+      });
+      const result = await getAccountBannerState(account);
+      expect(result).toStrictEqual({
+        display: true,
+        redelegate: true,
+        validatorSrcAddress: expensiveValidator?.validatorAddress,
+        ledgerValidator,
+      });
+    });
+  });
+});

package/src/families/cosmos/banner.ts

@@ -0,0 +1,87 @@
+import { getCurrentCosmosPreloadData } from "./preloadedData";
+import { getAccountBridge } from "../../bridge";
+import { LEDGER_VALIDATOR_ADDRESS } from "./utils";
+import type { CosmosAccount, CosmosValidatorItem } from "./types";
+
+interface AccountBannerState {
+  display: boolean;
+  redelegate: boolean;
+  validatorSrcAddress: string;
+  ledgerValidator: CosmosValidatorItem | undefined;
+}
+
+export async function getAccountBannerState(
+  account: CosmosAccount
+): Promise<AccountBannerState> {
+  // Group current validator
+  const cosmosResources = account.cosmosResources
+    ? account.cosmosResources
+    : { delegations: [], redelegations: [] };
+  const delegationAddresses = cosmosResources.delegations.map((delegation) => {
+    return delegation.validatorAddress;
+  });
+  const redelegationAddresses = cosmosResources.redelegations.map(
+    (redelegation) => {
+      return redelegation.validatorDstAddress;
+    }
+  );
+  const validatorAdresses = [...delegationAddresses, ...redelegationAddresses];
+
+  // Get ledger validator data
+  const { validators } = getCurrentCosmosPreloadData();
+  const ledgerValidator = validators.find(
+    (validator) => validator.validatorAddress === LEDGER_VALIDATOR_ADDRESS
+  );
+
+  // Find user current worst validator (default validator is ledger)
+  let worstValidator = ledgerValidator;
+  for (let i = 0; i < validatorAdresses.length; i++) {
+    const validatorAdress = validatorAdresses[i];
+    const validator = validators.find(
+      (validator) => validator.validatorAddress === validatorAdress
+    );
+    if (
+      worstValidator &&
+      validator &&
+      worstValidator.commission < validator.commission
+    ) {
+      worstValidator = validator;
+    }
+  }
+
+  let redelegate = false;
+  let validatorSrcAddress = "";
+  let display = false;
+
+  if (worstValidator) {
+    if (
+      worstValidator?.validatorAddress === ledgerValidator?.validatorAddress
+    ) {
+      // Not found worst validator than ledger
+      const maxSpendable = await getAccountBridge(
+        account,
+        undefined
+      ).estimateMaxSpendable({
+        account,
+        parentAccount: undefined,
+        transaction: undefined,
+      });
+      if (maxSpendable.gt(0)) {
+        // Delegate remaining ATOM (not staked)
+        display = true;
+      }
+    } else {
+      // Redelegate to the worst validator
+      display = true;
+      redelegate = true;
+      validatorSrcAddress = worstValidator.validatorAddress;
+    }
+  }
+
+  return {
+    display,
+    redelegate,
+    validatorSrcAddress,
+    ledgerValidator,
+  };
+}

package/src/operation.ts

@@ -178,6 +178,7 @@ export function getOperationAmountNumber(op: Operation): BigNumber {
     case "REWARD":
     case "REWARD_PAYOUT":
     case "SUPPLY":
+    case "WITHDRAW":
       return op.value;
 
     case "OUT":
@@ -191,6 +192,7 @@ export function getOperationAmountNumber(op: Operation): BigNumber {
     case "OPT_OUT":
     case "REDEEM":
     case "SLASH":
+    case "LOCK":
       return op.value.negated();
 
     case "FREEZE":
@@ -202,6 +204,10 @@ export function getOperationAmountNumber(op: Operation): BigNumber {
     case "SET_CONTROLLER":
     case "NOMINATE":
     case "CHILL":
+    case "REVOKE":
+    case "APPROVE":
+    case "ACTIVATE":
+    case "UNLOCK":
       return op.fee.negated();
 
     default:

package/src/reconciliation.ts

@@ -26,6 +26,7 @@ import {
   fromElrondResourcesRaw,
   fromCryptoOrgResourcesRaw,
   fromSolanaResourcesRaw,
+  fromCeloResourcesRaw,
   fromNFTRaw,
   toTronResourcesRaw,
   toCosmosResourcesRaw,
@@ -36,6 +37,7 @@ import {
   toElrondResourcesRaw,
   toCryptoOrgResourcesRaw,
   toSolanaResourcesRaw,
+  toCeloResourcesRaw,
 } from "./account";
 import consoleWarnExpectToEqual from "./consoleWarnExpectToEqual";
 import { AlgorandAccount, AlgorandAccountRaw } from "./families/algorand/types";
@@ -51,6 +53,7 @@ import { PolkadotAccount, PolkadotAccountRaw } from "./families/polkadot/types";
 import { SolanaAccount, SolanaAccountRaw } from "./families/solana/types";
 import { TezosAccount, TezosAccountRaw } from "./families/tezos/types";
 import { TronAccount, TronAccountRaw } from "./families/tron/types";
+import { CeloAccount, CeloAccountRaw } from "./families/celo/types";
 
 // aim to build operations with the minimal diff & call to coin implementation possible
 export async function minimalOperationsBuilder<CO>(
@@ -490,6 +493,25 @@ export function patchAccount(
       }
       break;
     }
+    case "celo": {
+      const celoAcc = account as CeloAccount;
+      const celoUpdatedRaw = updatedRaw as CeloAccountRaw;
+
+      if (
+        celoUpdatedRaw.celoResources &&
+        (!celoAcc.celoResources ||
+          !areSameResources(
+            toCeloResourcesRaw(celoAcc.celoResources),
+            celoUpdatedRaw.celoResources
+          ))
+      ) {
+        (next as CeloAccount).celoResources = fromCeloResourcesRaw(
+          celoUpdatedRaw.celoResources
+        );
+        changed = true;
+      }
+      break;
+    }
   }
 
   const nfts = updatedRaw?.nfts?.map(fromNFTRaw);