@ledgerhq/live-common 21.36.2 → 22.0.0

package/src/families/stellar/api/horizon.ts

@@ -7,7 +7,8 @@ import StellarSdk, {
 } from "stellar-sdk";
 import { getEnv } from "../../../env";
 import { getCryptoCurrencyById, parseCurrencyUnit } from "../../../currencies";
-import type { Account, NetworkInfo, Operation } from "../../../types";
+import type { Account, Operation } from "../../../types";
+import type { NetworkInfo } from "../types";
 import {
   getAccountSpendableBalance,
   rawOperationsToOperations,

package/src/families/stellar/bridge.test.ts

@@ -0,0 +1,6 @@
+import { setup } from "../../__tests__/test-helpers/libcore-setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
+import dataset from "./test-dataset";
+
+setup("stellar");
+testBridge("stellar", dataset);

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

@@ -3,7 +3,7 @@ import { Observable } from "rxjs";
 import Stellar from "@ledgerhq/hw-app-str";
 import { FeeNotLoaded } from "@ledgerhq/errors";
 import type { Account, Operation, SignOperationEvent } from "../../types";
-import { open, close } from "../../hw";
+import { withDevice } from "../../hw/deviceAccess";
 import type { Transaction } from "./types";
 import { buildTransaction } from "./js-buildTransaction";
 import { fetchSequence } from "./api";
@@ -48,11 +48,9 @@ const signOperation = ({
   deviceId: any;
   transaction: Transaction;
 }): Observable<SignOperationEvent> =>
-  Observable.create((o) => {
-    async function main() {
-      const transport = await open(deviceId);
-
-      try {
+  withDevice(deviceId)((transport) =>
+    Observable.create((o) => {
+      async function main() {
         o.next({
           type: "device-signature-requested",
         });
@@ -86,15 +84,13 @@ const signOperation = ({
             expirationDate: null,
           },
         });
-      } finally {
-        close(transport, deviceId);
       }
-    }
 
-    main().then(
-      () => o.complete(),
-      (e) => o.error(e)
-    );
-  });
+      main().then(
+        () => o.complete(),
+        (e) => o.error(e)
+      );
+    })
+  );
 
 export default signOperation;

package/src/families/stellar/test-dataset.ts

@@ -322,11 +322,9 @@ const dataset: DatasetTest<Transaction> = {
           ],
         },
         {
-          FIXME_tests: [
-            "balance is sum of ops", // https://github.com/LedgerHQ/lib-ledger-core/pull/580
-          ],
+          FIXME_tests: ["balance is sum of ops"],
           raw: {
-            id: "libcore:1:stellar:f30b743cb3a8bc8c3ea8fe8455c6a52221cc6cf867f7f1f5861dd52aba1d0b8a:sep5",
+            id: "js:1:stellar:f30b743cb3a8bc8c3ea8fe8455c6a52221cc6cf867f7f1f5861dd52aba1d0b8a:sep5",
             seedIdentifier: "gre",
             name: "GRE's Stellar 2",
             xpub: "f30b743cb3a8bc8c3ea8fe8455c6a52221cc6cf867f7f1f5861dd52aba1d0b8a",

package/src/families/stellar/types.ts

@@ -3,10 +3,6 @@ import type {
   TransactionCommon,
   TransactionCommonRaw,
 } from "../../types/transaction";
-export type CoreStatics = Record<string, never>;
-export type CoreAccountSpecifics = Record<string, never>;
-export type CoreOperationSpecifics = Record<string, never>;
-export type CoreCurrencySpecifics = Record<string, never>;
 
 export type NetworkInfo = {
   family: "stellar";
@@ -43,4 +39,3 @@ export type TransactionRaw = TransactionCommonRaw & {
   memoType: string | null | undefined;
   memoValue: string | null | undefined;
 };
-export const reflect = (_declare: any): void => {};

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

@@ -16,8 +16,10 @@ import {
   InvalidAddressBecauseDestinationIsAlsoSource,
   RecommendUndelegation,
   NotEnoughBalanceBecauseDestinationNotCreated,
+  RecipientRequired,
+  InvalidAddress,
 } from "@ledgerhq/errors";
-import { validateRecipient } from "../../../bridge/shared";
+import { validateAddress, ValidationResult } from "@taquito/utils";
 import type {
   CurrencyBridge,
   AccountBridge,
@@ -41,6 +43,19 @@ import { log } from "@ledgerhq/logs";
 import { InvalidAddressBecauseAlreadyDelegated } from "../../../errors";
 import api from "../api/tzkt";
 
+const validateRecipient = (currency, recipient) => {
+  let recipientError = null;
+  const recipientWarning = null;
+  if (!recipient) {
+    recipientError = new RecipientRequired("");
+  } else if (validateAddress(recipient) !== ValidationResult.VALID) {
+    recipientError = new InvalidAddress(undefined, {
+      currencyName: currency.name,
+    });
+  }
+  return Promise.resolve({ recipientError, recipientWarning });
+};
+
 const receive = makeAccountBridgeReceive();
 
 const EXISTENTIAL_DEPOSIT = new BigNumber(275000);

package/src/families/tezos/bridge.test.ts

@@ -0,0 +1,24 @@
+import { setup } from "../../__tests__/test-helpers/libcore-setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
+import dataset from "./test-dataset";
+import { fromAccountRaw } from "../../account";
+import { accountTZrevealedDelegating } from "./test-dataset";
+import { loadAccountDelegation, listBakers } from "./bakers";
+import whitelist from "./bakers.whitelist-default";
+
+setup("tezos");
+testBridge("tezos", 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/types.ts

@@ -1,10 +1,4 @@
 import type { BigNumber } from "bignumber.js";
-import type {
-  CoreAmount,
-  CoreBigInt,
-  Spec,
-  CoreOperationQuery,
-} from "../../libcore/types";
 import type {
   TransactionCommon,
   TransactionCommonRaw,
@@ -20,104 +14,8 @@ export type TezosResourcesRaw = {
   counter: number;
 };
 
-// WILL BE DROPPED =>
-
-export const tezosOperationTag = {
-  OPERATION_TAG_NONE: 0,
-  OPERATION_TAG_NONE1: 1,
-  OPERATION_TAG_NONE2: 2,
-  OPERATION_TAG_GENERIC: 3,
-  OPERATION_TAG_NONE4: 4,
-  OPERATION_TAG_PROPOSAL: 5,
-  OPERATION_TAG_BALLOT: 6,
-  OPERATION_TAG_REVEAL: 7,
-  OPERATION_TAG_TRANSACTION: 8,
-  OPERATION_TAG_ORIGINATION: 9,
-  OPERATION_TAG_DELEGATION: 10,
-};
-
 export type TezosOperationMode = "send" | "delegate" | "undelegate";
 
-export type TezosOperationTag =
-  typeof tezosOperationTag[keyof typeof tezosOperationTag];
-
-declare class CoreTezosLikeAddress {
-  toBase58(): Promise<string>;
-}
-
-declare class CoreTezosLikeTransaction {
-  getType(): Promise<TezosOperationTag>;
-  getHash(): Promise<string>;
-  getFees(): Promise<CoreAmount>;
-  getValue(): Promise<CoreAmount>;
-  getReceiver(): Promise<CoreTezosLikeAddress>;
-  getSender(): Promise<CoreTezosLikeAddress>;
-  getGasLimit(): Promise<CoreAmount>;
-  serialize(): Promise<string>;
-  setSignature(arg0: string): Promise<void>;
-  getStatus(): Promise<number>;
-}
-
-declare class CoreTezosLikeOperation {
-  getTransaction(): Promise<CoreTezosLikeTransaction>;
-}
-
-declare class CoreTezosLikeTransactionBuilder {
-  setType(type: TezosOperationTag): Promise<CoreTezosLikeTransactionBuilder>;
-  sendToAddress(
-    amount: CoreAmount,
-    address: string
-  ): Promise<CoreTezosLikeTransactionBuilder>;
-  wipeToAddress(address: string): Promise<CoreTezosLikeTransactionBuilder>;
-  setFees(fees: CoreAmount): Promise<CoreTezosLikeTransactionBuilder>;
-  setGasLimit(gasLimit: CoreAmount): Promise<CoreTezosLikeTransactionBuilder>;
-  build(): Promise<CoreTezosLikeTransaction>;
-  setStorageLimit(
-    storageLimit: CoreBigInt
-  ): Promise<CoreTezosLikeTransactionBuilder>;
-}
-
-declare class CoreTezosLikeAccount {
-  broadcastRawTransaction(signed: string): Promise<string>;
-  buildTransaction(): Promise<CoreTezosLikeTransactionBuilder>;
-  getStorage(address: string): Promise<CoreBigInt>;
-  getEstimatedGasLimit(address: string): Promise<CoreBigInt>;
-  getFees(): Promise<CoreBigInt>;
-  getOriginatedAccounts(): Promise<CoreTezosLikeOriginatedAccount[]>;
-}
-
-declare class CoreTezosLikeOriginatedAccount {
-  getAddress(): Promise<string>;
-  getPublicKey(): Promise<string>;
-  getBalance(): Promise<CoreAmount>;
-  isSpendable(): Promise<boolean>;
-  isDelegatable(): Promise<boolean>;
-  buildTransaction(): Promise<CoreTezosLikeTransactionBuilder>;
-  queryOperations(): Promise<CoreOperationQuery>;
-}
-
-export type CoreStatics = {
-  TezosLikeOperation: CoreTezosLikeOperation;
-  TezosLikeAddress: CoreTezosLikeAddress;
-  TezosLikeAccount: CoreTezosLikeAccount;
-  TezosLikeTransaction: CoreTezosLikeTransaction;
-  TezosLikeTransactionBuilder: CoreTezosLikeTransactionBuilder;
-};
-export type {
-  CoreTezosLikeOperation,
-  CoreTezosLikeAddress,
-  CoreTezosLikeAccount,
-  CoreTezosLikeOriginatedAccount,
-  CoreTezosLikeTransaction,
-  CoreTezosLikeTransactionBuilder,
-};
-export type CoreAccountSpecifics = {
-  asTezosLikeAccount(): Promise<CoreTezosLikeAccount>;
-};
-export type CoreOperationSpecifics = {
-  asTezosLikeOperation(): Promise<CoreTezosLikeOperation>;
-};
-export type CoreCurrencySpecifics = Record<string, never>;
 export type NetworkInfo = {
   family: "tezos";
   fees: BigNumber;
@@ -147,125 +45,3 @@ export type TransactionRaw = TransactionCommonRaw & {
   estimatedFees: string | null | undefined;
   taquitoError: string | null | undefined;
 };
-export const reflect = (declare: (arg0: string, arg1: Spec) => void) => {
-  declare("TezosLikeAddress", {
-    methods: {
-      toBase58: {},
-    },
-  });
-  declare("TezosLikeTransaction", {
-    methods: {
-      getType: {},
-      getHash: {},
-      getStatus: {},
-      getFees: {
-        returns: "Amount",
-      },
-      getValue: {
-        returns: "Amount",
-      },
-      getGasLimit: {
-        returns: "Amount",
-      },
-      getReceiver: {
-        returns: "TezosLikeAddress",
-      },
-      getSender: {
-        returns: "TezosLikeAddress",
-      },
-      serialize: {
-        returns: "hex",
-      },
-      setSignature: {
-        params: ["hex"],
-      },
-    },
-  });
-  declare("TezosLikeOperation", {
-    methods: {
-      getTransaction: {
-        returns: "TezosLikeTransaction",
-      },
-    },
-  });
-  declare("TezosLikeTransactionBuilder", {
-    methods: {
-      setType: {
-        returns: "TezosLikeTransactionBuilder",
-      },
-      sendToAddress: {
-        params: ["Amount"],
-        returns: "TezosLikeTransactionBuilder",
-      },
-      wipeToAddress: {
-        returns: "TezosLikeTransactionBuilder",
-      },
-      setFees: {
-        params: ["Amount"],
-        returns: "TezosLikeTransactionBuilder",
-      },
-      setGasLimit: {
-        params: ["Amount"],
-        returns: "TezosLikeTransactionBuilder",
-      },
-      setStorageLimit: {
-        params: ["BigInt"],
-        returns: "TezosLikeTransactionBuilder",
-      },
-      build: {
-        returns: "TezosLikeTransaction",
-      },
-    },
-  });
-  declare("TezosLikeAccount", {
-    methods: {
-      broadcastRawTransaction: {
-        params: ["hex"],
-      },
-      buildTransaction: {
-        returns: "TezosLikeTransactionBuilder",
-      },
-      getStorage: {
-        returns: "BigInt",
-      },
-      getEstimatedGasLimit: {
-        returns: "BigInt",
-      },
-      getFees: {
-        returns: "BigInt",
-      },
-      getOriginatedAccounts: {
-        returns: ["TezosLikeOriginatedAccount"],
-      },
-    },
-  });
-  declare("TezosLikeOriginatedAccount", {
-    methods: {
-      getAddress: {},
-      getPublicKey: {},
-      getBalance: {
-        returns: "Amount",
-      },
-      isSpendable: {},
-      isDelegatable: {},
-      buildTransaction: {
-        returns: "TezosLikeTransactionBuilder",
-      },
-      queryOperations: {
-        returns: "OperationQuery",
-      },
-    },
-  });
-  return {
-    OperationMethods: {
-      asTezosLikeOperation: {
-        returns: "TezosLikeOperation",
-      },
-    },
-    AccountMethods: {
-      asTezosLikeAccount: {
-        returns: "TezosLikeAccount",
-      },
-    },
-  };
-};

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

@@ -32,7 +32,7 @@ import type {
   AccountBridge,
   DeviceId,
 } from "../../../types/bridge";
-import { open, close } from "../../../hw";
+import { withDevice } from "../../../hw/deviceAccess";
 import signTransaction from "../../../hw/signTransaction";
 import { makeSync, makeScanAccounts } from "../../../bridge/jsHelpers";
 import { formatCurrencyUnit } from "../../../currencies";
@@ -99,62 +99,63 @@ const signOperation = ({
   transaction: Transaction;
   deviceId: DeviceId;
 }): Observable<SignOperationEvent> =>
-  Observable.create((o) => {
-    async function main() {
-      const subAccount =
-        transaction.subAccountId && account.subAccounts
-          ? account.subAccounts.find((sa) => sa.id === transaction.subAccountId)
-          : null;
-      const isContractAddressRecipient =
-        (await fetchTronContract(transaction.recipient)) !== undefined;
-      const fee = await getEstimatedFees(
-        account,
-        transaction,
-        isContractAddressRecipient
-      );
-      const balance = subAccount
-        ? subAccount.balance
-        : BigNumber.max(0, account.spendableBalance.minus(fee));
-      transaction.amount = transaction.useAllAmount
-        ? balance
-        : transaction.amount;
-
-      // send trc20 to a new account is forbidden by us (because it will not activate the account)
-      if (
-        transaction.recipient &&
-        transaction.mode === "send" &&
-        subAccount &&
-        subAccount.type === "TokenAccount" &&
-        subAccount.token.tokenType === "trc20" &&
-        !isContractAddressRecipient && // send trc20 to a smart contract is allowed
-        (await fetchTronAccount(transaction.recipient)).length === 0
-      ) {
-        throw new TronSendTrc20ToNewAccountForbidden();
-      }
+  withDevice(deviceId)((transport) =>
+    Observable.create((o) => {
+      async function main() {
+        const subAccount =
+          transaction.subAccountId && account.subAccounts
+            ? account.subAccounts.find(
+                (sa) => sa.id === transaction.subAccountId
+              )
+            : null;
+        const isContractAddressRecipient =
+          (await fetchTronContract(transaction.recipient)) !== undefined;
+        const fee = await getEstimatedFees(
+          account,
+          transaction,
+          isContractAddressRecipient
+        );
+        const balance = subAccount
+          ? subAccount.balance
+          : BigNumber.max(0, account.spendableBalance.minus(fee));
+        transaction.amount = transaction.useAllAmount
+          ? balance
+          : transaction.amount;
+
+        // send trc20 to a new account is forbidden by us (because it will not activate the account)
+        if (
+          transaction.recipient &&
+          transaction.mode === "send" &&
+          subAccount &&
+          subAccount.type === "TokenAccount" &&
+          subAccount.token.tokenType === "trc20" &&
+          !isContractAddressRecipient && // send trc20 to a smart contract is allowed
+          (await fetchTronAccount(transaction.recipient)).length === 0
+        ) {
+          throw new TronSendTrc20ToNewAccountForbidden();
+        }
 
-      const getPreparedTransaction = () => {
-        switch (transaction.mode) {
-          case "freeze":
-            return freezeTronTransaction(account, transaction);
+        const getPreparedTransaction = () => {
+          switch (transaction.mode) {
+            case "freeze":
+              return freezeTronTransaction(account, transaction);
 
-          case "unfreeze":
-            return unfreezeTronTransaction(account, transaction);
+            case "unfreeze":
+              return unfreezeTronTransaction(account, transaction);
 
-          case "vote":
-            return voteTronSuperRepresentatives(account, transaction);
+            case "vote":
+              return voteTronSuperRepresentatives(account, transaction);
 
-          case "claimReward":
-            return claimRewardTronTransaction(account);
+            case "claimReward":
+              return claimRewardTronTransaction(account);
 
-          default:
-            return createTronTransaction(account, transaction, subAccount);
-        }
-      };
+            default:
+              return createTronTransaction(account, transaction, subAccount);
+          }
+        };
 
-      const preparedTransaction = await getPreparedTransaction();
-      const transport = await open(deviceId);
+        const preparedTransaction = await getPreparedTransaction();
 
-      try {
         o.next({
           type: "device-signature-requested",
         });
@@ -274,16 +275,14 @@ const signOperation = ({
             expirationDate: null,
           },
         });
-      } finally {
-        close(transport, deviceId);
       }
-    }
 
-    main().then(
-      () => o.complete(),
-      (e) => o.error(e)
-    );
-  });
+      main().then(
+        () => o.complete(),
+        (e) => o.error(e)
+      );
+    })
+  );
 
 const broadcast = async ({
   signedOperation: { signature, operation, signatureRaw },

package/src/families/tron/types.ts

@@ -3,10 +3,7 @@ import type {
   TransactionCommon,
   TransactionCommonRaw,
 } from "../../types/transaction";
-export type CoreStatics = Record<string, never>;
-export type CoreAccountSpecifics = Record<string, never>;
-export type CoreOperationSpecifics = Record<string, never>;
-export type CoreCurrencySpecifics = Record<string, never>;
+
 export type TronOperationMode =
   | "send"
   | "freeze"
@@ -120,8 +117,6 @@ export type SendTransactionDataSuccess = {
   signature: string[] | null | undefined;
 };
 
-/** */
-export const reflect = (_declare: any): void => {};
 export type SuperRepresentativeData = {
   list: SuperRepresentative[];
   totalVotes: number;

package/src/generated/customAddressValidation.ts

@@ -1,9 +1,3 @@
-import bitcoin from "../families/bitcoin/customAddressValidation";
-
-import filecoin from "../families/filecoin/customAddressValidation";
-
 
 export default {
-  bitcoin,
-  filecoin,
 };