@ledgerhq/coin-filecoin 1.3.2

package/src/bridge/buildOptimisticOperation.ts

@@ -0,0 +1,58 @@
+import { Account, Operation, OperationType } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { Transaction } from "../types";
+import { toCBORResponse } from "../bridge/serializer";
+import { calculateEstimatedFees } from "../bridge/utils";
+import { convertAddressEthToFil } from "../network";
+import { getSubAccount } from "../common-logic/utils";
+
+export const buildOptimisticOperation = async (
+  account: Account,
+  transaction: Transaction,
+  serializationRes: toCBORResponse,
+  operationType: OperationType = "OUT",
+): Promise<Operation> => {
+  const type = operationType;
+  const subAccount = getSubAccount(account, transaction);
+  // resolved at broadcast time
+  const txHash = "";
+  const { gasFeeCap, gasLimit } = transaction;
+  const { parsedSender, recipientToBroadcast, amountToBroadcast: finalAmount } = serializationRes;
+  const fee = calculateEstimatedFees(gasFeeCap, gasLimit);
+
+  let operation: Operation;
+  if (subAccount) {
+    const recipientFilAddr = convertAddressEthToFil(transaction.recipient);
+    operation = {
+      id: encodeOperationId(subAccount.id, txHash, "OUT"),
+      hash: txHash,
+      type,
+      value: finalAmount,
+      fee,
+      blockHeight: null,
+      blockHash: null,
+      accountId: subAccount.id,
+      senders: [parsedSender],
+      recipients: [recipientFilAddr],
+      date: new Date(),
+      extra: {},
+    };
+  } else {
+    operation = {
+      id: encodeOperationId(account.id, txHash, "OUT"),
+      hash: txHash,
+      type,
+      senders: [parsedSender],
+      recipients: [recipientToBroadcast],
+      accountId: account.id,
+      value: finalAmount.plus(fee),
+      fee,
+      blockHash: null,
+      blockHeight: null,
+      date: new Date(),
+      extra: {},
+    };
+  }
+
+  return operation;
+};

package/src/bridge/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/bridge/deviceTransactionConfig.ts

@@ -0,0 +1,119 @@
+import type { CommonDeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import type { Account, AccountLike, TokenAccount } from "@ledgerhq/types-live";
+import type { Transaction, TransactionStatus } from "../types";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import {
+  AccountType,
+  Methods,
+  expectedToFieldForTokenTransfer,
+  getAccountUnit,
+  methodToString,
+} from "./utils";
+import { validateAddress } from "../network";
+
+export type ExtraDeviceTransactionField =
+  | {
+      type: "filecoin.gasFeeCap";
+      label: string;
+      value: string;
+    }
+  | {
+      type: "filecoin.gasPremium";
+      label: string;
+      value: string;
+    }
+  | {
+      type: "filecoin.gasLimit";
+      label: string;
+      value: string;
+    }
+  | {
+      type: "filecoin.method";
+      label: string;
+      value: string;
+    }
+  | {
+      type: "filecoin.recipient";
+      label: string;
+      value: string;
+    };
+
+export type DeviceTransactionField = CommonDeviceTransactionField | ExtraDeviceTransactionField;
+
+function getDeviceTransactionConfig(input: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const tokenTransfer = input.account.type === AccountType.TokenAccount;
+  const subAccount = tokenTransfer ? (input.account as TokenAccount) : null;
+
+  const fields: Array<DeviceTransactionField> = [];
+  const unit = input.parentAccount
+    ? input.parentAccount.currency.units[0]
+    : getAccountUnit(input.account);
+  const formatConfig = {
+    disableRounding: true,
+    alwaysShowSign: false,
+    showCode: false,
+  };
+
+  if (subAccount) {
+    fields.push({
+      type: "filecoin.recipient",
+      label: "To",
+      value: expectedToFieldForTokenTransfer(input.transaction.recipient),
+    });
+  } else {
+    const recipient = input.transaction.recipient;
+    if (recipient.length >= 4 && recipient.substring(0, 4) === "0xff") {
+      const validated = validateAddress(recipient);
+      if (validated.isValid) {
+        const value = validated.parsedAddress.toString();
+        fields.push({
+          type: "filecoin.recipient",
+          label: "To",
+          value,
+        });
+      }
+    }
+  }
+
+  fields.push({
+    type: "filecoin.gasLimit",
+    label: "Gas Limit",
+    value: formatCurrencyUnit(unit, input.transaction.gasLimit, formatConfig),
+  });
+
+  if (!subAccount) {
+    fields.push({
+      type: "filecoin.gasFeeCap",
+      label: "Gas Fee Cap",
+      value: formatCurrencyUnit(unit, input.transaction.gasFeeCap, formatConfig),
+    });
+
+    fields.push({
+      type: "filecoin.gasPremium",
+      label: "Gas Premium",
+      value: formatCurrencyUnit(unit, input.transaction.gasPremium, formatConfig),
+    });
+    fields.push({
+      type: "filecoin.method",
+      label: "Method",
+      value: methodToString(input.transaction.method),
+    });
+  }
+
+  if (subAccount) {
+    fields.push({
+      type: "filecoin.method",
+      label: "Method",
+      value: methodToString(Methods.ERC20Transfer),
+    });
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/bridge/estimateMaxSpendable.ts

@@ -0,0 +1,120 @@
+import { AccountBridge, TokenAccount } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import { getAddress, getSubAccount } from "../common-logic";
+import { AccountType, Methods, calculateEstimatedFees } from "./utils";
+import {
+  InvalidAddress,
+  NotEnoughBalanceInParentAccount,
+  NotEnoughSpendableBalance,
+} from "@ledgerhq/errors";
+import { isFilEthAddress, validateAddress } from "../network";
+import { fetchBalances, fetchEstimatedFees } from "../api";
+import BigNumber from "bignumber.js";
+import { BroadcastBlockIncl } from "../types";
+import { encodeTxnParams, generateTokenTxnParams } from "../erc20/tokenAccounts";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}) => {
+  // log("debug", "[estimateMaxSpendable] start fn");
+  if (transaction && !transaction.subAccountId) {
+    transaction.subAccountId = account.type === "Account" ? null : account.id;
+  }
+
+  let tokenAccountTxn: boolean = false;
+  let subAccount: TokenAccount | undefined | null;
+  const a = getMainAccount(account, parentAccount);
+  if (account.type === AccountType.TokenAccount) {
+    tokenAccountTxn = true;
+    subAccount = account;
+  }
+  if (transaction && transaction.subAccountId && !subAccount) {
+    tokenAccountTxn = true;
+    subAccount = getSubAccount(a, transaction) ?? null;
+  }
+
+  let { address: sender } = getAddress(a);
+
+  let methodNum = Methods.Transfer;
+  let recipient = transaction?.recipient;
+
+  const invalidAddressErr = new InvalidAddress(undefined, {
+    currencyName: subAccount ? subAccount.token.name : 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) || tokenAccountTxn
+        ? Methods.InvokeEVM
+        : Methods.Transfer;
+  }
+
+  let balance = new BigNumber((await fetchBalances(sender)).spendable_balance);
+
+  if (balance.eq(0)) return balance;
+
+  const validatedContractAddress = validateAddress(subAccount?.token.contractAddress ?? "");
+  if (tokenAccountTxn && !validatedContractAddress.isValid) {
+    throw invalidAddressErr;
+  }
+  const contractAddress =
+    tokenAccountTxn && validatedContractAddress.isValid
+      ? validatedContractAddress.parsedAddress.toString()
+      : "";
+  const finalRecipient = tokenAccountTxn ? contractAddress : recipient;
+
+  // If token transfer, the evm payload is required to estimate fees
+  const params =
+    tokenAccountTxn && transaction && subAccount
+      ? generateTokenTxnParams(
+          contractAddress,
+          transaction.amount.isZero() ? BigNumber(1) : transaction.amount,
+        )
+      : undefined;
+
+  const result = await fetchEstimatedFees({
+    to: finalRecipient,
+    from: sender,
+    methodNum,
+    blockIncl: BroadcastBlockIncl,
+    ...(params && { params: encodeTxnParams(params) }), // If token transfer, the eth call params are required to estimate fees
+    ...(tokenAccountTxn && { value: "0" }), // If token transfer, the value should be 0 (avoid any native token transfer on fee estimation)
+  });
+
+  const gasFeeCap = new BigNumber(result.gas_fee_cap);
+  const gasLimit = new BigNumber(result.gas_limit);
+  const estimatedFees = calculateEstimatedFees(gasFeeCap, gasLimit);
+
+  if (balance.lte(estimatedFees)) {
+    if (tokenAccountTxn) {
+      throw new NotEnoughBalanceInParentAccount(undefined, {
+        currencyName: a.currency.name,
+      });
+    }
+
+    throw new NotEnoughSpendableBalance(undefined, {
+      currencyName: a.currency.name,
+    });
+  }
+  balance = balance.minus(estimatedFees);
+
+  if (tokenAccountTxn && subAccount) {
+    return subAccount.spendableBalance;
+  }
+  // log("debug", "[estimateMaxSpendable] finish fn");
+
+  return balance;
+};

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,80 @@
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  InvalidAddress,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
+import { Transaction, TransactionStatus } from "../types";
+import { isRecipientValidForTokenTransfer, validateAddress } from "../network";
+import { getAddress, getSubAccount } from "../common-logic";
+import { calculateEstimatedFees } from "./utils";
+import { InvalidRecipientForTokenTransfer } from "../errors";
+import BigNumber from "bignumber.js";
+
+export const getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
+  account: Account,
+  transaction: Transaction,
+): Promise<TransactionStatus> => {
+  // log("debug", "[getTransactionStatus] start fn");
+  const errors: TransactionStatus["errors"] = {};
+  const warnings: TransactionStatus["warnings"] = {};
+  const { balance } = account;
+  const { address } = getAddress(account);
+  const subAccount = getSubAccount(account, transaction);
+  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: BigNumber;
+  if (useAllAmount && !subAccount) {
+    totalSpent = account.spendableBalance;
+    amount = totalSpent.minus(estimatedFees);
+    if (amount.lte(0) || totalSpent.gt(balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  if (subAccount) {
+    totalSpent = estimatedFees;
+    if (totalSpent.gt(account.spendableBalance)) 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();
+  }
+
+  if (subAccount) {
+    const spendable = subAccount.spendableBalance;
+    if (transaction.amount.gt(spendable)) {
+      errors.amount = new NotEnoughBalance();
+    }
+    if (useAllAmount) {
+      amount = spendable;
+    }
+    totalSpent = amount;
+
+    if (recipient && !isRecipientValidForTokenTransfer(recipient)) {
+      errors.recipient = new InvalidRecipientForTokenTransfer();
+    }
+  }
+
+  // log("debug", "[getTransactionStatus] finish fn");
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};

package/src/bridge/index.ts

@@ -0,0 +1,63 @@
+import {
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import resolver from "../signer";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import type { Transaction, TransactionStatus, FilecoinSigner } from "../types";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { prepareTransaction } from "./prepareTransaction";
+import { createTransaction } from "./createTransaction";
+import { getAccountShape } from "../common-logic/utils";
+import { buildSignOperation } from "./signOperation";
+import { broadcast } from "./broadcast";
+
+function buildCurrencyBridge(signerContext: SignerContext<FilecoinSigner>): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddressWrapper(getAddress),
+  });
+
+  return {
+    preload: () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+}
+
+const sync = makeSync({ getAccountShape });
+
+function buildAccountBridge(
+  signerContext: SignerContext<FilecoinSigner>,
+): AccountBridge<Transaction, Account, TransactionStatus> {
+  const getAddress = resolver(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction: defaultUpdateTransaction,
+    getTransactionStatus,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+  };
+}
+
+export function createBridges(signerContext: SignerContext<FilecoinSigner>) {
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,82 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { isEthereumConvertableAddr, isFilEthAddress, validateAddress } from "../network";
+import { BroadcastBlockIncl, Transaction } from "../types";
+import { Methods, calculateEstimatedFees } from "./utils";
+import { fetchEstimatedFees } from "../api/index";
+import { getAddress, getSubAccount } from "../common-logic/utils";
+import { encodeTxnParams, generateTokenTxnParams } from "../erc20/tokenAccounts";
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  const { balance } = account;
+  const { address } = getAddress(account);
+  const { useAllAmount } = transaction;
+  const recipient = transaction.recipient.toLowerCase();
+
+  const subAccount = getSubAccount(account, transaction);
+  const tokenAccountTxn = !!subAccount;
+
+  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) || tokenAccountTxn
+          ? Methods.InvokeEVM
+          : Methods.Transfer;
+
+      const validatedContractAddress = validateAddress(subAccount?.token.contractAddress ?? "");
+      let finalRecipient = recipientValidation;
+      let params: string | undefined = undefined;
+      // used as fallback only for estimation of fees
+      let fallbackParams: string = "";
+      if (tokenAccountTxn && validatedContractAddress.isValid) {
+        finalRecipient = validatedContractAddress;
+        // If token transfer, the evm payload is required to estimate fees
+        if (isEthereumConvertableAddr(recipientValidation.parsedAddress)) {
+          params = generateTokenTxnParams(
+            recipient,
+            transaction.amount.isZero() ? BigNumber(1) : transaction.amount,
+          );
+        } else {
+          fallbackParams = generateTokenTxnParams(subAccount.token.contractAddress, BigNumber(1));
+        }
+      }
+
+      const paramsForEstimation = params ? params : fallbackParams;
+      const result = await fetchEstimatedFees({
+        to: finalRecipient.parsedAddress.toString(),
+        from: senderValidation.parsedAddress.toString(),
+        methodNum: method,
+        blockIncl: BroadcastBlockIncl,
+        ...(tokenAccountTxn && { params: encodeTxnParams(paramsForEstimation) }), // If token transfer, the eth call params are required to estimate fees
+        ...(tokenAccountTxn && { value: "0" }), // If token transfer, the value should be 0 (avoid any native token transfer on fee estimation)
+      });
+
+      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;
+      patch.params = params;
+
+      const fee = calculateEstimatedFees(patch.gasFeeCap, patch.gasLimit);
+      if (useAllAmount) {
+        patch.amount = subAccount ? subAccount.spendableBalance : balance.minus(fee);
+        patch.params =
+          tokenAccountTxn && params ? generateTokenTxnParams(recipient, patch.amount) : undefined;
+      }
+
+      return defaultUpdateTransaction(transaction, patch);
+    }
+  }
+
+  return transaction;
+};

package/src/bridge/serializer.ts

@@ -0,0 +1,63 @@
+import { Account } from "@ledgerhq/types-live";
+
+import { Transaction } from "../types";
+import { getAddress, getSubAccount } from "../common-logic/index";
+import { validateAddress } from "../network";
+import { Message } from "iso-filecoin/message";
+import { encodeTxnParams } from "../erc20/tokenAccounts";
+import BigNumber from "bignumber.js";
+import { AccountType } from "./utils";
+
+export interface toCBORResponse {
+  txPayload: Buffer;
+  recipientToBroadcast: string;
+  parsedSender: string;
+  encodedParams: string;
+  amountToBroadcast: BigNumber;
+}
+
+export const toCBOR = async (account: Account, tx: Transaction): Promise<toCBORResponse> => {
+  const { address: from } = getAddress(account);
+  const { method, version, nonce, gasLimit, gasPremium, gasFeeCap, amount, recipient } = tx;
+  const recipientValidation = validateAddress(recipient);
+  const fromValidation = validateAddress(from);
+
+  const subAccount = getSubAccount(account, tx);
+  const tokenTransfer = subAccount && subAccount.type === AccountType.TokenAccount;
+  const params = tokenTransfer ? encodeTxnParams(tx.params ?? "") : undefined;
+
+  if (!recipientValidation.isValid || !fromValidation.isValid)
+    throw new Error("recipient and/or from address are not valid");
+
+  let finalRecipient: string;
+  if (tokenTransfer) {
+    const validated = validateAddress(subAccount.token.contractAddress);
+    if (!validated.isValid) throw new Error("token contract address is not valid");
+    finalRecipient = validated.parsedAddress.toString();
+  } else {
+    finalRecipient = recipientValidation.parsedAddress.toString();
+  }
+
+  const finalAmount = tokenTransfer ? "0" : amount.toString();
+
+  const message = new Message({
+    to: finalRecipient,
+    from: fromValidation.parsedAddress.toString(),
+    gasFeeCap: gasFeeCap.toString(),
+    gasLimit: gasLimit.toNumber(),
+    gasPremium: gasPremium.toString(),
+    method,
+    nonce,
+    params,
+    version: version === 0 ? 0 : undefined,
+    value: finalAmount,
+  });
+
+  return {
+    txPayload: message.serialize(),
+    recipientToBroadcast: finalRecipient,
+    parsedSender: fromValidation.parsedAddress.toString(),
+    encodedParams: params ?? "",
+    amountToBroadcast: new BigNumber(finalAmount),
+  };
+};