@ledgerhq/live-common 21.36.3 → 22.0.2

package/src/families/cosmos/message.ts

@@ -1,155 +0,0 @@
-import type { Transaction, CosmosMessage } from "./types";
-import type { Core } from "../../libcore/types";
-import { promiseAllBatched } from "../../promise";
-import type { CryptoCurrency } from "../../types";
-
-const getAmount = async (
-  core: Core,
-  currency: CryptoCurrency,
-  amount: string
-) => {
-  return await core.CosmosLikeAmount.init(
-    amount,
-    currency.id === "cosmos_testnet" ? "umuon" : "uatom"
-  );
-};
-
-export const cosmosCreateMessage = async (
-  freshAddress: string,
-  transaction: Transaction,
-  core: Core,
-  currency: CryptoCurrency
-): Promise<CosmosMessage[]> => {
-  const { recipient } = transaction;
-
-  switch (transaction.mode) {
-    case "send":
-      return [
-        await core.CosmosLikeMessage.wrapMsgSend(
-          await core.CosmosLikeMsgSend.init(freshAddress, recipient, [
-            await getAmount(core, currency, transaction.amount.toString()),
-          ])
-        ),
-      ];
-
-    case "delegate": {
-      const { validators } = transaction;
-
-      if (!validators || validators.length === 0) {
-        throw new Error("no validators");
-      }
-
-      return await promiseAllBatched(
-        2,
-        validators,
-        async (validator) =>
-          await core.CosmosLikeMessage.wrapMsgDelegate(
-            await core.CosmosLikeMsgDelegate.init(
-              freshAddress,
-              validator.address,
-              await getAmount(core, currency, validator.amount.toString())
-            )
-          )
-      );
-    }
-
-    case "undelegate": {
-      const { validators } = transaction;
-
-      if (!validators || validators.length === 0) {
-        throw new Error("no validators");
-      }
-
-      return await promiseAllBatched(
-        2,
-        validators,
-        async (validator) =>
-          await core.CosmosLikeMessage.wrapMsgUndelegate(
-            await core.CosmosLikeMsgUndelegate.init(
-              freshAddress,
-              validator.address,
-              await getAmount(core, currency, validator.amount.toString())
-            )
-          )
-      );
-    }
-
-    case "redelegate": {
-      const { cosmosSourceValidator } = transaction;
-
-      if (!cosmosSourceValidator) {
-        throw new Error("source validator is empty");
-      }
-
-      const { validators } = transaction;
-
-      if (!validators || validators.length === 0) {
-        throw new Error("no validators");
-      }
-
-      return await promiseAllBatched(
-        2,
-        validators,
-        async (validator) =>
-          await core.CosmosLikeMessage.wrapMsgBeginRedelegate(
-            await core.CosmosLikeMsgBeginRedelegate.init(
-              freshAddress,
-              cosmosSourceValidator,
-              validator.address,
-              await getAmount(core, currency, validator.amount.toString())
-            )
-          )
-      );
-    }
-
-    case "claimReward": {
-      const { validators } = transaction;
-
-      if (!validators || validators.length === 0) {
-        throw new Error("no validators");
-      }
-
-      return await promiseAllBatched(
-        2,
-        validators,
-        async (validator) =>
-          await core.CosmosLikeMessage.wrapMsgWithdrawDelegationReward(
-            await core.CosmosLikeMsgWithdrawDelegationReward.init(
-              freshAddress,
-              validator.address
-            )
-          )
-      );
-    }
-
-    case "claimRewardCompound": {
-      const { validators } = transaction;
-
-      if (!validators || validators.length === 0) {
-        throw new Error("no validators");
-      }
-
-      return [
-        ...(await promiseAllBatched(2, validators, async (validator) => {
-          return await core.CosmosLikeMessage.wrapMsgWithdrawDelegationReward(
-            await core.CosmosLikeMsgWithdrawDelegationReward.init(
-              freshAddress,
-              validator.address
-            )
-          );
-        })),
-        ...(await promiseAllBatched(2, validators, async (validator) => {
-          return await core.CosmosLikeMessage.wrapMsgDelegate(
-            await core.CosmosLikeMsgDelegate.init(
-              freshAddress,
-              validator.address,
-              await getAmount(core, currency, validator.amount.toString())
-            )
-          );
-        })),
-      ];
-    }
-  }
-
-  throw new Error(`unknown message : ${transaction.mode}`);
-};

package/src/families/cosmos/test-specifics.ts

@@ -1,225 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { cosmosCreateMessage } from "./message";
-import { withLibcore } from "../../libcore/access";
-import { getCryptoCurrencyById } from "../../currencies";
-import { Transaction } from "./types";
-export default () => {
-  describe("cosmosCreateMessage", () => {
-    const commonTransaction = {
-      family: "cosmos",
-      fees: null,
-      gas: null,
-      recipient: "",
-      useAllAmount: false,
-      networkInfo: null,
-      memo: null,
-      cosmosSourceValidator: null,
-      validators: [],
-    };
-    const sourceAddresss = "cosmos1g84934jpu3v5de5yqukkkhxmcvsw3u2ajxvpdl";
-    const currency = getCryptoCurrencyById("cosmos");
-    test("create a message send", async () => {
-      const messages = await withLibcore(async (core) => {
-        return await cosmosCreateMessage(
-          sourceAddresss,
-          {
-            ...commonTransaction,
-            amount: new BigNumber(3000),
-            mode: "send",
-          } as Transaction,
-          core,
-          currency
-        );
-      });
-      expect(messages[0].constructor.name).toBe("NJSCosmosLikeMessage");
-      expect(messages.length).toBe(1);
-    });
-    test("create a message delegate that throw and error", async () => {
-      await withLibcore(async (core) => {
-        try {
-          return await cosmosCreateMessage(
-            sourceAddresss,
-            {
-              ...commonTransaction,
-              amount: new BigNumber(3000),
-              mode: "delegate",
-            } as Transaction,
-            core,
-            currency
-          );
-        } catch (e: any) {
-          expect(e.message).toBe("no validators");
-        }
-      });
-    });
-    test("create a message delegate with multiples validators", async () => {
-      const messages = await withLibcore(async (core) => {
-        return await cosmosCreateMessage(
-          sourceAddresss,
-          {
-            ...commonTransaction,
-            amount: new BigNumber(3000),
-            mode: "delegate",
-            validators: [
-              {
-                amount: new BigNumber(3000),
-                address: "",
-              },
-              {
-                amount: new BigNumber(3000),
-                address: "",
-              },
-              {
-                amount: new BigNumber(3000),
-                address: "",
-              },
-            ],
-          } as Transaction,
-          core,
-          currency
-        );
-      });
-      expect(messages[0].constructor.name).toBe("NJSCosmosLikeMessage");
-      expect(messages[1].constructor.name).toBe("NJSCosmosLikeMessage");
-      expect(messages[2].constructor.name).toBe("NJSCosmosLikeMessage");
-      expect(messages.length).toBe(3);
-    });
-    test("create a message delegate", async () => {
-      const messages = await withLibcore(async (core) => {
-        return await cosmosCreateMessage(
-          sourceAddresss,
-          {
-            ...commonTransaction,
-            amount: new BigNumber(3000),
-            mode: "delegate",
-            validators: [
-              {
-                amount: new BigNumber(3000),
-                address: "",
-              },
-            ],
-          } as Transaction,
-          core,
-          currency
-        );
-      });
-      expect(messages[0].constructor.name).toBe("NJSCosmosLikeMessage");
-      expect(messages.length).toBe(1);
-    });
-    test("create a message undelegate", async () => {
-      const messages = await withLibcore(async (core) => {
-        return await cosmosCreateMessage(
-          sourceAddresss,
-          {
-            ...commonTransaction,
-            amount: new BigNumber(3000),
-            mode: "undelegate",
-            validators: [
-              {
-                amount: new BigNumber(3000),
-                address: "",
-              },
-            ],
-          } as Transaction,
-          core,
-          currency
-        );
-      });
-      expect(messages[0].constructor.name).toBe("NJSCosmosLikeMessage");
-      expect(messages.length).toBe(1);
-    });
-    test("create a message redelegate - without cosmosSourceValidator", async () => {
-      await withLibcore(async (core) => {
-        try {
-          return await cosmosCreateMessage(
-            sourceAddresss,
-            {
-              ...commonTransaction,
-              amount: new BigNumber(0),
-              mode: "redelegate",
-              cosmosSourceValidator: null,
-              validators: [
-                {
-                  amount: new BigNumber(3000),
-                  address: "",
-                },
-              ],
-            } as Transaction,
-            core,
-            currency
-          );
-        } catch (e: any) {
-          expect(e.message).toBe("source validator is empty");
-        }
-      });
-    });
-    test("create a message redelegate", async () => {
-      const messages = await withLibcore(async (core) => {
-        return await cosmosCreateMessage(
-          sourceAddresss,
-          {
-            ...commonTransaction,
-            amount: new BigNumber(3000),
-            mode: "redelegate",
-            cosmosSourceValidator: "source",
-            validators: [
-              {
-                amount: new BigNumber(3000),
-                address: "",
-              },
-            ],
-          } as Transaction,
-          core,
-          currency
-        );
-      });
-      expect(messages[0].constructor.name).toBe("NJSCosmosLikeMessage");
-      expect(messages.length).toBe(1);
-    });
-    test("create a message claimReward", async () => {
-      const messages = await withLibcore(async (core) => {
-        return await cosmosCreateMessage(
-          sourceAddresss,
-          {
-            ...commonTransaction,
-            amount: new BigNumber(0),
-            mode: "claimReward",
-            validators: [
-              {
-                amount: new BigNumber(0),
-                address: "",
-              },
-            ],
-          } as Transaction,
-          core,
-          currency
-        );
-      });
-      expect(messages[0].constructor.name).toBe("NJSCosmosLikeMessage");
-      expect(messages.length).toBe(1);
-    });
-    test("create a message claimRewardCompound", async () => {
-      const messages = await withLibcore(async (core) => {
-        return await cosmosCreateMessage(
-          sourceAddresss,
-          {
-            ...commonTransaction,
-            amount: new BigNumber(0),
-            mode: "claimRewardCompound",
-            validators: [
-              {
-                amount: new BigNumber(0),
-                address: "",
-              },
-            ],
-          } as Transaction,
-          core,
-          currency
-        );
-      });
-      expect(messages[0].constructor.name).toBe("NJSCosmosLikeMessage");
-      expect(messages[1].constructor.name).toBe("NJSCosmosLikeMessage");
-      expect(messages.length).toBe(2);
-    });
-  });
-};

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

@@ -1,78 +0,0 @@
-import "../../__tests__/test-helpers/setup";
-import BigNumber from "bignumber.js";
-import { toNFTRaw } from "../../account";
-import type { NFT } from "../../types";
-import { mergeNfts } from "../../bridge/jsHelpers";
-import { encodeNftId } from "../../nft";
-
-describe("nft merging", () => {
-  const makeNFT = (tokenId: string, contract: string, amount: number): NFT => ({
-    id: encodeNftId("test", contract, tokenId),
-    tokenId,
-    amount: new BigNumber(amount),
-    collection: {
-      contract,
-      standard: "erc721",
-    },
-  });
-  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]);
-  });
-});

package/src/families/filecoin/customAddressValidation.ts

@@ -1,19 +0,0 @@
-import type { Core } from "../../libcore/types";
-import type { CryptoCurrency } from "../../types";
-import { InvalidAddress } from "@ledgerhq/errors";
-import { validateAddress } from "./bridge/utils/addresses";
-export default async (
-  core: Core,
-  arg: {
-    currency: CryptoCurrency;
-    recipient: string;
-  }
-): Promise<null> => {
-  if (validateAddress(arg.recipient).isValid) return Promise.resolve(null);
-
-  return Promise.reject(
-    new InvalidAddress(undefined, {
-      currencyName: arg.currency.name,
-    })
-  );
-};

package/src/families/polkadot/test-specifics.ts

@@ -1,70 +0,0 @@
-import { BigNumber } from "bignumber.js";
-import { canUnbond, MAX_UNLOCKINGS } from "./logic";
-import type { Account } from "../../types";
-export default () => {
-  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();
-    });
-  });
-};