@ledgerhq/live-common 21.13.2 → 21.16.0

package/src/nft/helpers.ts

@@ -0,0 +1,78 @@
+import eip55 from "eip55";
+import BigNumber from "bignumber.js";
+import { NFT, Operation } from "../types";
+
+type Collection = NFT["collection"];
+
+type CollectionMap<C> = Record<string, C>;
+
+export type CollectionWithNFT = Collection & {
+  nfts: Array<Omit<NFT, "collection">>;
+};
+
+export const nftsFromOperations = (ops: Operation[]): NFT[] => {
+  const nftsMap = ops
+    // if ops are Operations get the prop nftOperations, else ops are considered nftOperations already
+    .flatMap((op) => (op?.nftOperations?.length ? op.nftOperations : op))
+    .reduce((acc: Record<string, NFT>, nftOp: Operation) => {
+      if (!nftOp?.contract) {
+        return acc;
+      }
+
+      // Creating a "token for a contract" unique key
+      const contract = eip55.encode(nftOp.contract!);
+      const nftKey = contract + nftOp.tokenId!;
+      const { tokenId, standard, id } = nftOp;
+
+      const nft = (acc[nftKey] ?? {
+        id,
+        tokenId: tokenId!,
+        amount: new BigNumber(0),
+        collection: {
+          contract,
+          standard: standard!,
+        },
+      }) as NFT;
+
+      if (nftOp.type === "NFT_IN") {
+        nft.amount = nft.amount.plus(nftOp.value);
+      } else if (nftOp.type === "NFT_OUT") {
+        nft.amount = nft.amount.minus(nftOp.value);
+      }
+
+      acc[nftKey] = nft;
+
+      return acc;
+    }, {});
+
+  return Object.values(nftsMap);
+};
+
+export const nftsByCollections = (
+  nfts: NFT[] = [],
+  collectionAddress?: string
+): CollectionWithNFT[] => {
+  const filteredNfts = collectionAddress
+    ? nfts.filter((n) => n.collection.contract === collectionAddress)
+    : nfts;
+
+  const collectionMap = filteredNfts.reduce(
+    (acc: CollectionMap<CollectionWithNFT>, nft: NFT) => {
+      const { collection, ...nftWithoutCollection } = nft;
+
+      if (!acc[collection.contract]) {
+        acc[collection.contract] = { ...collection, nfts: [] };
+      }
+      acc[collection.contract].nfts.push(nftWithoutCollection);
+
+      return acc;
+    },
+    {} as CollectionMap<CollectionWithNFT>
+  );
+
+  return Object.values(collectionMap);
+};
+
+export const getNftKey = (contract: string, tokenId: string): string => {
+  return `${contract}-${tokenId}`;
+};

package/src/nft/index.ts

@@ -0,0 +1,3 @@
+export * from "./nftId";
+export * from "./helpers";
+export * from "./NftMetadataProvider";

package/src/nft/nftId.ts

@@ -0,0 +1,17 @@
+export const encodeNftId = (
+  accountId: string,
+  contract: string,
+  tokenId: string
+): string => {
+  return `${accountId}+${contract}+${tokenId.toString()}`;
+};
+
+export const decodeNftId = (id: string): unknown => {
+  const [accountId, contract, tokenId] = id.split("+");
+
+  return {
+    accountId,
+    contract,
+    tokenId,
+  };
+};

package/src/operation.ts

@@ -17,6 +17,16 @@ export function findOperationInAccount(
         if (internalOp.id === operationId) return internalOp;
       }
     }
+
+    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;
+      }
+    }
   }
 
   for (let i = 0; i < pendingOperations.length; i++) {
@@ -66,7 +76,9 @@ export function patchOperationWithHash(
   };
 }
 
-export function flattenOperationWithInternals(op: Operation): Operation[] {
+export function flattenOperationWithInternalsAndNfts(
+  op: Operation
+): Operation[] {
   let ops: Operation[] = [];
 
   // ops of type NONE does not appear in lists
@@ -79,6 +91,11 @@ export function flattenOperationWithInternals(op: Operation): Operation[] {
     ops = ops.concat(op.internalOperations);
   }
 
+  // all nfts operations are expanded after the main op
+  if (op.nftOperations) {
+    ops = ops.concat(op.nftOperations);
+  }
+
   return ops;
 }
 
@@ -88,6 +105,7 @@ export function getOperationAmountNumber(op: Operation): BigNumber {
     case "REWARD":
     case "REWARD_PAYOUT":
     case "SUPPLY":
+    case "NFT_IN":
       return op.value;
 
     case "OUT":
@@ -101,6 +119,7 @@ export function getOperationAmountNumber(op: Operation): BigNumber {
     case "OPT_OUT":
     case "REDEEM":
     case "SLASH":
+    case "NFT_OUT":
       return op.value.negated();
 
     case "FREEZE":
@@ -122,7 +141,7 @@ export function getOperationAmountNumber(op: Operation): BigNumber {
 export function getOperationAmountNumberWithInternals(
   op: Operation
 ): BigNumber {
-  return flattenOperationWithInternals(op).reduce(
+  return flattenOperationWithInternalsAndNfts(op).reduce(
     (amount: BigNumber, op) => amount.plus(getOperationAmountNumber(op)),
     new BigNumber(0)
   );
@@ -148,5 +167,5 @@ export const isConfirmedOperation = (
   confirmationsNb: number
 ): boolean =>
   operation.blockHeight
-    ? account.blockHeight - operation.blockHeight > confirmationsNb
+    ? account.blockHeight - operation.blockHeight + 1 > confirmationsNb
     : false;

package/src/reconciliation.ts

@@ -27,6 +27,7 @@ import {
   fromTezosResourcesRaw,
   fromElrondResourcesRaw,
   fromCryptoOrgResourcesRaw,
+  fromNFTRaw,
 } from "./account";
 import consoleWarnExpectToEqual from "./consoleWarnExpectToEqual";
 
@@ -382,6 +383,12 @@ export function patchAccount(
     changed = true;
   }
 
+  const nfts = updatedRaw?.nfts?.map(fromNFTRaw);
+  if (updatedRaw.nfts && !isEqual(account.nfts, nfts)) {
+    next.nfts = nfts;
+    changed = true;
+  }
+
   if (!changed) return account; // nothing changed at all
 
   return next;

package/src/types/account.ts

@@ -37,6 +37,7 @@ import type {
   PortfolioRange,
 } from "./portfolio";
 import type { SwapOperation, SwapOperationRaw } from "../exchange/swap/types";
+import type { NFT, NFTRaw } from "./nft";
 // This is the old cache and now DEPRECATED (pre v2 portfoli)
 export type BalanceHistoryMap = Partial<Record<PortfolioRange, BalanceHistory>>;
 export type BalanceHistoryRawMap = Record<PortfolioRange, BalanceHistoryRaw>;
@@ -214,6 +215,8 @@ export type Account = {
   swapHistory: SwapOperation[];
   // Hash used to discard tx history on sync
   syncHash?: string;
+  // Array of NFTs computed by diffing NFTOperations
+  nfts?: NFT[];
 };
 export type SubAccount = TokenAccount | ChildAccount;
 export type AccountLike = Account | SubAccount;
@@ -299,6 +302,7 @@ export type AccountRaw = {
   cryptoOrgResources?: CryptoOrgResourcesRaw;
   swapHistory?: SwapOperationRaw[];
   syncHash?: string;
+  nfts?: NFTRaw[];
 };
 export type SubAccountRaw = TokenAccountRaw | ChildAccountRaw;
 export type AccountRawLike = AccountRaw | SubAccountRaw;

package/src/types/index.ts

@@ -9,3 +9,4 @@ export * from "./transaction";
 export * from "../generated/types";
 export * from "./bridge";
 export * from "./pagination";
+export * from "./nft";

package/src/types/nft.ts

@@ -0,0 +1,38 @@
+import type BigNumber from "bignumber.js";
+
+export type NFTStandards = "ERC721" | "ERC1155";
+
+export type NFT = {
+  // id crafted by live
+  id: string;
+  // id on chain
+  tokenId: string;
+  amount: BigNumber;
+  collection: {
+    // contract address. Careful 1 contract address != 1 collection as some collections are off-chain
+    // So 1 contract address from OpenSea for example can reprensent an infinity of collections
+    contract: string;
+    // Carefull to non spec compliant NFTs (cryptopunks, cryptokitties, ethrock, and others?)
+    standard: NFTStandards | string;
+  };
+};
+
+export type NFTRaw = Omit<NFT, "amount"> & {
+  amount: string;
+};
+
+export type NFTMetadataLinksProviders = "opensea" | "rarible" | "etherscan";
+
+export type NFTMetadataResponse = {
+  status: 200 | 404 | 500;
+  result?: {
+    contract: string;
+    tokenId: string;
+    tokenName: string | null;
+    nftName: string | null;
+    media: string | null;
+    description: string | null;
+    properties: Array<Record<"key" | "value", string>>;
+    links: Record<NFTMetadataLinksProviders, string>;
+  } | null;
+};

package/src/types/operation.ts

@@ -1,4 +1,6 @@
 import type { BigNumber } from "bignumber.js";
+import { NFTStandards } from "./nft";
+
 export type OperationType =
   | "IN"
   | "OUT"
@@ -26,7 +28,9 @@ export type OperationType =
   | "APPROVE"
   | "OPT_IN"
   | "OPT_OUT"
-  | "CLOSE_ACCOUNT";
+  | "CLOSE_ACCOUNT"
+  | "NFT_IN"
+  | "NFT_OUT";
 export type Operation = {
   // unique identifier (usually hash)
   id: string;
@@ -54,6 +58,15 @@ export type Operation = {
   transactionSequenceNumber?: number;
   // the account id. available for convenient reason
   accountId: string;
+  // --------------------------------------------- properties related to NFTs
+  // the specification used for the transaction's event
+  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)
+  contract?: string;
+  // Id of an NFT inside its collection/contract
+  tokenId?: string;
   // --------------------------------------------- specific operation raw fields
   // transaction date
   date: Date;
@@ -67,6 +80,8 @@ export type Operation = {
   // in context of accounts that have internal transactions that belong to a parent transaction
   // we have internal operations. Those are not included in the top level operations but can be presented to UI at that same level
   internalOperations?: Operation[];
+  // Operations related to ERC721 | ERC1155 tokens
+  nftOperations?: Operation[];
 };
 export type OperationRaw = {
   id: string;
@@ -81,6 +96,11 @@ export type OperationRaw = {
   transactionSequenceNumber?: number;
   accountId: string;
   hasFailed?: boolean;
+  // --------------------------------------------- properties related to NFTs
+  standard?: NFTStandards | string;
+  operator?: string;
+  contract?: string;
+  tokenId?: string;
   // --------------------------------------------- specific operation raw fields
   date: string;
   extra: Record<string, any>;
@@ -89,4 +109,6 @@ export type OperationRaw = {
   // in context of accounts that have internal transactions that belong to a parent transaction
   // we have internal operations. Those are not included in the top level operations but can be presented to UI at that same level
   internalOperations?: OperationRaw[];
+  // Operations related to ERC721 | ERC1155 tokens
+  nftOperations?: OperationRaw[];
 };