@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

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

@@ -1,325 +1,19 @@
-import {
-  AmountRequired,
-  FeeNotLoaded,
-  InvalidAddress,
-  NotEnoughBalance,
-  RecipientRequired,
-} from "@ledgerhq/errors";
-import { BigNumber } from "bignumber.js";
-import Fil from "@zondax/ledger-filecoin";
-import { Observable } from "rxjs";
-
-import { makeAccountBridgeReceive, makeSync } from "../../../bridge/jsHelpers";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
 import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import {
-  Account,
-  AccountBridge,
-  AccountLike,
-  Operation,
-  BroadcastFnSignature,
-  SignOperationEvent,
-  SignOperationFnSignature,
-} from "@ledgerhq/types-live";
+import { makeAccountBridgeReceive, makeSync } from "../../../bridge/jsHelpers";
+import { getTransactionStatus } from "../getTransactionStatus";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { prepareTransaction } from "../prepareTransaction";
 import { Transaction, TransactionStatus } from "../types";
-import { getAccountShape, getAddress, getTxToBroadcast } from "./utils/utils";
-import { broadcastTx, fetchBalances, fetchEstimatedFees } from "./utils/api";
-import { BroadcastBlockIncl } from "./utils/types";
-import { getMainAccount } from "../../../account";
-import { close } from "../../../hw";
-import { toCBOR } from "./utils/serializer";
-import { Methods, calculateEstimatedFees, getPath, isError } from "../utils";
-import { log } from "@ledgerhq/logs";
-import { isFilEthAddress, validateAddress } from "./utils/addresses";
-import { encodeOperationId, patchOperationWithHash } from "../../../operation";
-import { withDevice } from "../../../hw/deviceAccess";
+import { createTransaction } from "../createTransaction";
+import { signOperation } from "../signOperation";
+import { getAccountShape } from "./utils/utils";
+import { broadcast } from "../broadcast";
 
 const receive = makeAccountBridgeReceive();
-
-const createTransaction = (): Transaction => {
-  // log("debug", "[createTransaction] creating base tx");
-
-  return {
-    family: "filecoin",
-    amount: new BigNumber(0),
-    method: 0,
-    version: 0,
-    nonce: 0,
-    gasLimit: new BigNumber(0),
-    gasFeeCap: new BigNumber(0),
-    gasPremium: new BigNumber(0),
-    recipient: "",
-    useAllAmount: false,
-  };
-};
-
-const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
-  // log("debug", "[getTransactionStatus] start fn");
-
-  const errors: TransactionStatus["errors"] = {};
-  const warnings: TransactionStatus["warnings"] = {};
-
-  const { balance } = a;
-  const { address } = getAddress(a);
-  const { recipient, useAllAmount, gasPremium, gasFeeCap, gasLimit } = t;
-  let { amount } = t;
-
-  const invalidAddressErr = new InvalidAddress(undefined, {
-    currencyName: a.currency.name,
-  });
-  if (!recipient) errors.recipient = new RecipientRequired();
-  else if (!validateAddress(recipient).isValid) errors.recipient = invalidAddressErr;
-  else if (!validateAddress(address).isValid) errors.sender = invalidAddressErr;
-
-  if (gasFeeCap.eq(0) || gasPremium.eq(0) || gasLimit.eq(0)) errors.gas = new FeeNotLoaded();
-
-  // This is the worst case scenario (the tx won't cost more than this value)
-  const estimatedFees = calculateEstimatedFees(gasFeeCap, gasLimit);
-
-  let totalSpent;
-  if (useAllAmount) {
-    totalSpent = a.spendableBalance;
-    amount = totalSpent.minus(estimatedFees);
-    if (amount.lte(0) || totalSpent.gt(balance)) {
-      errors.amount = new NotEnoughBalance();
-    }
-  } else {
-    totalSpent = amount.plus(estimatedFees);
-    if (amount.eq(0)) {
-      errors.amount = new AmountRequired();
-    } else if (totalSpent.gt(a.spendableBalance)) errors.amount = new NotEnoughBalance();
-  }
-
-  // log("debug", "[getTransactionStatus] finish fn");
-
-  return {
-    errors,
-    warnings,
-    estimatedFees,
-    amount,
-    totalSpent,
-  };
-};
-
-const estimateMaxSpendable = async ({
-  account,
-  parentAccount,
-  transaction,
-}: {
-  account: AccountLike;
-  parentAccount?: Account | null | undefined;
-  transaction?: Transaction | null | undefined;
-}): Promise<BigNumber> => {
-  // log("debug", "[estimateMaxSpendable] start fn");
-
-  const a = getMainAccount(account, parentAccount);
-  let { address: sender } = getAddress(a);
-
-  let methodNum = Methods.Transfer;
-  let recipient = transaction?.recipient;
-
-  const invalidAddressErr = new InvalidAddress(undefined, {
-    currencyName: a.currency.name,
-  });
-  const senderValidation = validateAddress(sender);
-  if (!senderValidation.isValid) throw invalidAddressErr;
-  sender = senderValidation.parsedAddress.toString();
-
-  if (recipient) {
-    const recipientValidation = validateAddress(recipient);
-    if (!recipientValidation.isValid) {
-      throw invalidAddressErr;
-    }
-    recipient = recipientValidation.parsedAddress.toString();
-
-    methodNum = isFilEthAddress(recipientValidation.parsedAddress)
-      ? Methods.InvokeEVM
-      : Methods.Transfer;
-  }
-
-  const balances = await fetchBalances(sender);
-  let balance = new BigNumber(balances.spendable_balance);
-
-  if (balance.eq(0)) return balance;
-
-  const amount = transaction?.amount;
-
-  const result = await fetchEstimatedFees({
-    to: recipient,
-    from: sender,
-    methodNum,
-    blockIncl: BroadcastBlockIncl,
-  });
-  const gasFeeCap = new BigNumber(result.gas_fee_cap);
-  const gasLimit = new BigNumber(result.gas_limit);
-  const estimatedFees = calculateEstimatedFees(gasFeeCap, gasLimit);
-
-  if (balance.lte(estimatedFees)) return new BigNumber(0);
-
-  balance = balance.minus(estimatedFees);
-  if (amount) balance = balance.minus(amount);
-
-  // log("debug", "[estimateMaxSpendable] finish fn");
-
-  return balance;
-};
-
-const prepareTransaction = async (a: Account, t: Transaction): Promise<Transaction> => {
-  const { balance } = a;
-  const { address } = getAddress(a);
-  const { recipient, useAllAmount } = t;
-
-  if (recipient && address) {
-    const recipientValidation = validateAddress(recipient);
-    const senderValidation = validateAddress(address);
-
-    if (recipientValidation.isValid && senderValidation.isValid) {
-      const patch: Partial<Transaction> = {};
-
-      const method = isFilEthAddress(recipientValidation.parsedAddress)
-        ? Methods.InvokeEVM
-        : Methods.Transfer;
-
-      const result = await fetchEstimatedFees({
-        to: recipientValidation.parsedAddress.toString(),
-        from: senderValidation.parsedAddress.toString(),
-        methodNum: method,
-        blockIncl: BroadcastBlockIncl,
-      });
-
-      patch.gasFeeCap = new BigNumber(result.gas_fee_cap);
-      patch.gasPremium = new BigNumber(result.gas_premium);
-      patch.gasLimit = new BigNumber(result.gas_limit);
-      patch.nonce = result.nonce;
-      patch.method = method;
-
-      const fee = calculateEstimatedFees(patch.gasFeeCap, patch.gasLimit);
-      if (useAllAmount) patch.amount = balance.minus(fee);
-
-      return defaultUpdateTransaction(t, patch);
-    }
-  }
-
-  return t;
-};
-
 const sync = makeSync({ getAccountShape });
 
-const broadcast: BroadcastFnSignature = async ({ signedOperation }) => {
-  // log("debug", "[broadcast] start fn");
-  const { operation, signature, rawData } = signedOperation;
-  const tx = getTxToBroadcast(operation, signature, rawData!);
-
-  const resp = await broadcastTx(tx);
-  const { hash } = resp;
-
-  const result = patchOperationWithHash(signedOperation.operation, hash);
-
-  // log("debug", "[broadcast] finish fn");
-
-  return result;
-};
-
-const signOperation: SignOperationFnSignature<Transaction> = ({
-  account,
-  deviceId,
-  transaction,
-}): Observable<SignOperationEvent> =>
-  withDevice(deviceId)(
-    transport =>
-      new Observable(o => {
-        async function main() {
-          // log("debug", "[signOperation] start fn");
-
-          const { method, version, nonce, gasFeeCap, gasLimit, gasPremium } = transaction;
-          const { amount } = transaction;
-          const { id: accountId } = account;
-          const { derivationPath } = getAddress(account);
-
-          if (!gasFeeCap.gt(0) || !gasLimit.gt(0)) {
-            log(
-              "debug",
-              `signOperation missingData --> gasFeeCap=${gasFeeCap} gasLimit=${gasLimit}`,
-            );
-            throw new FeeNotLoaded();
-          }
-
-          const filecoin = new Fil(transport);
-
-          try {
-            o.next({
-              type: "device-signature-requested",
-            });
-
-            const fee = calculateEstimatedFees(gasFeeCap, gasLimit);
-
-            // Serialize tx
-            const { txPayload, parsedSender, parsedRecipient } = toCBOR(account, transaction);
-
-            log("debug", `[signOperation] serialized CBOR tx: [${txPayload.toString("hex")}]`);
-
-            // Sign by device
-            const result = await filecoin.sign(getPath(derivationPath), txPayload);
-            isError(result);
-
-            o.next({
-              type: "device-signature-granted",
-            });
-
-            // resolved at broadcast time
-            const txHash = "";
-
-            // build signature on the correct format
-            const signature = `${result.signature_compact.toString("base64")}`;
-
-            const operation: Operation = {
-              id: encodeOperationId(accountId, txHash, "OUT"),
-              hash: txHash,
-              type: "OUT",
-              senders: [parsedSender],
-              recipients: [parsedRecipient],
-              accountId,
-              value: amount.plus(fee),
-              fee,
-              blockHash: null,
-              blockHeight: null,
-              date: new Date(),
-              extra: {},
-            };
-
-            // Necessary for broadcast
-            const additionalTxFields = {
-              gasLimit,
-              gasFeeCap,
-              gasPremium,
-              method,
-              version,
-              nonce,
-              signatureType: 1,
-            };
-
-            o.next({
-              type: "signed",
-              signedOperation: {
-                operation,
-                signature,
-                rawData: additionalTxFields,
-              },
-            });
-          } finally {
-            close(transport, deviceId);
-
-            // log("debug", "[signOperation] finish fn");
-          }
-        }
-
-        main().then(
-          () => o.complete(),
-          e => o.error(e),
-        );
-      }),
-  );
-
-export const accountBridge: AccountBridge<Transaction> = {
+export const accountBridge: AccountBridge<Transaction, Account, TransactionStatus> = {
   createTransaction,
   updateTransaction: defaultUpdateTransaction,
   prepareTransaction,

package/src/families/filecoin/broadcast.ts

@@ -0,0 +1,20 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import { getTxToBroadcast } from "./bridge/utils/utils";
+import { broadcastTx } from "./bridge/utils/api";
+import { Transaction } from "./types";
+
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({ signedOperation }) => {
+  // log("debug", "[broadcast] start fn");
+  const { operation, signature, rawData } = signedOperation;
+  const tx = getTxToBroadcast(operation, signature, rawData!);
+
+  const resp = await broadcastTx(tx);
+  const { hash } = resp;
+
+  const result = patchOperationWithHash(signedOperation.operation, hash);
+
+  // log("debug", "[broadcast] finish fn");
+
+  return result;
+};

package/src/families/filecoin/buildOptimisticOperation.ts

@@ -0,0 +1,32 @@
+import { Account, Operation, OperationType } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { Transaction } from "./types";
+import { toCBOR } from "./bridge/utils/serializer";
+import { calculateEstimatedFees } from "./utils";
+
+export const buildOptimisticOperation = (
+  account: Account,
+  transaction: Transaction,
+  operationType: OperationType = "OUT",
+): Operation => {
+  const { id: accountId } = account;
+  // resolved at broadcast time
+  const hash = "";
+  const { parsedSender, parsedRecipient } = toCBOR(account, transaction);
+  const fee = calculateEstimatedFees(transaction.gasFeeCap, transaction.gasLimit);
+
+  return {
+    id: encodeOperationId(accountId, hash, operationType),
+    hash,
+    type: "OUT",
+    senders: [parsedSender],
+    recipients: [parsedRecipient],
+    accountId,
+    value: transaction.amount.plus(fee),
+    fee,
+    blockHash: null,
+    blockHeight: null,
+    date: new Date(),
+    extra: {},
+  };
+};

package/src/families/filecoin/createTransaction.ts

@@ -0,0 +1,20 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+import BigNumber from "bignumber.js";
+
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => {
+  // log("debug", "[createTransaction] creating base tx");
+
+  return {
+    family: "filecoin",
+    amount: new BigNumber(0),
+    method: 0,
+    version: 0,
+    nonce: 0,
+    gasLimit: new BigNumber(0),
+    gasFeeCap: new BigNumber(0),
+    gasPremium: new BigNumber(0),
+    recipient: "",
+    useAllAmount: false,
+  };
+};

package/src/families/filecoin/estimateMaxSpendable.ts

@@ -0,0 +1,69 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+import { getMainAccount } from "../../account";
+import { getAddress } from "./bridge/utils/utils";
+import { Methods, calculateEstimatedFees } from "./utils";
+import { InvalidAddress } from "@ledgerhq/errors";
+import { isFilEthAddress, validateAddress } from "./bridge/utils/addresses";
+import { fetchBalances, fetchEstimatedFees } from "./bridge/utils/api";
+import BigNumber from "bignumber.js";
+import { BroadcastBlockIncl } from "./bridge/utils/types";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}) => {
+  // log("debug", "[estimateMaxSpendable] start fn");
+
+  const mainAccount = getMainAccount(account, parentAccount);
+  let { address: sender } = getAddress(mainAccount);
+
+  let methodNum = Methods.Transfer;
+  let recipient = transaction?.recipient;
+
+  const invalidAddressErr = new InvalidAddress(undefined, {
+    currencyName: mainAccount.currency.name,
+  });
+  const senderValidation = validateAddress(sender);
+  if (!senderValidation.isValid) throw invalidAddressErr;
+  sender = senderValidation.parsedAddress.toString();
+
+  if (recipient) {
+    const recipientValidation = validateAddress(recipient);
+    if (!recipientValidation.isValid) {
+      throw invalidAddressErr;
+    }
+    recipient = recipientValidation.parsedAddress.toString();
+
+    methodNum = isFilEthAddress(recipientValidation.parsedAddress)
+      ? Methods.InvokeEVM
+      : Methods.Transfer;
+  }
+
+  const balances = await fetchBalances(sender);
+  let balance = new BigNumber(balances.spendable_balance);
+
+  if (balance.eq(0)) return balance;
+
+  const amount = transaction?.amount;
+
+  const result = await fetchEstimatedFees({
+    to: recipient,
+    from: sender,
+    methodNum,
+    blockIncl: BroadcastBlockIncl,
+  });
+  const gasFeeCap = new BigNumber(result.gas_fee_cap);
+  const gasLimit = new BigNumber(result.gas_limit);
+  const estimatedFees = calculateEstimatedFees(gasFeeCap, gasLimit);
+
+  if (balance.lte(estimatedFees)) return new BigNumber(0);
+
+  balance = balance.minus(estimatedFees);
+  if (amount) balance = balance.minus(amount);
+
+  // log("debug", "[estimateMaxSpendable] finish fn");
+
+  return balance;
+};

package/src/families/filecoin/getTransactionStatus.ts

@@ -0,0 +1,63 @@
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  InvalidAddress,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction, TransactionStatus } from "./types";
+import { validateAddress } from "./bridge/utils/addresses";
+import { getAddress } from "./bridge/utils/utils";
+import { calculateEstimatedFees } from "./utils";
+
+export const getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
+  account,
+  transaction,
+) => {
+  // log("debug", "[getTransactionStatus] start fn");
+
+  const errors: TransactionStatus["errors"] = {};
+  const warnings: TransactionStatus["warnings"] = {};
+
+  const { balance } = account;
+  const { address } = getAddress(account);
+  const { recipient, useAllAmount, gasPremium, gasFeeCap, gasLimit } = transaction;
+  let { amount } = transaction;
+
+  const invalidAddressErr = new InvalidAddress(undefined, {
+    currencyName: account.currency.name,
+  });
+  if (!recipient) errors.recipient = new RecipientRequired();
+  else if (!validateAddress(recipient).isValid) errors.recipient = invalidAddressErr;
+  else if (!validateAddress(address).isValid) errors.sender = invalidAddressErr;
+
+  if (gasFeeCap.eq(0) || gasPremium.eq(0) || gasLimit.eq(0)) errors.gas = new FeeNotLoaded();
+
+  // This is the worst case scenario (the tx won't cost more than this value)
+  const estimatedFees = calculateEstimatedFees(gasFeeCap, gasLimit);
+
+  let totalSpent;
+  if (useAllAmount) {
+    totalSpent = account.spendableBalance;
+    amount = totalSpent.minus(estimatedFees);
+    if (amount.lte(0) || totalSpent.gt(balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  } else {
+    totalSpent = amount.plus(estimatedFees);
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    } else if (totalSpent.gt(account.spendableBalance)) errors.amount = new NotEnoughBalance();
+  }
+
+  // log("debug", "[getTransactionStatus] finish fn");
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};

package/src/families/filecoin/prepareTransaction.ts

@@ -0,0 +1,51 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { isFilEthAddress, validateAddress } from "./bridge/utils/addresses";
+import { BroadcastBlockIncl } from "./bridge/utils/types";
+import { Methods, calculateEstimatedFees } from "./utils";
+import { fetchEstimatedFees } from "./bridge/utils/api";
+import { getAddress } from "./bridge/utils/utils";
+import { Transaction } from "./types";
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  const { balance } = account;
+  const { address } = getAddress(account);
+  const { recipient, useAllAmount } = transaction;
+
+  if (recipient && address) {
+    const recipientValidation = validateAddress(recipient);
+    const senderValidation = validateAddress(address);
+
+    if (recipientValidation.isValid && senderValidation.isValid) {
+      const patch: Partial<Transaction> = {};
+
+      const method = isFilEthAddress(recipientValidation.parsedAddress)
+        ? Methods.InvokeEVM
+        : Methods.Transfer;
+
+      const result = await fetchEstimatedFees({
+        to: recipientValidation.parsedAddress.toString(),
+        from: senderValidation.parsedAddress.toString(),
+        methodNum: method,
+        blockIncl: BroadcastBlockIncl,
+      });
+
+      patch.gasFeeCap = new BigNumber(result.gas_fee_cap);
+      patch.gasPremium = new BigNumber(result.gas_premium);
+      patch.gasLimit = new BigNumber(result.gas_limit);
+      patch.nonce = result.nonce;
+      patch.method = method;
+
+      const fee = calculateEstimatedFees(patch.gasFeeCap, patch.gasLimit);
+      if (useAllAmount) patch.amount = balance.minus(fee);
+
+      return defaultUpdateTransaction(transaction, patch);
+    }
+  }
+
+  return transaction;
+};

package/src/families/filecoin/signOperation.ts

@@ -0,0 +1,92 @@
+import { Observable } from "rxjs";
+import { log } from "@ledgerhq/logs";
+import Fil from "@zondax/ledger-filecoin";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { AccountBridge, SignOperationEvent } from "@ledgerhq/types-live";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { withDevice } from "../../hw/deviceAccess";
+import { toCBOR } from "./bridge/utils/serializer";
+import { getAddress } from "./bridge/utils/utils";
+import { getPath, isError } from "./utils";
+import { Transaction } from "./types";
+import { close } from "../../hw";
+
+export const signOperation: AccountBridge<Transaction>["signOperation"] = ({
+  account,
+  deviceId,
+  transaction,
+}): Observable<SignOperationEvent> =>
+  withDevice(deviceId)(
+    transport =>
+      new Observable(o => {
+        async function main() {
+          // log("debug", "[signOperation] start fn");
+
+          const { method, version, nonce, gasFeeCap, gasLimit, gasPremium } = transaction;
+          const { derivationPath } = getAddress(account);
+
+          if (!gasFeeCap.gt(0) || !gasLimit.gt(0)) {
+            log(
+              "debug",
+              `signOperation missingData --> gasFeeCap=${gasFeeCap} gasLimit=${gasLimit}`,
+            );
+            throw new FeeNotLoaded();
+          }
+
+          const filecoin = new Fil(transport);
+
+          try {
+            o.next({
+              type: "device-signature-requested",
+            });
+
+            // Serialize tx
+            const { txPayload } = toCBOR(account, transaction);
+
+            log("debug", `[signOperation] serialized CBOR tx: [${txPayload.toString("hex")}]`);
+
+            // Sign by device
+            const result = await filecoin.sign(getPath(derivationPath), txPayload);
+            isError(result);
+
+            o.next({
+              type: "device-signature-granted",
+            });
+
+            // build signature on the correct format
+            const signature = `${result.signature_compact.toString("base64")}`;
+
+            const operation = buildOptimisticOperation(account, transaction);
+
+            // Necessary for broadcast
+            const additionalTxFields = {
+              gasLimit,
+              gasFeeCap,
+              gasPremium,
+              method,
+              version,
+              nonce,
+              signatureType: 1,
+            };
+
+            o.next({
+              type: "signed",
+              signedOperation: {
+                operation,
+                signature,
+                rawData: additionalTxFields,
+              },
+            });
+          } finally {
+            close(transport, deviceId);
+
+            // log("debug", "[signOperation] finish fn");
+          }
+        }
+
+        main().then(
+          () => o.complete(),
+          e => o.error(e),
+        );
+      }),
+  );