@ledgerhq/live-common 23.1.0 → 24.0.0-next.2

package/src/families/solana/{test-dataset.ts → bridge.integration.test.ts}

@@ -1,8 +1,8 @@
+import "../../__tests__/test-helpers/setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
 import BigNumber from "bignumber.js";
 import { CurrenciesData, DatasetTest, encodeAccountId } from "../../types";
-
-import { Transaction, TransactionModel } from "./types";
-
+import { SolanaStake, Transaction, TransactionModel } from "./types";
 import scanAccounts1 from "./datasets/solana.scanAccounts.1";
 import {
   AmountRequired,
@@ -32,9 +32,17 @@ import createTransaction from "./js-createTransaction";
 import { compact } from "lodash/fp";
 import { assertUnreachable } from "./utils";
 import { getEnv } from "../../env";
+import { Account, TransactionStatus } from "../../types";
+import { ChainAPI } from "./api";
+import {
+  SolanaStakeAccountIsNotDelegatable,
+  SolanaStakeAccountValidatorIsUnchangeable,
+} from "./errors";
+import getTransactionStatus from "./js-getTransactionStatus";
+import { prepareTransaction } from "./js-prepareTransaction";
 
 // do not change real properties or the test will break
-export const testOnChainData = {
+const testOnChainData = {
   //  --- real props ---
   unfundedAddress: "7b6Q3ap8qRzfyvDw1Qce3fUV8C7WgFNzJQwYNTJm3KQo",
   // 0/0
@@ -951,4 +959,161 @@ function stakingTests(): TransactionTestSpec[] {
   ];
 }
 
-export default dataset;
+testBridge(dataset);
+
+const baseAccount = {
+  balance: new BigNumber(0),
+  spendableBalance: new BigNumber(0),
+} as Account;
+
+const baseTx = {
+  family: "solana",
+  recipient: "",
+  amount: new BigNumber(0),
+} as Transaction;
+
+const baseAPI = {
+  getFeeForMessage: (_msg: unknown) =>
+    Promise.resolve(testOnChainData.fees.lamportsPerSignature),
+} as ChainAPI;
+
+type StakeTestSpec = {
+  activationState: SolanaStake["activation"]["state"];
+  txModel: Transaction["model"];
+  expectedErrors: Record<string, Error>;
+};
+
+/**
+ * Some business logic can not be described in terms of transactions and expected status
+ * in the test datasets, like stake activation/deactivation, because stake activation is
+ * not determenistic and changes with time. Hence the tests here to mock data
+ * to be determenistic.
+ */
+
+describe("solana staking", () => {
+  test("stake.delegate :: status is error: stake account is not delegatable", async () => {
+    const stakeDelegateModel: Transaction["model"] & {
+      kind: "stake.delegate";
+    } = {
+      kind: "stake.delegate",
+      uiState: {
+        stakeAccAddr: testOnChainData.unfundedAddress,
+        voteAccAddr: testOnChainData.validatorAddress,
+      },
+    };
+
+    const stakeTests: StakeTestSpec[] = [
+      {
+        activationState: "activating",
+        txModel: stakeDelegateModel,
+        expectedErrors: {
+          fee: new NotEnoughBalance(),
+          stakeAccAddr: new SolanaStakeAccountIsNotDelegatable(),
+        },
+      },
+      {
+        activationState: "active",
+        txModel: stakeDelegateModel,
+        expectedErrors: {
+          fee: new NotEnoughBalance(),
+          stakeAccAddr: new SolanaStakeAccountIsNotDelegatable(),
+        },
+      },
+      {
+        activationState: "deactivating",
+        txModel: {
+          ...stakeDelegateModel,
+          uiState: {
+            ...stakeDelegateModel.uiState,
+            voteAccAddr: testOnChainData.unfundedAddress,
+          },
+        },
+        expectedErrors: {
+          fee: new NotEnoughBalance(),
+          stakeAccAddr: new SolanaStakeAccountValidatorIsUnchangeable(),
+        },
+      },
+    ];
+
+    for (const stakeTest of stakeTests) {
+      await runStakeTest(stakeTest);
+    }
+  });
+});
+
+async function runStakeTest(stakeTestSpec: StakeTestSpec) {
+  const api = {
+    ...baseAPI,
+    getMinimumBalanceForRentExemption: () =>
+      Promise.resolve(testOnChainData.fees.stakeAccountRentExempt),
+    getAccountInfo: () => {
+      return Promise.resolve({ data: mockedVoteAccount } as any);
+    },
+  } as ChainAPI;
+
+  const account: Account = {
+    ...baseAccount,
+    solanaResources: {
+      stakes: [
+        {
+          stakeAccAddr: testOnChainData.unfundedAddress,
+          delegation: {
+            stake: 1,
+            voteAccAddr: testOnChainData.validatorAddress,
+          },
+          activation: {
+            state: stakeTestSpec.activationState,
+          },
+        } as SolanaStake,
+      ],
+    },
+  };
+
+  const tx: Transaction = {
+    ...baseTx,
+    model: stakeTestSpec.txModel,
+  };
+
+  const preparedTx = await prepareTransaction(account, tx, api);
+  const status = await getTransactionStatus(account, preparedTx);
+
+  const expectedStatus: TransactionStatus = {
+    amount: new BigNumber(0),
+    estimatedFees: new BigNumber(testOnChainData.fees.lamportsPerSignature),
+    totalSpent: new BigNumber(testOnChainData.fees.lamportsPerSignature),
+    errors: stakeTestSpec.expectedErrors,
+    warnings: {},
+  };
+
+  expect(status).toEqual(expectedStatus);
+}
+
+const mockedVoteAccount = {
+  parsed: {
+    info: {
+      authorizedVoters: [
+        {
+          authorizedVoter: "EvnRmnMrd69kFdbLMxWkTn1icZ7DCceRhvmb2SJXqDo4",
+          epoch: 283,
+        },
+      ],
+      authorizedWithdrawer: "EvnRmnMrd69kFdbLMxWkTn1icZ7DCceRhvmb2SJXqDo4",
+      commission: 7,
+      epochCredits: [
+        {
+          credits: "98854605",
+          epoch: 283,
+          previousCredits: "98728105",
+        },
+      ],
+      lastTimestamp: { slot: 122422797, timestamp: 1645796249 },
+      nodePubkey: "EvnRmnMrd69kFdbLMxWkTn1icZ7DCceRhvmb2SJXqDo4",
+      priorVoters: [],
+      rootSlot: 122422766,
+      votes: [{ confirmationCount: 1, slot: 122422797 }],
+    },
+    type: "vote",
+  },
+  program: "vote",
+  space: 3731,
+};

package/src/families/stellar/{test-dataset.ts → bridge.integration.test.ts}

@@ -1,3 +1,5 @@
+import "../../__tests__/test-helpers/setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
 import { BigNumber } from "bignumber.js";
 import type { DatasetTest } from "../../types";
 import {
@@ -13,10 +15,10 @@ import {
   addMultisignStellarMockAddresses,
 } from "./bridge/mock";
 
-export const notCreatedStellarMockAddress =
+const notCreatedStellarMockAddress =
   "GAW46JE3SHIAYLNNNQCAZFQ437WB5ZH7LDRDWR5LVDWHCTHCKYB6RCCH";
 
-export const multisignStellarMockAddress =
+const multisignStellarMockAddress =
   "GCDDN6T2LJN3T7SPWJQV6BCCL5KNY5GBN7X4CMSZLDEXDHXAH32TOAHS";
 
 addNotCreatedStellarMockAddresses(notCreatedStellarMockAddress);
@@ -347,4 +349,4 @@ const dataset: DatasetTest<Transaction> = {
   },
 };
 
-export default dataset;
+testBridge(dataset);

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

@@ -2,11 +2,13 @@ import { getMainAccount } from "../../account";
 import createTransaction from "./js-createTransaction";
 import prepareTransaction from "./js-prepareTransaction";
 import getTransactionStatus from "./js-getTransactionStatus";
-import { notCreatedStellarMockAddress } from "./test-dataset";
 import type { Account, AccountLike } from "../../types";
 import type { Transaction } from "./types";
 import BigNumber from "bignumber.js";
 
+const notCreatedStellarMockAddress =
+  "GAW46JE3SHIAYLNNNQCAZFQ437WB5ZH7LDRDWR5LVDWHCTHCKYB6RCCH";
+
 const estimateMaxSpendable = async ({
   account,
   parentAccount,

package/src/families/tezos/{test-dataset.ts → bridge.integration.test.ts}

@@ -1,3 +1,9 @@
+import "../../__tests__/test-helpers/setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
+import { fromAccountRaw } from "../../account";
+import { loadAccountDelegation, listBakers } from "./bakers";
+import whitelist from "./bakers.whitelist-default";
+
 import { AmountRequired, NotEnoughBalance } from "@ledgerhq/errors";
 import type { DatasetTest } from "../../types";
 import type { Transaction } from "./types";
@@ -100,7 +106,6 @@ const dataset: DatasetTest<Transaction> = {
     },
   },
 };
-export default dataset;
 
 function makeAccount(name, pubkey, address, derivationMode) {
   return {
@@ -123,3 +128,19 @@ function makeAccount(name, pubkey, address, derivationMode) {
     subAccounts: [],
   };
 }
+
+testBridge(dataset);
+
+describe("tezos bakers", () => {
+  // FIXME Flaky test that will fail every time a Tezos baker is discontinued
+  test("getting the bakers", async () => {
+    const list = await listBakers(whitelist);
+    expect(list.map((o) => o.address)).toEqual(whitelist);
+  });
+  // TODO we'll need two accounts to test diff cases
+  test("load account baker info", async () => {
+    const account = fromAccountRaw(accountTZrevealedDelegating);
+    const delegation = await loadAccountDelegation(account);
+    expect(delegation).toBe(null);
+  });
+});

package/src/families/tezos/synchronisation.ts

@@ -208,7 +208,7 @@ const txToOp =
         type = "CREATE";
         maybeValue = new BigNumber(tx.contractBalance || 0);
         senders = [address];
-        recipients = [tx.originatedContract.address];
+        recipients = [tx.originatedContract?.address || ""];
         break;
       case "activation":
         type = "IN";

package/src/families/tron/{test-dataset.ts → bridge.integration.test.ts}

@@ -1,6 +1,8 @@
+import "../../__tests__/test-helpers/setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
 import invariant from "invariant";
 import { BigNumber } from "bignumber.js";
-import type { DatasetTest } from "../../types";
+import type { CurrenciesData, DatasetTest } from "../../types";
 import { fromTransactionRaw } from "./transaction";
 import type { Transaction } from "./types";
 import { activationFees } from "./constants";
@@ -38,8 +40,7 @@ const getTokenAccountId = (account, id) =>
     )
   ).id;
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const tron = {
+const tron: CurrenciesData<Transaction> = {
   FIXME_ignoreAccountFields: [
     "tronResources.cacheTransactionInfoById", // this is a cache, don't save it
     "tronResources.unwithdrawnReward", // it changes every vote cycles
@@ -771,8 +772,8 @@ const tron = {
 const dataset: DatasetTest<Transaction> = {
   implementations: ["tronjs"],
   currencies: {
-    // tron, // LL-7611
+    tron,
   },
 };
 
-export default dataset;
+testBridge(dataset);

package/src/hw/actions/initSwap.ts

@@ -1,24 +1,26 @@
-import { Observable, of, concat } from "rxjs";
-import { scan, tap, catchError } from "rxjs/operators";
+import { log } from "@ledgerhq/logs";
 import { useEffect, useState } from "react";
+import { concat, Observable, of } from "rxjs";
+import { catchError, scan, tap } from "rxjs/operators";
 import { getMainAccount } from "../../account";
-import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
-import type { InitSwapInput, SwapTransaction } from "../../exchange/swap/types";
-import type { Action, Device } from "./types";
-import type { AppState } from "./app";
-import { log } from "@ledgerhq/logs";
-import { createAction as createAppAction } from "./app";
 import type {
   Exchange,
   ExchangeRate,
+  InitSwapInput,
   InitSwapResult,
   SwapRequestEvent,
+  SwapTransaction,
 } from "../../exchange/swap/types";
+import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
+import type { AppState } from "./app";
+import { createAction as createAppAction } from "./app";
+import type { Action, Device } from "./types";
 
 type State = {
   initSwapResult: InitSwapResult | null | undefined;
   initSwapRequested: boolean;
   initSwapError: Error | null | undefined;
+  swapId?: string;
   error?: Error;
   isLoading: boolean;
   freezeReduxDevice: boolean;
@@ -40,6 +42,7 @@ type Result =
     }
   | {
       initSwapError: Error;
+      swapId?: string;
     };
 
 type InitSwapAction = Action<InitSwapRequest, InitSwapState, Result>;
@@ -47,6 +50,7 @@ type InitSwapAction = Action<InitSwapRequest, InitSwapState, Result>;
 const mapResult = ({
   initSwapResult,
   initSwapError,
+  swapId,
 }: InitSwapState): Result | null | undefined =>
   initSwapResult
     ? {
@@ -55,12 +59,14 @@ const mapResult = ({
     : initSwapError
     ? {
         initSwapError,
+        swapId,
       }
     : null;
 
 const initialState: State = {
   initSwapResult: null,
   initSwapError: null,
+  swapId: undefined,
   initSwapRequested: false,
   isLoading: true,
   freezeReduxDevice: false,
@@ -72,7 +78,12 @@ const reducer = (state: State, e: SwapRequestEvent) => {
       return { ...state, freezeReduxDevice: true };
 
     case "init-swap-error":
-      return { ...state, initSwapError: e.error, isLoading: false };
+      return {
+        ...state,
+        initSwapError: e.error,
+        swapId: e.swapId,
+        isLoading: false,
+      };
 
     case "init-swap-requested":
       return {

package/src/load/speculos.ts

@@ -316,8 +316,11 @@ export function appCandidatesMatches(
           hackBadSemver(appCandidate.firmware),
           searchFirmware
         ))) &&
-    (!search.appVersion ||
-      semver.satisfies(appCandidate.appVersion, search.appVersion))
+    ((!search.appVersion &&
+      !appCandidate.appVersion.includes("prerelease") &&
+      !appCandidate.appVersion.includes("rc")) ||
+      (search.appVersion &&
+        semver.satisfies(appCandidate.appVersion, search.appVersion)))
   );
 }
 export const findAppCandidate = (

package/src/nft/nftOperationId.ts

@@ -0,0 +1,47 @@
+export function encodeERC721OperationId(
+  nftId: string,
+  hash: string,
+  type: string
+): string {
+  return `${nftId}-${hash}-${type}`;
+}
+
+export function decodeERC721OperationId(id: string): {
+  nftId: string;
+  hash: string;
+  type: string;
+} {
+  const [nftId, hash, type] = id.split("-");
+  return {
+    nftId,
+    hash,
+    type,
+  };
+}
+
+export function encodeERC1155OperationId(
+  nftId: string,
+  hash: string,
+  type: string,
+  i = 0,
+  j = 0
+): string {
+  return `${nftId}-${hash}-${type}-i${i}_${j}`;
+}
+
+export function decodeERC1155OperationId(id: string): {
+  nftId: string;
+  hash: string;
+  type: string;
+  i: number;
+  j: number;
+} {
+  const [nftId, hash, type, i, j] = id.split("-");
+  return {
+    nftId,
+    hash,
+    type,
+    i: Number(i),
+    j: Number(j),
+  };
+}

package/src/operation.ts

@@ -1,5 +1,24 @@
 import { BigNumber } from "bignumber.js";
-import type { Account, AccountLike, Operation } from "./types";
+import { encodeNftId } from "./nft";
+import {
+  encodeERC1155OperationId,
+  encodeERC721OperationId,
+} from "./nft/nftOperationId";
+import {
+  Account,
+  AccountLike,
+  decodeAccountId,
+  NFTStandard,
+  Operation,
+} from "./types";
+
+const nftOperationIdEncoderPerStandard: Record<
+  NFTStandard,
+  (...args: any[]) => string
+> = {
+  ERC721: encodeERC721OperationId,
+  ERC1155: encodeERC1155OperationId,
+};
 
 export function findOperationInAccount(
   { operations, pendingOperations }: AccountLike,
@@ -32,6 +51,16 @@ export function findOperationInAccount(
   for (let i = 0; i < pendingOperations.length; i++) {
     const op = pendingOperations[i];
     if (op.id === operationId) return op;
+
+    if (op.nftOperations) {
+      const nftOps = op.nftOperations;
+
+      for (let j = 0; j < nftOps.length; j++) {
+        const nftOp = nftOps[j];
+
+        if (nftOp.id === operationId) return nftOp;
+      }
+    }
   }
 
   return null;
@@ -73,6 +102,26 @@ export function patchOperationWithHash(
         hash,
         id: encodeOperationId(op.accountId, hash, op.type),
       })),
+    nftOperations:
+      operation.nftOperations &&
+      operation.nftOperations.map((nftOp, i) => {
+        const { currencyId } = decodeAccountId(operation.accountId);
+        const nftId = encodeNftId(
+          operation.accountId,
+          nftOp.contract || "",
+          nftOp.tokenId || "",
+          currencyId
+        );
+        const nftOperationIdEncoder =
+          nftOperationIdEncoderPerStandard[nftOp?.standard || ""] ||
+          nftOperationIdEncoderPerStandard.ERC721;
+
+        return {
+          ...nftOp,
+          hash,
+          id: nftOperationIdEncoder(nftId, hash, nftOp.type, 0, i),
+        };
+      }),
   };
 }
 

package/src/portfolio/v2/index.ts

@@ -24,8 +24,13 @@ import type {
   ValueChange,
 } from "./types";
 import { getPortfolioRangeConfig, getDates } from "./range";
-import { defaultAssetsDistribution } from "../";
-import type { AssetsDistributionOpts } from "../";
+
+export const defaultAssetsDistribution = {
+  minShowFirst: 1,
+  maxShowFirst: 6,
+  showFirstThreshold: 0.95,
+};
+export type AssetsDistributionOpts = typeof defaultAssetsDistribution;
 
 export function getPortfolioCount(
   accounts: AccountLike[],

package/src/portfolio/v2/range.test.ts

@@ -0,0 +1,66 @@
+import {
+  startOfHour,
+  startOfMonth,
+  startOfDay,
+  startOfWeek,
+  getPortfolioRangeConfig,
+  getDates,
+  getRanges,
+} from "./range";
+
+describe("startOfHour", () => {
+  test("basic test", () => {
+    expect(startOfHour(new Date(1655827384305)).toISOString()).toBe(
+      "2022-06-21T16:00:00.000Z"
+    );
+  });
+});
+describe("startOfDay", () => {
+  test("basic test", () => {
+    expect(startOfDay(new Date(1655827384305)).toISOString()).toBe(
+      "2022-06-21T04:00:00.000Z"
+    );
+  });
+});
+describe("startOfMonth", () => {
+  test("basic test", () => {
+    expect(startOfMonth(new Date(1655827384305)).toISOString()).toBe(
+      "2022-06-01T04:00:00.000Z"
+    );
+  });
+});
+describe("startOfWeek", () => {
+  test("basic test", () => {
+    expect(startOfWeek(new Date(1655827384305)).toISOString()).toBe(
+      "2022-06-19T04:00:00.000Z"
+    );
+  });
+});
+describe("getPortfolioRangeConfig", () => {
+  test("returns a value for day", () => {
+    expect(getPortfolioRangeConfig("day")).toBeDefined();
+  });
+  test("returns a value for week", () => {
+    expect(getPortfolioRangeConfig("week")).toBeDefined();
+  });
+  test("returns a value for month", () => {
+    expect(getPortfolioRangeConfig("month")).toBeDefined();
+  });
+});
+describe("getDates", () => {
+  test("day returns an array of asked size", () => {
+    expect(getDates("day", 100).length).toEqual(100);
+  });
+  test("week returns an array of asked size", () => {
+    expect(getDates("week", 100).length).toEqual(100);
+  });
+  test("month returns an array of asked size", () => {
+    expect(getDates("month", 100).length).toEqual(100);
+  });
+});
+
+describe("getRanges", () => {
+  test("returns a non empty array", () => {
+    expect(getRanges().length).toBeGreaterThan(0);
+  });
+});

package/src/portfolio/v2/range.ts

@@ -1,12 +1,26 @@
-import {
-  weekIncrement,
-  dayIncrement,
-  hourIncrement,
-  startOfWeek,
-  startOfDay,
-  startOfHour,
-} from "../range";
 import type { PortfolioRangeConfig, PortfolioRange } from "./types";
+
+export const hourIncrement = 60 * 60 * 1000;
+export const dayIncrement = 24 * hourIncrement;
+export const weekIncrement = 7 * dayIncrement;
+
+export function startOfHour(t: Date): Date {
+  return new Date(t.getFullYear(), t.getMonth(), t.getDate(), t.getHours());
+}
+
+export function startOfMonth(t: Date): Date {
+  return new Date(t.getFullYear(), t.getMonth(), 1);
+}
+
+export function startOfDay(t: Date): Date {
+  return new Date(t.getFullYear(), t.getMonth(), t.getDate());
+}
+
+export function startOfWeek(t: Date): Date {
+  const d = startOfDay(t);
+  return new Date(d.getTime() - d.getDay() * dayIncrement);
+}
+
 export function getPortfolioRangeConfig(
   r: PortfolioRange
 ): PortfolioRangeConfig {

package/lib/__tests__/portfolio.d.ts

@@ -1,2 +0,0 @@
-import "./test-helpers/staticTime";
-//# sourceMappingURL=portfolio.d.ts.map

package/lib/__tests__/portfolio.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"portfolio.d.ts","sourceRoot":"","sources":["../../src/__tests__/portfolio.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC"}