@ledgerhq/live-common 21.36.3 → 22.0.2

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

@@ -33,6 +33,7 @@ import { signOperation } from "../signOperation";
 import { modes } from "../modules";
 import postSyncPatch from "../postSyncPatch";
 import { inferDynamicRange } from "../../../range";
+import { nftMetadata, collectionMetadata } from "../nftResolvers";
 
 const receive = makeAccountBridgeReceive();
 
@@ -210,6 +211,10 @@ const currencyBridge: CurrencyBridge = {
   preload,
   hydrate,
   scanAccounts,
+  nftResolvers: {
+    nftMetadata,
+    collectionMetadata,
+  },
 };
 const accountBridge: AccountBridge<Transaction> = {
   createTransaction,

package/src/families/ethereum/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("ethereum");
+testBridge("ethereum", dataset);

package/src/families/ethereum/modules/erc1155.ts

@@ -11,10 +11,10 @@ import type { ModeModule, Transaction } from "../types";
 import type { Account } from "../../../types";
 import { prepareTransaction } from "./erc721";
 
-const notOwnedNft = createCustomErrorClass("NotOwnedNft");
-const notEnoughNftOwned = createCustomErrorClass("NotEnoughNftOwned");
-const notTokenIdsProvided = createCustomErrorClass("NotTokenIdsProvided");
-const quantityNeedsToBePositive = createCustomErrorClass(
+const NotOwnedNft = createCustomErrorClass("NotOwnedNft");
+const NotEnoughNftOwned = createCustomErrorClass("NotEnoughNftOwned");
+const NotTokenIdsProvided = createCustomErrorClass("NotTokenIdsProvided");
+const QuantityNeedsToBePositive = createCustomErrorClass(
   "QuantityNeedsToBePositive"
 );
 
@@ -47,8 +47,8 @@ const erc1155Transfer: ModeModule = {
       }
 
       t.quantities?.forEach((quantity) => {
-        if (quantity.isLessThan(1)) {
-          result.errors.amount = new quantityNeedsToBePositive();
+        if (!quantity || quantity.isLessThan(1)) {
+          result.errors.amount = new QuantityNeedsToBePositive();
         }
       });
 
@@ -62,15 +62,15 @@ const erc1155Transfer: ModeModule = {
           const transferQuantity = Number(t.quantities?.[index]);
 
           if (!nft) {
-            return new notOwnedNft();
+            return new NotOwnedNft();
           }
 
           if (transferQuantity && !nft.amount.gte(transferQuantity)) {
-            return new notEnoughNftOwned();
+            return new NotEnoughNftOwned();
           }
 
           return true;
-        }, true as true | Error) || new notTokenIdsProvided();
+        }, true as true | Error) || new NotTokenIdsProvided();
 
       if (!enoughTokensOwned || enoughTokensOwned instanceof Error) {
         result.errors.amount = enoughTokensOwned;

package/src/families/ethereum/modules/erc721.ts

@@ -11,7 +11,7 @@ import type { ModeModule, Transaction } from "../types";
 import type { Account } from "../../../types";
 import { apiForCurrency } from "../../../api/Ethereum";
 
-const notOwnedNft = createCustomErrorClass("NotOwnedNft");
+const NotOwnedNft = createCustomErrorClass("NotOwnedNft");
 
 export type Modes = "erc721.transfer";
 
@@ -23,12 +23,14 @@ export async function prepareTransaction(
   const { collection, collectionName, tokenIds } = transaction;
   if (collection && tokenIds && typeof collectionName === "undefined") {
     const api = apiForCurrency(account.currency);
-    const [{ status, result }] = await api.getNFTMetadata([
-      {
-        contract: collection,
-        tokenId: tokenIds[0],
-      },
-    ]);
+    const [{ status, result }] = await api.getNFTCollectionMetadata(
+      [
+        {
+          contract: collection,
+        },
+      ],
+      account.currency?.ethereumLikeInfo?.chainId?.toString() || "1"
+    );
     let collectionName = ""; // default value fallback if issue
     if (status === 200) {
       collectionName = result?.tokenName || "";
@@ -66,12 +68,10 @@ const erc721Transfer: ModeModule = {
 
       if (
         !a.nfts?.find?.(
-          (n) =>
-            n.tokenId === t.tokenIds?.[0] &&
-            n.collection.contract === t.collection
+          (n) => n.tokenId === t.tokenIds?.[0] && n.contract === t.collection
         )
       ) {
-        result.errors.amount = new notOwnedNft();
+        result.errors.amount = new NotOwnedNft();
       }
     }
   },

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

@@ -0,0 +1,147 @@
+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, nftsFromOperations } from "../../nft";
+
+describe("nft merging", () => {
+  const makeNFT = (
+    tokenId: string,
+    contract: string,
+    amount: number
+  ): ProtoNFT => ({
+    id: encodeNftId("test", contract, tokenId, "ethereum"),
+    tokenId,
+    amount: new BigNumber(amount),
+    contract,
+    standard: "ERC721",
+    currencyId: "ethereum",
+  });
+  const oldNfts = [
+    makeNFT("1", "contract1", 10),
+    makeNFT("2", "contract1", 1),
+    makeNFT("3", "contract2", 6),
+  ];
+
+  test("should remove first NFT and return new array with same refs", () => {
+    const nfts = [makeNFT("2", "contract1", 1), makeNFT("3", "contract2", 6)];
+    const newNfts = mergeNfts(oldNfts, nfts);
+
+    expect(newNfts.map(toNFTRaw)).toEqual(nfts.map(toNFTRaw));
+    expect(oldNfts[1]).toBe(newNfts[0]);
+    expect(oldNfts[2]).toBe(newNfts[1]);
+  });
+
+  test("should remove any NFT and return new array with same refs", () => {
+    const nfts = [makeNFT("1", "contract1", 10), makeNFT("3", "contract2", 6)];
+    const newNfts = mergeNfts(oldNfts, nfts);
+
+    expect(newNfts.map(toNFTRaw)).toEqual(nfts.map(toNFTRaw));
+    expect(oldNfts[0]).toBe(newNfts[0]);
+    expect(oldNfts[2]).toBe(newNfts[1]);
+  });
+
+  test("should change NFT amount and return new array with new ref", () => {
+    const nfts = [
+      makeNFT("1", "contract1", 10),
+      makeNFT("2", "contract1", 5),
+      makeNFT("3", "contract2", 6),
+    ];
+    const addToNft1 = mergeNfts(oldNfts, nfts);
+
+    expect(addToNft1.map(toNFTRaw)).toEqual(nfts.map(toNFTRaw));
+    expect(oldNfts[0]).toBe(addToNft1[0]);
+    expect(oldNfts[1]).not.toBe(addToNft1[1]);
+    expect(oldNfts[2]).toBe(addToNft1[2]);
+  });
+
+  test("should add NFT and return new array with new ref", () => {
+    const nfts = [
+      makeNFT("1", "contract1", 10),
+      makeNFT("2", "contract1", 1),
+      makeNFT("3", "contract2", 6),
+      makeNFT("4", "contract2", 4),
+    ];
+    const addToNft1 = mergeNfts(oldNfts, nfts);
+
+    expect(addToNft1.map(toNFTRaw)).toEqual(
+      [
+        makeNFT("4", "contract2", 4),
+        makeNFT("1", "contract1", 10),
+        makeNFT("2", "contract1", 1),
+        makeNFT("3", "contract2", 6),
+      ].map(toNFTRaw)
+    );
+    expect(oldNfts[0]).toBe(addToNft1[1]);
+    expect(oldNfts[1]).toBe(addToNft1[2]);
+    expect(oldNfts[2]).toBe(addToNft1[3]);
+    expect(addToNft1[0]).toBe(nfts[3]);
+  });
+});
+
+describe("OpenSea lazy minting bs", () => {
+  test("should have a correct on-chain nft amount even with OpenSea lazy minting", () => {
+    const makeNftOperation = (
+      type: Operation["type"],
+      value: string | number,
+      dateOrder: number
+    ): Operation => {
+      if (!["NFT_IN", "NFT_OUT"].includes(type)) {
+        return {} as Operation;
+      }
+
+      const id = encodeAccountId({
+        type: "type",
+        currencyId: "polygon",
+        xpubOrAddress: "0xbob",
+        derivationMode: "",
+        version: "1",
+      });
+      const sender = type === "NFT_IN" ? "0xbob" : "0xkvn";
+      const receiver = type === "NFT_IN" ? "0xkvn" : "0xbob";
+      const contract = "0x0000000000000000000000000000000000000000";
+      const fee = new BigNumber(0);
+      const tokenId = "42069";
+      const hash = "FaKeHasH";
+      const date = new Date(Date.now() + dateOrder ?? 0);
+
+      return {
+        id,
+        hash,
+        senders: [sender],
+        recipients: [receiver],
+        contract,
+        fee,
+        standard: "ERC1155",
+        tokenId,
+        value: new BigNumber(value),
+        type,
+        accountId: id,
+        date,
+      } as Operation;
+    };
+
+    // scenario with bob lazy minting 10 NFTs
+    const ops = [
+      makeNftOperation("NFT_OUT", 5, 0), // lazy mint sending 5 NFT
+      makeNftOperation("NFT_IN", 1, 1), // receiving 1 of them back
+      makeNftOperation("NFT_IN", 2, 2), // receiving 2 of them back
+      makeNftOperation("NFT_OUT", 2, 3), // lazy mint sending 5 NFT (transformed by OpenSea in 2 txs) 1/2 (off-chain)
+      makeNftOperation("NFT_OUT", 3, 4), // lazy mint sending 5 NFT (transformed by OpenSea in 2 txs) 2/2 (on-chain)
+      makeNftOperation("NFT_IN", 1, 5), // receiving 1 back
+    ];
+
+    // What happened for bob:
+    //
+    // -5 off-chain -> 0 on-chain (5 off-chain)
+    // +1 on-chain -> 1 on-chain (5 off-chain)
+    // +2 on-chain -> 3 on-chain (5 off-chain)
+    // -2 off-chain & -3 on-chain -> 0 on-chain (3 off-chain)
+    // +1 on-chain -> 1 on-chain (and 3 off-chain)
+
+    const nfts = nftsFromOperations(ops);
+    expect(nfts[0].amount.toNumber()).toBe(1);
+  });
+});

package/src/families/ethereum/nftResolvers.ts

@@ -0,0 +1,79 @@
+import {
+  CurrencyBridge,
+  NFTCollectionMetadataResponse,
+  NFTMetadataResponse,
+} from "../../types";
+import { getCryptoCurrencyById } from "../../currencies";
+import { metadataCallBatcher } from "../../nft";
+
+const SUPPORTED_CHAIN_IDS = new Set([
+  1, // Ethereum
+  137, // Polygon
+]);
+
+type NftResolvers = NonNullable<CurrencyBridge["nftResolvers"]>;
+
+export const nftMetadata: NftResolvers["nftMetadata"] = async ({
+  contract,
+  tokenId,
+  currencyId,
+  metadata,
+}): Promise<NFTMetadataResponse> => {
+  // This is for test/mock purposes
+  if (typeof metadata !== "undefined") {
+    return {
+      status: 200,
+      result: {
+        contract,
+        tokenId,
+        ...metadata,
+      },
+    };
+  }
+
+  const currency = getCryptoCurrencyById(currencyId);
+  const chainId = currency?.ethereumLikeInfo?.chainId;
+
+  if (!chainId || !SUPPORTED_CHAIN_IDS.has(chainId)) {
+    throw new Error("Ethereum Bridge NFT Resolver: Unsupported chainId");
+  }
+
+  const response = (await metadataCallBatcher(currency).loadNft({
+    contract,
+    tokenId,
+  })) as NFTMetadataResponse;
+
+  return response;
+};
+
+export const collectionMetadata: NftResolvers["collectionMetadata"] = async ({
+  contract,
+  currencyId,
+  metadata,
+}): Promise<NFTCollectionMetadataResponse> => {
+  // This is for test/mock purposes
+  if (typeof metadata !== "undefined") {
+    return {
+      status: 200,
+      result: {
+        contract,
+        ...metadata,
+      },
+    };
+  }
+
+  const currency = getCryptoCurrencyById(currencyId);
+  const chainId = currency?.ethereumLikeInfo?.chainId;
+
+  if (!chainId || !SUPPORTED_CHAIN_IDS.has(chainId)) {
+    throw new Error("Ethereum Bridge NFT Resolver: Unsupported chainId");
+  }
+
+  const response = (await metadataCallBatcher(currency).loadCollection({
+    contract,
+  })) as NFTCollectionMetadataResponse;
+
+  return response;
+};
+
+export default { nftMetadata, collectionMetadata };

package/src/families/ethereum/synchronisation.ts

@@ -336,7 +336,7 @@ const txToOps =
             const receiver = safeEncodeEIP55(event.receiver);
             const contract = safeEncodeEIP55(event.contract);
             const tokenId = event.token_id;
-            const nftId = encodeNftId(id, event.contract, tokenId);
+            const nftId = encodeNftId(id, event.contract, tokenId, currency.id);
             const sending = addr === sender;
             const receiving = addr === receiver;
 
@@ -414,7 +414,12 @@ const txToOps =
             event.transfers.forEach((transfer, j) => {
               const tokenId = transfer.id;
               const value = new BigNumber(transfer.value);
-              const nftId = encodeNftId(id, event.contract, tokenId);
+              const nftId = encodeNftId(
+                id,
+                event.contract,
+                tokenId,
+                currency.id
+              );
 
               if (sending) {
                 const type = "NFT_OUT";

package/src/families/ethereum/types.ts

@@ -8,6 +8,7 @@ import type { TransactionMode, ModeModule } from "./modules";
 import type { Range, RangeRaw } from "../../range";
 import type { CryptoCurrency } from "../../types";
 import type { DerivationMode } from "../../derivation";
+
 export type EthereumGasLimitRequest = {
   from?: string;
   to?: string;
@@ -91,9 +92,3 @@ export type TypedMessageData = {
     stringHash: string;
   };
 };
-//
-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 const reflect = (_declare: any) => {};

package/src/families/filecoin/types.ts

@@ -38,9 +38,3 @@ export type TransactionRaw = TransactionCommonRaw & {
 };
 
 export type BroadcastFnSignature = (arg0: BroadcastArg0) => Promise<Operation>;
-
-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 const reflect = (_declare: any) => {};

package/src/families/neo/types.ts

@@ -2,10 +2,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 NetworkInfo = {
   family: "neo";
 };
@@ -18,4 +15,3 @@ export type Transaction = TransactionCommon & {
 export type TransactionRaw = TransactionCommonRaw & {
   family: "neo";
 };
-export const reflect = (_declare: any) => {};

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

@@ -0,0 +1,81 @@
+import { setup } from "../../__tests__/test-helpers/libcore-setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
+import dataset from "./test-dataset";
+import { disconnect } from "./api";
+import { BigNumber } from "bignumber.js";
+import { canUnbond, MAX_UNLOCKINGS } from "./logic";
+import type { Account } from "../../types";
+
+// Disconnect all api clients that could be open.
+afterAll(async () => {
+  await disconnect();
+});
+
+setup("polkadot");
+testBridge("polkadot", dataset);
+
+describe("canUnbond", () => {
+  test("can unbond", () => {
+    const account: Partial<Account> = {
+      polkadotResources: {
+        controller: "",
+        stash: "",
+        nonce: 0,
+        numSlashingSpans: 0,
+        lockedBalance: new BigNumber(10000),
+        unlockedBalance: new BigNumber(0),
+        unlockingBalance: new BigNumber(0),
+        nominations: [],
+        unlockings: [
+          ...Array(MAX_UNLOCKINGS - 1).map(() => ({
+            amount: new BigNumber(Math.random()),
+            completionDate: new Date(),
+          })),
+        ],
+      },
+    };
+    expect(canUnbond(account as Account)).toBeTruthy();
+  });
+  test("can't unbond because unlockings is too much", () => {
+    const account: Partial<Account> = {
+      polkadotResources: {
+        controller: "",
+        stash: "",
+        nonce: 0,
+        numSlashingSpans: 0,
+        lockedBalance: new BigNumber(1000000),
+        unlockedBalance: new BigNumber(0),
+        unlockingBalance: new BigNumber(0),
+        nominations: [],
+        unlockings: [
+          ...Array(MAX_UNLOCKINGS).map(() => ({
+            amount: new BigNumber(Math.random()),
+            completionDate: new Date(),
+          })),
+        ],
+      },
+    };
+    expect(canUnbond(account as Account)).toBeFalsy();
+  });
+  test("can't unbond because not enough lockedBalance", () => {
+    const account: Partial<Account> = {
+      polkadotResources: {
+        controller: "",
+        stash: "",
+        nonce: 0,
+        numSlashingSpans: 0,
+        lockedBalance: new BigNumber(100),
+        unlockedBalance: new BigNumber(0),
+        unlockingBalance: new BigNumber(100),
+        nominations: [],
+        unlockings: [
+          ...Array(MAX_UNLOCKINGS).map(() => ({
+            amount: new BigNumber(Math.random()),
+            completionDate: new Date(),
+          })),
+        ],
+      },
+    };
+    expect(canUnbond(account as Account)).toBeFalsy();
+  });
+});

package/src/families/polkadot/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 RewardDestinationType =
   | "Staked"
   | "Stash"
@@ -107,4 +104,3 @@ export type PolkadotPreloadData = {
 export type PolkadotSearchFilter = (
   query: string
 ) => (validator: PolkadotValidator) => boolean;
-export const reflect = (_declare: any): void => {};

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

@@ -0,0 +1,12 @@
+import { setup } from "../../__tests__/test-helpers/libcore-setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
+import dataset from "./test-dataset";
+import { disconnect } from "../../api/Ripple";
+
+// Disconnect all api clients that could be open.
+afterAll(async () => {
+  await disconnect();
+});
+
+setup("ripple");
+testBridge("ripple", dataset);

package/src/families/ripple/types.ts

@@ -4,65 +4,7 @@ import type {
   TransactionCommon,
   TransactionCommonRaw,
 } from "../../types/transaction";
-import type { CoreAmount, CoreBigInt, Spec } from "../../libcore/types";
 
-declare class CoreRippleLikeAddress {
-  toBase58(): Promise<string>;
-}
-
-declare class CoreRippleLikeTransaction {
-  getHash(): Promise<string>;
-  getFees(): Promise<CoreAmount>;
-  getReceiver(): Promise<CoreRippleLikeAddress>;
-  getSender(): Promise<CoreRippleLikeAddress>;
-  serialize(): Promise<string>;
-  setSignature(arg0: string, arg1: string): Promise<void>;
-  setDERSignature(arg0: string): Promise<void>;
-  getDestinationTag(): Promise<number | null | undefined>;
-  getSequence(): Promise<CoreBigInt>;
-}
-
-declare class CoreRippleLikeOperation {
-  getTransaction(): Promise<CoreRippleLikeTransaction>;
-}
-
-declare class CoreRippleLikeTransactionBuilder {
-  wipeToAddress(address: string): Promise<void>;
-  sendToAddress(amount: CoreAmount, recipient: string): Promise<void>;
-  setDestinationTag(tag: number): Promise<void>;
-  setFees(fees: CoreAmount): Promise<void>;
-  build(): Promise<CoreRippleLikeTransaction>;
-}
-
-declare class CoreRippleLikeAccount {
-  buildTransaction(): Promise<CoreRippleLikeTransactionBuilder>;
-  broadcastRawTransaction(signed: string): Promise<string>;
-  getFees(): Promise<CoreAmount>;
-  getBaseReserve(): Promise<CoreAmount>;
-  isAddressActivated(address: string): Promise<boolean>;
-}
-
-export type CoreStatics = {
-  RippleLikeOperation: CoreRippleLikeOperation;
-  RippleLikeAddress: CoreRippleLikeAddress;
-  RippleLikeTransaction: CoreRippleLikeTransaction;
-  RippleLikeAccount: CoreRippleLikeAccount;
-  RippleLikeTransactionBuilder: CoreRippleLikeTransactionBuilder;
-};
-export type {
-  CoreRippleLikeAccount,
-  CoreRippleLikeAddress,
-  CoreRippleLikeOperation,
-  CoreRippleLikeTransaction,
-  CoreRippleLikeTransactionBuilder,
-};
-export type CoreAccountSpecifics = {
-  asRippleLikeAccount(): Promise<CoreRippleLikeAccount>;
-};
-export type CoreOperationSpecifics = {
-  asRippleLikeOperation(): Promise<CoreRippleLikeOperation>;
-};
-export type CoreCurrencySpecifics = Record<string, never>;
 export type NetworkInfo = {
   family: "ripple";
   serverFee: BigNumber;
@@ -87,88 +29,3 @@ export type TransactionRaw = TransactionCommonRaw & {
   tag: number | null | undefined;
   feeCustomUnit: Unit | null | undefined;
 };
-export const reflect = (declare: (arg0: string, arg1: Spec) => void) => {
-  declare("RippleLikeAddress", {
-    methods: {
-      toBase58: {},
-    },
-  });
-  declare("RippleLikeOperation", {
-    methods: {
-      getTransaction: {
-        returns: "RippleLikeTransaction",
-      },
-    },
-  });
-  declare("RippleLikeTransaction", {
-    methods: {
-      getHash: {},
-      getDestinationTag: {},
-      getSequence: {
-        returns: "BigInt",
-      },
-      getFees: {
-        returns: "Amount",
-      },
-      getReceiver: {
-        returns: "RippleLikeAddress",
-      },
-      getSender: {
-        returns: "RippleLikeAddress",
-      },
-      serialize: {
-        returns: "hex",
-      },
-      setSignature: {
-        params: ["hex", "hex"],
-      },
-      setDERSignature: {
-        params: ["hex"],
-      },
-    },
-  });
-  declare("RippleLikeTransactionBuilder", {
-    methods: {
-      wipeToAddress: {},
-      sendToAddress: {
-        params: ["Amount"],
-      },
-      setFees: {
-        params: ["Amount"],
-      },
-      setDestinationTag: {},
-      build: {
-        returns: "RippleLikeTransaction",
-      },
-    },
-  });
-  declare("RippleLikeAccount", {
-    methods: {
-      buildTransaction: {
-        returns: "RippleLikeTransactionBuilder",
-      },
-      broadcastRawTransaction: {
-        params: ["hex"],
-      },
-      getFees: {
-        returns: "Amount",
-      },
-      getBaseReserve: {
-        returns: "Amount",
-      },
-      isAddressActivated: {},
-    },
-  });
-  return {
-    OperationMethods: {
-      asRippleLikeOperation: {
-        returns: "RippleLikeOperation",
-      },
-    },
-    AccountMethods: {
-      asRippleLikeAccount: {
-        returns: "RippleLikeAccount",
-      },
-    },
-  };
-};