@ledgerhq/live-common 22.3.0-universal.0 → 23.0.0-next.1

package/src/families/cardano/specs.ts

@@ -0,0 +1,96 @@
+import expect from "expect";
+import type { AppSpec } from "../../bot/types";
+import type { CardanoResources, Transaction } from "./types";
+import { pickSiblings } from "../../bot/specs";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { DeviceModelId } from "@ledgerhq/devices";
+import BigNumber from "bignumber.js";
+import invariant from "invariant";
+import { utils as TyphonUtils } from "@stricahq/typhonjs";
+import { mergeTokens } from "./logic";
+import { parseCurrencyUnit } from "../../currencies";
+
+const currency = getCryptoCurrencyById("cardano");
+const minBalanceRequired = parseCurrencyUnit(currency.units[0], "2.2");
+const minBalanceRequiredForMaxSend = parseCurrencyUnit(currency.units[0], "1");
+
+const cardano: AppSpec<Transaction> = {
+  name: "cardano",
+  currency: getCryptoCurrencyById("cardano"),
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "CardanoADA",
+  },
+  testTimeout: 2 * 60 * 1000,
+  mutations: [
+    {
+      name: "move ~50%",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minBalanceRequired), "balance is too low");
+        const sibling = pickSiblings(siblings, 3);
+        const recipient = sibling.freshAddress;
+        const transaction = bridge.createTransaction(account);
+
+        const updates = [
+          { recipient },
+          { amount: new BigNumber(account.balance.dividedBy(2)).dp(0, 1) },
+          { memo: "LedgerLiveBot" },
+        ];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ operation, transaction }): void => {
+        expect(operation.extra).toEqual({
+          memo: transaction.memo,
+        });
+        expect(transaction.amount).toEqual(
+          operation.value.minus(operation.fee)
+        );
+      },
+    },
+    {
+      name: "send max",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(
+          maxSpendable.gt(minBalanceRequiredForMaxSend),
+          "balance is too low"
+        );
+        const sibling = pickSiblings(siblings, 3);
+        const recipient = sibling.freshAddress;
+        const transaction = bridge.createTransaction(account);
+
+        const updates = [{ recipient }, { useAllAmount: true }];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ accountBeforeTransaction, operation }): void => {
+        const cardanoResources =
+          accountBeforeTransaction.cardanoResources as CardanoResources;
+        const utxoTokens = cardanoResources.utxos.map((u) => u.tokens).flat();
+        const tokenBalance = mergeTokens(utxoTokens);
+        const requiredAdaForTokens = tokenBalance.length
+          ? TyphonUtils.calculateMinUtxoAmount(
+              tokenBalance,
+              new BigNumber(
+                cardanoResources.protocolParams.lovelacePerUtxoWord
+              ),
+              false
+            )
+          : new BigNumber(0);
+        expect(operation.value).toEqual(
+          accountBeforeTransaction.balance.minus(requiredAdaForTokens)
+        );
+      },
+    },
+  ],
+};
+
+export default { cardano };

package/src/families/cardano/speculos-deviceActions.ts

@@ -0,0 +1,66 @@
+import type { DeviceAction } from "../../bot/types";
+import type { Transaction } from "./types";
+import { formatCurrencyUnit } from "../../currencies";
+import { deviceActionFlow } from "../../bot/specs";
+import { Unit } from "@ledgerhq/cryptoassets";
+import BigNumber from "bignumber.js";
+
+function expectedValue(unit: Unit, value: BigNumber) {
+  return formatCurrencyUnit(unit, value, {
+    showCode: true,
+    disableRounding: true,
+    showAllDigits: true,
+  });
+}
+
+const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Start new",
+    },
+    {
+      title: "ordinary transaction?",
+      button: "Rr",
+    },
+    {
+      title: "Auxiliary data hash",
+      button: "LRlr",
+    },
+    {
+      title: "Send to address",
+      button: "LRlr",
+      ignoreAssertionFailure: true,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Send",
+      button: "LRlr",
+      ignoreAssertionFailure: true,
+      expectedValue: ({ account, status }) =>
+        expectedValue(account.unit, status.amount),
+    },
+    {
+      title: "Transaction fee",
+      button: "LRlr",
+      ignoreAssertionFailure: true,
+      expectedValue: ({ account, status }) =>
+        expectedValue(account.unit, status.estimatedFees),
+    },
+    {
+      title: "Transaction TTL",
+      button: "LRlr",
+    },
+    {
+      title: "...",
+    },
+    {
+      title: "Confirm",
+    },
+    {
+      title: "transaction?",
+      button: "Rr",
+    },
+  ],
+});
+
+export default { acceptTransaction };

package/src/families/cardano/test-dataset.ts

@@ -0,0 +1,41 @@
+import BigNumber from "bignumber.js";
+import type { DatasetTest } from "../../types";
+import { cardanoRawAccount1 } from "./datasets/rawAccount.1";
+import { cardanoScanAccounts } from "./datasets/scanAccounts";
+import { CardanoMinAmountError } from "./errors";
+import { fromTransactionRaw } from "./transaction";
+import type { Transaction } from "./types";
+
+const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    cardano_testnet: {
+      scanAccounts: cardanoScanAccounts,
+      accounts: [
+        {
+          raw: cardanoRawAccount1,
+          transactions: [
+            {
+              name: "amount less then minimum",
+              transaction: fromTransactionRaw({
+                family: "cardano",
+                recipient:
+                  "addr_test1qpl90kc2jl5kr9tev0s7vays9yhwcdnq8nlylyk4dqsdq3g466elxnxwrzwq72pvp5akenj30t5s9et7frfvrxxx8xcsxrzs87",
+                amount: "0.1",
+                mode: "send",
+              }),
+              expectedStatus: {
+                amount: new BigNumber("0.1"),
+                errors: {
+                  amount: new CardanoMinAmountError(),
+                },
+              },
+            },
+          ],
+        },
+      ],
+    },
+  },
+};
+
+export default dataset;

package/src/families/cardano/transaction.ts

@@ -0,0 +1,55 @@
+import type { Transaction, TransactionRaw } from "./types";
+import { BigNumber } from "bignumber.js";
+import {
+  fromTransactionCommonRaw,
+  toTransactionCommonRaw,
+} from "../../transaction/common";
+import type { Account } from "../../types";
+import { getAccountUnit } from "../../account";
+import { formatCurrencyUnit } from "../../currencies";
+
+export const formatTransaction = (
+  { mode, amount, recipient, useAllAmount, subAccountId }: Transaction,
+  mainAccount: Account
+): string => {
+  const account =
+    (subAccountId &&
+      (mainAccount.subAccounts || []).find((a) => a.id === subAccountId)) ||
+    mainAccount;
+  return `
+  ${mode.toUpperCase()} ${
+    useAllAmount
+      ? "MAX"
+      : amount.isZero()
+      ? ""
+      : " " +
+        formatCurrencyUnit(getAccountUnit(account), amount, {
+          showCode: true,
+          disableRounding: true,
+        })
+  }${recipient ? `\nTO ${recipient}` : ""}`;
+};
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    family: tr.family,
+    mode: tr.mode,
+    fees: tr.fees ? new BigNumber(tr.fees) : undefined,
+    memo: tr.memo,
+  };
+};
+
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  return {
+    ...common,
+    family: t.family,
+    mode: t.mode,
+    fees: t.fees?.toString() || undefined,
+    memo: t.memo,
+  };
+};
+
+export default { formatTransaction, fromTransactionRaw, toTransactionRaw };

package/src/families/cardano/types.ts

@@ -0,0 +1,178 @@
+import type { BigNumber } from "bignumber.js";
+import { types as TyphonTypes } from "@stricahq/typhonjs";
+import type {
+  TransactionCommon,
+  TransactionCommonRaw,
+} from "../../types/transaction";
+
+export enum PaymentChain {
+  external = 0,
+  internal = 1,
+}
+
+export enum StakeChain {
+  stake = 2,
+}
+
+export enum NetworkId {
+  testnet = 0,
+  mainnet = 1,
+}
+
+export type BipPath = {
+  purpose: number;
+  coin: number;
+  account: number;
+  chain: PaymentChain | StakeChain;
+  index: number;
+};
+
+export type BipPathRaw = {
+  purpose: number;
+  coin: number;
+  account: number;
+  chain: PaymentChain | StakeChain;
+  index: number;
+};
+
+export type Token = {
+  assetName: string;
+  policyId: string;
+  amount: BigNumber;
+};
+
+export type TokenRaw = {
+  assetName: string;
+  policyId: string;
+  amount: string;
+};
+
+export type PaymentKeyPath = {
+  key: string;
+  path: BipPath;
+};
+
+export type PaymentCredential = {
+  isUsed: boolean;
+  key: string;
+  path: BipPath;
+};
+
+export type PaymentCredentialRaw = {
+  isUsed: boolean;
+  key: string;
+  path: BipPathRaw;
+};
+
+export type StakeCredential = {
+  key: string;
+  path: BipPath;
+};
+
+export type CardanoOutput = {
+  hash: string;
+  index: number;
+  address: string;
+  amount: BigNumber;
+  tokens: Array<Token>;
+  paymentCredential: {
+    key: string;
+    path: BipPath;
+  };
+};
+
+export type CardanoOutputRaw = {
+  hash: string;
+  index: number;
+  address: string;
+  amount: string;
+  tokens: Array<TokenRaw>;
+  paymentCredential: {
+    key: string;
+    path: BipPath;
+  };
+};
+
+export type ProtocolParams = {
+  minFeeA: string;
+  minFeeB: string;
+  stakeKeyDeposit: string;
+  lovelacePerUtxoWord: string;
+  collateralPercent: string;
+  priceSteps: string;
+  priceMem: string;
+  languageView: TyphonTypes.LanguageView;
+};
+
+export type ProtocolParamsRaw = {
+  minFeeA: string;
+  minFeeB: string;
+  stakeKeyDeposit: string;
+  lovelacePerUtxoWord: string;
+  collateralPercent: string;
+  priceSteps: string;
+  priceMem: string;
+  // TyphonTypes.LanguageView is already a raw type
+  languageView: TyphonTypes.LanguageView;
+};
+
+/**
+ * Cardano account resources
+ */
+export type CardanoResources = {
+  externalCredentials: Array<PaymentCredential>;
+  internalCredentials: Array<PaymentCredential>;
+  utxos: Array<CardanoOutput>;
+  protocolParams: ProtocolParams;
+};
+
+/**
+ * Cardano account resources from raw JSON
+ */
+export type CardanoResourcesRaw = {
+  externalCredentials: Array<PaymentCredentialRaw>;
+  internalCredentials: Array<PaymentCredentialRaw>;
+  utxos: Array<CardanoOutputRaw>;
+  protocolParams: ProtocolParamsRaw;
+};
+
+/**
+ * Cardano transaction
+ */
+export type Transaction = TransactionCommon & {
+  mode: string;
+  family: "cardano";
+  fees?: BigNumber;
+  memo?: string;
+  // add here all transaction-specific fields if you implement other modes than "send"
+};
+
+/**
+ * Cardano transaction from a raw JSON
+ */
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "cardano";
+  mode: string;
+  fees?: string;
+  memo?: string;
+  // also the transaction fields as raw JSON data
+};
+
+export type CardanoLikeNetworkParameters = {
+  identifier: string;
+  networkId: number;
+  chainStartTime: number;
+  byronSlotDuration: number;
+  byronSlotsPerEpoch: number;
+  shelleyStartEpoch: number;
+  shelleySlotDuration: number;
+  shelleySlotsPerEpoch: number;
+  addressPrefix: string;
+};
+
+/**
+ * Cardano currency data that will be preloaded.
+ */
+export type CardanoPreloadData = {
+  protocolParams: ProtocolParams;
+};

package/src/families/ethereum/hw-signMessage.ts

@@ -36,11 +36,15 @@ const resolver: EthResolver = async (
   if (typeof message === "string") {
     result = await eth.signPersonalMessage(path, rawMessage.slice(2));
   } else {
-    result = await eth.signEIP712HashedMessage(
-      path,
-      bufferToHex(domainHash(message)),
-      bufferToHex(messageHash(message))
-    );
+    if (process.env.EXPERIMENTAL_EIP712) {
+      result = await eth.signEIP712Message(path, message);
+    } else {
+      result = await eth.signEIP712HashedMessage(
+        path,
+        bufferToHex(domainHash(message)),
+        bufferToHex(messageHash(message))
+      );
+    }
   }
 
   let v: string | number = result["v"] - 27;

package/src/families/filecoin/__snapshots__/bridge.test.ts.snap

@@ -0,0 +1,87 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`filecoin currency bridge scanAccounts filecoin seed 1 1`] = `
+Array [
+  Object {
+    "balance": "100000000000000000",
+    "currencyId": "filecoin",
+    "derivationMode": "",
+    "freshAddress": "f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a",
+    "freshAddressPath": "44'/461'/0'/0/0",
+    "freshAddresses": Array [
+      Object {
+        "address": "f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a",
+        "derivationPath": "44'/461'/0'/0/0",
+      },
+    ],
+    "id": "js:2:filecoin:f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a:",
+    "index": 0,
+    "name": "Filecoin 1",
+    "nfts": undefined,
+    "operationsCount": 1,
+    "pendingOperations": Array [],
+    "seedIdentifier": "04ca7b02cafdf36e8b4caaf530a96b949764af71b956b2a3328b7a10940794c860f574a9199be98bde3c261887fec8e5fd94bc5f104908bf5f992f52ef2a89abb0",
+    "spendableBalance": "100000000000000000",
+    "starred": false,
+    "swapHistory": Array [],
+    "syncHash": undefined,
+    "unitMagnitude": 18,
+    "used": true,
+  },
+  Object {
+    "balance": "0",
+    "currencyId": "filecoin",
+    "derivationMode": "",
+    "freshAddress": "f1n5rnuefec32bn2aoymugnoi7ah3xi2xynvltnqi",
+    "freshAddressPath": "44'/461'/1'/0/0",
+    "freshAddresses": Array [
+      Object {
+        "address": "f1n5rnuefec32bn2aoymugnoi7ah3xi2xynvltnqi",
+        "derivationPath": "44'/461'/1'/0/0",
+      },
+    ],
+    "id": "js:2:filecoin:f1n5rnuefec32bn2aoymugnoi7ah3xi2xynvltnqi:",
+    "index": 1,
+    "name": "Filecoin 2",
+    "nfts": undefined,
+    "operationsCount": 0,
+    "pendingOperations": Array [],
+    "seedIdentifier": "04ca7b02cafdf36e8b4caaf530a96b949764af71b956b2a3328b7a10940794c860f574a9199be98bde3c261887fec8e5fd94bc5f104908bf5f992f52ef2a89abb0",
+    "spendableBalance": "0",
+    "starred": false,
+    "swapHistory": Array [],
+    "syncHash": undefined,
+    "unitMagnitude": 18,
+    "used": false,
+  },
+]
+`;
+
+exports[`filecoin currency bridge scanAccounts filecoin seed 1 2`] = `
+Array [
+  Array [
+    Object {
+      "accountId": "js:2:filecoin:f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a:",
+      "blockHash": null,
+      "blockHeight": 1802367,
+      "contract": undefined,
+      "extra": Object {},
+      "fee": "0",
+      "hash": "bafy2bzaceaztepnzdzbul7nmkef6blk5x2luvbvangrjal25k6xi5qob36k32",
+      "id": "js:2:filecoin:f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a:-bafy2bzaceaztepnzdzbul7nmkef6blk5x2luvbvangrjal25k6xi5qob36k32-IN",
+      "operator": undefined,
+      "recipients": Array [
+        "f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a",
+      ],
+      "senders": Array [
+        "f1ov6d42tujoyexkbdh34oik2vhe5unqo2a5ocqoq",
+      ],
+      "standard": undefined,
+      "tokenId": undefined,
+      "type": "IN",
+      "value": "100000000000000000",
+    },
+  ],
+  Array [],
+]
+`;

package/src/families/filecoin/bridge/account.ts

@@ -29,7 +29,7 @@ import { Operation } from "../../../types/operation";
 import { calculateEstimatedFees, getPath, isError } from "../utils";
 import { log } from "@ledgerhq/logs";
 import { getAddressRaw, validateAddress } from "./utils/addresses";
-import { patchOperationWithHash } from "../../../operation";
+import { encodeOperationId, patchOperationWithHash } from "../../../operation";
 import { withDevice } from "../../../hw/deviceAccess";
 
 const receive = makeAccountBridgeReceive();
@@ -84,10 +84,12 @@ const getTransactionStatus = async (
   const estimatedFees = calculateEstimatedFees(gasFeeCap, gasLimit);
 
   const totalSpent = useAllAmount ? balance : amount.plus(estimatedFees);
-  amount = useAllAmount ? balance.minus(estimatedFees) : amount;
-
-  if (amount.lte(0)) errors.amount = new AmountRequired();
-  if (totalSpent.gt(a.spendableBalance)) errors.amount = new NotEnoughBalance();
+  if (totalSpent.gt(a.spendableBalance)) {
+    errors.amount = new NotEnoughBalance();
+  } else {
+    amount = useAllAmount ? balance.minus(estimatedFees) : amount;
+    if (amount.lte(0)) errors.amount = new AmountRequired();
+  }
 
   // log("debug", "[getTransactionStatus] finish fn");
 
@@ -114,29 +116,27 @@ const estimateMaxSpendable = async ({
   const a = getMainAccount(account, parentAccount);
   const { address } = getAddress(a);
 
+  const recipient = transaction?.recipient;
+
   if (!validateAddress(address).isValid) throw new InvalidAddress();
+  if (recipient && !validateAddress(recipient).isValid)
+    throw new InvalidAddress();
 
   const balances = await fetchBalances(address);
-
   const balance = new BigNumber(balances.spendable_balance);
 
-  const recipient = transaction?.recipient;
-  const amount = transaction?.amount;
-  if (recipient) {
-    log(
-      "debug",
-      "[estimateMaxSpendable] fetching estimated fees to adjust the real max spendable balance"
-    );
+  if (balance.eq(0)) return balance;
 
-    if (!validateAddress(recipient).isValid) throw new InvalidAddress();
+  const amount = transaction?.amount;
 
-    const result = await fetchEstimatedFees({ to: recipient, from: address });
-    const gasFeeCap = new BigNumber(result.gas_fee_cap);
-    const gasLimit = new BigNumber(result.gas_limit);
+  const result = await fetchEstimatedFees({ to: recipient, from: address });
+  const gasFeeCap = new BigNumber(result.gas_fee_cap);
+  const gasLimit = new BigNumber(result.gas_limit);
+  const estimatedFees = calculateEstimatedFees(gasFeeCap, gasLimit);
 
-    balance.minus(calculateEstimatedFees(gasFeeCap, gasLimit));
-  }
+  if (balance.lte(estimatedFees)) return new BigNumber(0);
 
+  balance.minus(estimatedFees);
   if (amount) balance.minus(amount);
 
   // log("debug", "[estimateMaxSpendable] finish fn");
@@ -269,7 +269,7 @@ const signOperation: SignOperationFnSignature<Transaction> = ({
             const signature = `${result.signature_compact.toString("base64")}`;
 
             const operation: Operation = {
-              id: `${accountId}-${txHash}-OUT`,
+              id: encodeOperationId(accountId, txHash, "OUT"),
               hash: txHash,
               type: "OUT",
               senders: [address],

package/src/families/filecoin/bridge/utils/types.ts

@@ -1,5 +1,5 @@
 export interface EstimatedFeesRequest {
-  to: string;
+  to?: string;
   from: string;
 }
 

package/src/families/filecoin/bridge/utils/utils.ts

@@ -11,6 +11,7 @@ import {
 } from "../../../../bridge/jsHelpers";
 import { fetchBalances, fetchBlockHeight, fetchTxs } from "./api";
 import { encodeAccountId } from "../../../../account";
+import { encodeOperationId } from "../../../../operation";
 import flatMap from "lodash/flatMap";
 
 type TxsById = {
@@ -48,7 +49,7 @@ export const processTxs = (
 };
 
 export const mapTxToOps =
-  (id, { address }: GetAccountShapeArg0) =>
+  (accountId, { address }: GetAccountShapeArg0) =>
   (tx: TransactionResponse): Operation[] => {
     const { to, from, hash, timestamp, amount, fee } = tx;
     const ops: Operation[] = [];
@@ -61,14 +62,14 @@ export const mapTxToOps =
 
     if (isSending) {
       ops.push({
-        id: `${id}-${hash}-OUT`,
+        id: encodeOperationId(accountId, hash, "OUT"),
         hash,
         type: "OUT",
         value: value.plus(feeToUse),
         fee: feeToUse,
         blockHeight: tx.height,
         blockHash: null,
-        accountId: id,
+        accountId,
         senders: [from],
         recipients: [to],
         date,
@@ -78,14 +79,14 @@ export const mapTxToOps =
 
     if (isReceiving) {
       ops.push({
-        id: `${id}-${hash}-IN`,
+        id: encodeOperationId(accountId, hash, "IN"),
         hash,
         type: "IN",
         value,
         fee: feeToUse,
         blockHeight: tx.height,
         blockHash: null,
-        accountId: id,
+        accountId,
         senders: [from],
         recipients: [to],
         date,
@@ -137,14 +138,14 @@ export const getTxToBroadcast = (
 };
 
 export const getAccountShape: GetAccountShape = async (info) => {
-  const { address, currency } = info;
+  const { address, currency, derivationMode } = info;
 
   const accountId = encodeAccountId({
     type: "js",
     version: "2",
     currencyId: currency.id,
     xpubOrAddress: address,
-    derivationMode: "",
+    derivationMode,
   });
 
   const blockHeight = await fetchBlockHeight();