@ledgerhq/live-common 22.2.0-next.2 → 22.2.0-nightly.2

package/src/families/cosmos/specs.ts

@@ -50,7 +50,6 @@ const cosmos: AppSpec<Transaction> = {
   currency: getCryptoCurrencyById("cosmos"),
   appQuery: {
     model: DeviceModelId.nanoS,
-    firmware: "2.0.0",
     appName: "Cosmos",
   },
   testTimeout: 2 * 60 * 1000,

package/src/families/ethereum/nft.unit.test.ts

@@ -1,18 +1,10 @@
-import { findCryptoCurrencyByTicker } from "@ledgerhq/cryptoassets";
 import "../../__tests__/test-helpers/setup";
 import BigNumber from "bignumber.js";
 import { encodeAccountId, toNFTRaw } from "../../account";
 import { Operation } from "../../types";
 import { ProtoNFT } from "../../types/nft";
 import { mergeNfts } from "../../bridge/jsHelpers";
-import {
-  encodeNftId,
-  getNftCapabilities,
-  isNFTActive,
-  isNftTransaction,
-  nftsFromOperations,
-} from "../../nft";
-import { Transaction } from "./types";
+import { encodeNftId, nftsFromOperations } from "../../nft";
 
 describe("nft merging", () => {
   const makeNFT = (
@@ -155,104 +147,3 @@ describe("OpenSea lazy minting bs", () => {
     expect(nfts[0].amount.toNumber()).toBe(1);
   });
 });
-
-describe("nft helpers", () => {
-  describe("isNftTransaction ", () => {
-    test("should return that it's an NFT transaction", () => {
-      const transaction: Transaction = {
-        family: "ethereum",
-        mode: "erc721.transfer",
-        amount: new BigNumber(0),
-        recipient: "",
-        gasPrice: null,
-        userGasLimit: null,
-        estimatedGasLimit: null,
-        feeCustomUnit: null,
-        networkInfo: null,
-      };
-
-      expect(isNftTransaction(transaction)).toEqual(true);
-    });
-
-    test("should return that it's not an NFT transaction", () => {
-      const transaction: Transaction = {
-        family: "ethereum",
-        mode: "compound.supply",
-        amount: new BigNumber(0),
-        recipient: "",
-        gasPrice: null,
-        userGasLimit: null,
-        estimatedGasLimit: null,
-        feeCustomUnit: null,
-        networkInfo: null,
-      };
-
-      expect(isNftTransaction(transaction)).toEqual(false);
-    });
-
-    test("should not throw with null or undefined", () => {
-      expect(isNftTransaction(null)).toEqual(false);
-      expect(isNftTransaction(undefined)).toEqual(false);
-    });
-  });
-
-  describe("isNFTActive", () => {
-    test("should return that's it's activated for ethereum", () => {
-      const currency = findCryptoCurrencyByTicker("ETH");
-
-      expect(isNFTActive(currency)).toBe(true);
-    });
-
-    test("should return that's it's not activated for ripple", () => {
-      const currency = findCryptoCurrencyByTicker("XRP");
-
-      expect(isNFTActive(currency)).toBe(false);
-    });
-
-    test("should not throw with null or undefined", () => {
-      expect(isNFTActive(null)).toBe(false);
-      expect(isNFTActive(undefined)).toBe(false);
-    });
-  });
-
-  describe("getNftCapabilities", () => {
-    test("should return the capabilities of an NFT ERC1155", () => {
-      const nft: ProtoNFT = {
-        id: "",
-        contract: "",
-        tokenId: "",
-        amount: new BigNumber(0),
-        currencyId: "ethereum",
-        standard: "ERC1155",
-      };
-
-      expect(getNftCapabilities(nft)).toEqual(
-        expect.objectContaining({
-          hasQuantity: true,
-        })
-      );
-    });
-
-    test("should return the capabilities of an NFT ERC721", () => {
-      const nft: ProtoNFT = {
-        id: "",
-        contract: "",
-        tokenId: "",
-        amount: new BigNumber(0),
-        currencyId: "ethereum",
-        standard: "ERC721",
-      };
-
-      expect(getNftCapabilities(nft)).toEqual(
-        expect.objectContaining({
-          hasQuantity: false,
-        })
-      );
-    });
-
-    test("should not throw with null or undefined", () => {
-      expect(getNftCapabilities(null)).toMatchObject({});
-      expect(getNftCapabilities(undefined)).toMatchObject({});
-    });
-  });
-});

package/src/nft/support.ts

@@ -1,35 +1,27 @@
-import { Transaction, CryptoCurrency, ProtoNFT, NFTStandard } from "../types";
+import { Transaction, CryptoCurrency, ProtoNFT } from "../types";
 import { getEnv } from "../env";
 
-export const isNftTransaction = (
-  transaction: Transaction | undefined | null
-): boolean => {
-  if (transaction?.family === "ethereum") {
-    return ["erc721.transfer", "erc1155.transfer"].includes(transaction?.mode);
+export const isNftTransaction = (transaction: Transaction): boolean => {
+  if (transaction.family === "ethereum") {
+    return ["erc721.transfer", "erc1155.transfer"].includes(transaction.mode);
   }
 
   return false;
 };
 
-export function isNFTActive(
-  currency: CryptoCurrency | undefined | null
-): boolean {
-  return getEnv("NFT_CURRENCIES").split(",").includes(currency?.id);
+export function isNFTActive(currency: CryptoCurrency): boolean {
+  return getEnv("NFT_CURRENCIES").split(",").includes(currency.id);
 }
 
-const nftCapabilities: Record<string, NFTStandard[]> = {
+const nftCapabilities = {
   hasQuantity: ["ERC1155"],
 };
 
-type NFTCapabilty = keyof typeof nftCapabilities;
-
-export const getNftCapabilities = (
-  nft: ProtoNFT | undefined | null
-): Record<NFTCapabilty, boolean> =>
-  (Object.entries(nftCapabilities) as [NFTCapabilty, NFTStandard[]][]).reduce(
+export const getNftCapabilities = (nft: ProtoNFT) =>
+  Object.entries(nftCapabilities).reduce(
     (acc, [capability, standards]) => ({
       ...acc,
-      [capability]: nft?.standard ? standards.includes(nft.standard) : false,
+      [capability]: standards.includes(nft.standard),
     }),
-    {} as Record<NFTCapabilty, boolean>
+    {}
   );

package/src/types/nft.ts

@@ -1,7 +1,7 @@
 import type BigNumber from "bignumber.js";
 import { CryptoCurrencyIds } from ".";
 
-export type NFTStandard = "ERC721" | "ERC1155";
+export type NFTStandards = "ERC721" | "ERC1155";
 
 export type NFTMediaSizes = "preview" | "big" | "original";
 
@@ -33,7 +33,7 @@ export type ProtoNFT = {
   tokenId: string;
   amount: BigNumber;
   contract: string;
-  standard: NFTStandard;
+  standard: NFTStandards;
   currencyId: CryptoCurrencyIds;
   metadata?: NFTMetadata;
 };

package/src/types/operation.ts

@@ -1,5 +1,5 @@
 import type { BigNumber } from "bignumber.js";
-import { NFTStandard } from "./nft";
+import { NFTStandards } from "./nft";
 
 export type OperationType =
   | "IN"
@@ -65,7 +65,7 @@ export type Operation = {
   accountId: string;
   // --------------------------------------------- properties related to NFTs
   // the specification used for the transaction's event
-  standard?: NFTStandard | string;
+  standard?: NFTStandards | string;
   // address of an account/contract that is approved to make the transfer
   operator?: string;
   // address of the contract/collection containing an NFT (tokenId)
@@ -102,7 +102,7 @@ export type OperationRaw = {
   accountId: string;
   hasFailed?: boolean;
   // --------------------------------------------- properties related to NFTs
-  standard?: NFTStandard | string;
+  standard?: NFTStandards | string;
   operator?: string;
   contract?: string;
   tokenId?: string;