@ledgerhq/live-common 21.36.2 → 22.0.0

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/js-signOperation.ts

@@ -11,7 +11,7 @@ import type {
   OperationType,
   SignOperationEvent,
 } from "../../types";
-import { open, close } from "../../hw";
+import { withDevice } from "../../hw/deviceAccess";
 import { encodeOperationId } from "../../operation";
 import { buildTransaction } from "./js-buildTransaction";
 import { calculateAmount, getNonce, isFirstBond } from "./logic";
@@ -157,69 +157,69 @@ const signOperation = ({
   deviceId: any;
   transaction: Transaction;
 }): Observable<SignOperationEvent> =>
-  new Observable((o) => {
-    async function main() {
-      const transport = await open(deviceId);
-
-      try {
-        o.next({
-          type: "device-signature-requested",
-        });
+  withDevice(deviceId)(
+    (transport) =>
+      new Observable((o) => {
+        async function main() {
+          o.next({
+            type: "device-signature-requested",
+          });
 
-        if (!transaction.fees) {
-          throw new FeeNotLoaded();
+          if (!transaction.fees) {
+            throw new FeeNotLoaded();
+          }
+
+          // Ensure amount is filled when useAllAmount
+          const transactionToSign = {
+            ...transaction,
+            amount: calculateAmount({
+              a: account,
+              t: transaction,
+            }),
+          };
+          const { unsigned, registry } = await buildTransaction(
+            account,
+            transactionToSign,
+            true
+          );
+          const payload = registry
+            .createType("ExtrinsicPayload", unsigned, {
+              version: unsigned.version,
+            })
+            .toU8a({
+              method: true,
+            });
+          // Sign by device
+          const polkadot = new Polkadot(transport);
+          // FIXME: the type of payload Uint8Array is not compatible with the signature of sign which accept a string
+          const r = await polkadot.sign(
+            account.freshAddressPath,
+            payload as any
+          );
+          const signed = await signExtrinsic(unsigned, r.signature, registry);
+          o.next({
+            type: "device-signature-granted",
+          });
+          const operation = buildOptimisticOperation(
+            account,
+            transactionToSign,
+            transactionToSign.fees ?? new BigNumber(0)
+          );
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature: signed,
+              expirationDate: null,
+            },
+          });
         }
 
-        // Ensure amount is filled when useAllAmount
-        const transactionToSign = {
-          ...transaction,
-          amount: calculateAmount({
-            a: account,
-            t: transaction,
-          }),
-        };
-        const { unsigned, registry } = await buildTransaction(
-          account,
-          transactionToSign,
-          true
-        );
-        const payload = registry
-          .createType("ExtrinsicPayload", unsigned, {
-            version: unsigned.version,
-          })
-          .toU8a({
-            method: true,
-          });
-        // Sign by device
-        const polkadot = new Polkadot(transport);
-        // FIXME: the type of payload Uint8Array is not compatible with the signature of sign which accept a string
-        const r = await polkadot.sign(account.freshAddressPath, payload as any);
-        const signed = await signExtrinsic(unsigned, r.signature, registry);
-        o.next({
-          type: "device-signature-granted",
-        });
-        const operation = buildOptimisticOperation(
-          account,
-          transactionToSign,
-          transactionToSign.fees ?? new BigNumber(0)
+        main().then(
+          () => o.complete(),
+          (e) => o.error(e)
         );
-        o.next({
-          type: "signed",
-          signedOperation: {
-            operation,
-            signature: signed,
-            expirationDate: null,
-          },
-        });
-      } finally {
-        close(transport, deviceId);
-      }
-    }
-
-    main().then(
-      () => o.complete(),
-      (e) => o.error(e)
-    );
-  });
+      })
+  );
 
 export default signOperation;

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 => {};