@ledgerhq/coin-filecoin 1.3.2

package/src/bridge/signOperation.ts

@@ -0,0 +1,97 @@
+import { Observable } from "rxjs";
+import { log } from "@ledgerhq/logs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { Account, AccountBridge, Operation } from "@ledgerhq/types-live";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { toCBOR } from "./serializer";
+import { getAddress, getSubAccount } from "../common-logic/utils";
+import { AccountType } from "./utils";
+import { Transaction, FilecoinSigner } from "../types";
+
+export const buildSignOperation =
+  (
+    signerContext: SignerContext<FilecoinSigner>,
+  ): AccountBridge<Transaction, Account>["signOperation"] =>
+  ({ account, deviceId, transaction }) =>
+    new Observable(o => {
+      async function main() {
+        const { method, version, nonce, gasFeeCap, gasLimit, gasPremium } = transaction;
+        const { derivationPath } = getAddress(account);
+        const subAccount = getSubAccount(account, transaction);
+        const tokenAccountTxn = subAccount?.type === AccountType.TokenAccount;
+
+        if (!gasFeeCap.gt(0) || !gasLimit.gt(0)) {
+          log("debug", `signOperation missingData --> gasFeeCap=${gasFeeCap} gasLimit=${gasLimit}`);
+          throw new FeeNotLoaded();
+        }
+
+        o.next({
+          type: "device-signature-requested",
+        });
+
+        // Serialize tx
+        const toCBORResponse = await toCBOR(account, transaction);
+        const {
+          txPayload,
+          parsedSender,
+          recipientToBroadcast,
+          encodedParams,
+          amountToBroadcast: finalAmount,
+        } = toCBORResponse;
+
+        log("debug", `[signOperation] serialized CBOR tx: [${txPayload.toString("hex")}]`);
+
+        // Sign by device
+        const { r } = await signerContext(deviceId, async signer => {
+          const r = await signer.sign(derivationPath, txPayload);
+          return { r };
+        });
+
+        o.next({
+          type: "device-signature-granted",
+        });
+
+        if (!r.signature_compact) {
+          throw new Error("Signature compact is null");
+        }
+        // build signature on the correct format
+        const signature = `${Buffer.from(r.signature_compact).toString("base64")}`;
+
+        const operation: Operation = await buildOptimisticOperation(
+          account,
+          transaction,
+          toCBORResponse,
+        );
+
+        // Necessary for broadcast
+        const additionalTxFields = {
+          sender: parsedSender,
+          recipient: recipientToBroadcast,
+          params: encodedParams,
+          gasLimit,
+          gasFeeCap,
+          gasPremium,
+          method,
+          version,
+          nonce,
+          signatureType: 1,
+          tokenTransfer: tokenAccountTxn,
+          value: finalAmount.toString(),
+        };
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature,
+            rawData: additionalTxFields,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

package/src/bridge/transaction.ts

@@ -0,0 +1,69 @@
+import type { Transaction, TransactionRaw } from "../types";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import BigNumber from "bignumber.js";
+
+export const formatTransaction = (
+  { recipient, useAllAmount, amount }: Transaction,
+  account: Account,
+): string => `
+SEND ${
+  useAllAmount
+    ? "MAX"
+    : amount.isZero()
+      ? ""
+      : " " +
+        formatCurrencyUnit(getAccountCurrency(account).units[0], amount, {
+          showCode: true,
+          disableRounding: true,
+        })
+}
+TO ${recipient}`;
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    family: tr.family,
+    version: tr.version,
+    method: tr.method,
+    nonce: tr.nonce,
+    amount: new BigNumber(tr.amount),
+    gasFeeCap: new BigNumber(tr.gasFeeCap),
+    gasLimit: new BigNumber(tr.gasLimit),
+    gasPremium: new BigNumber(tr.gasPremium),
+  };
+};
+
+const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+
+  return {
+    ...common,
+    method: t.method,
+    version: t.version,
+    family: t.family,
+    nonce: t.nonce,
+    amount: t.amount.toFixed(),
+    gasFeeCap: t.gasFeeCap.toString(),
+    gasLimit: t.gasLimit.toNumber(),
+    gasPremium: t.gasPremium.toString(),
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/bridge/utils.ts

@@ -0,0 +1,73 @@
+import { AccountLike } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { getEquivalentAddress } from "../network";
+
+export enum Methods {
+  Transfer = 0,
+  ERC20Transfer = 1,
+  InvokeEVM = 3844450837,
+}
+
+export enum AccountType {
+  Account = "Account",
+  TokenAccount = "TokenAccount",
+}
+
+export enum BotScenario {
+  DEFAULT = "default",
+  ETH_RECIPIENT = "eth-recipient",
+  F4_RECIPIENT = "f4-recipient",
+  TOKEN_TRANSFER = "token-transfer",
+}
+
+const validHexRegExp = new RegExp(/^(0x)?[a-fA-F0-9]+$/);
+const validBase64RegExp = new RegExp(
+  /^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{3}=|[A-Za-z\d+/]{2}==)?$/,
+);
+
+// TODO Filecoin - Use the new package @zondax/ledger-utils instead
+
+export const isValidHex = (msg: string) => validHexRegExp.test(msg) && msg.length % 2 === 0;
+export const isValidBase64 = (msg: string) => validBase64RegExp.test(msg);
+
+export const methodToString = (method: number): string => {
+  switch (method) {
+    case Methods.Transfer:
+      return "Transfer";
+    case Methods.InvokeEVM:
+      return "InvokeEVM (3844450837)";
+    case Methods.ERC20Transfer:
+      return "ERC20 Transfer";
+    default:
+      return "Unknown";
+  }
+};
+
+export const getBufferFromString = (message: string): Buffer =>
+  isValidHex(message)
+    ? Buffer.from(message, "hex")
+    : isValidBase64(message)
+      ? Buffer.from(message, "base64")
+      : Buffer.from(message);
+
+export const calculateEstimatedFees = (gasFeeCap: BigNumber, gasLimit: BigNumber): BigNumber =>
+  gasFeeCap.multipliedBy(gasLimit);
+
+export function getAccountUnit(account: AccountLike) {
+  if (account.type === AccountType.TokenAccount) {
+    return account.token.units[0];
+  }
+
+  return account.currency.units[0];
+}
+
+export const expectedToFieldForTokenTransfer = (recipient: string) => {
+  let value = recipient;
+  const equivalent = getEquivalentAddress(value);
+
+  if (equivalent && value != equivalent) {
+    value += ` / ${equivalent}`;
+  }
+
+  return value;
+};

package/src/bridge/utils.unit.test.ts

@@ -0,0 +1,27 @@
+import { isValidBase64, isValidHex, methodToString } from "./utils";
+
+test("methodToString", () => {
+  const str1 = methodToString(0);
+  expect(str1).toBe("Transfer");
+  const str2 = methodToString(3844450837);
+  expect(str2).toBe("InvokeEVM (3844450837)");
+  const str3 = methodToString(5649856);
+  expect(str3).toBe("Unknown");
+});
+
+test("isValidHex", () => {
+  expect(isValidHex("0x0001aaeeff")).toBeTruthy();
+  expect(isValidHex("0001aaeeff")).toBeTruthy();
+  expect(isValidHex("0x0001rreeta")).toBeFalsy();
+  expect(isValidHex("0x0001aaeef")).toBeFalsy();
+});
+
+test("isValidBase64", () => {
+  expect(isValidBase64("YXNkYWZhc2Rmc2Rm")).toBeTruthy();
+  expect(
+    isValidBase64(
+      "YXNmZHNhZGZzYWRmYXNkZnNhZGZzYWRmYXNkZnNhZGYyNTEyMzQxMjIzcjZmYXM0MmZhczJkMTNhc2M=",
+    ),
+  ).toBeTruthy();
+  expect(isValidBase64("asdasd````")).toBeFalsy();
+});

package/src/common-logic/index.ts

@@ -0,0 +1,10 @@
+export {
+  getUnit,
+  processTxs,
+  mapTxToOps,
+  getAddress,
+  getTxToBroadcast,
+  getAccountShape,
+  getSubAccount,
+  valueFromUnit,
+} from "./utils";

package/src/common-logic/utils.ts

@@ -0,0 +1,232 @@
+import { Account, Operation } from "@ledgerhq/types-live";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+import { log } from "@ledgerhq/logs";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { BigNumber } from "bignumber.js";
+import { BroadcastTransactionRequest, TransactionResponse, TxStatus, Transaction } from "../types";
+import { GetAccountShape, AccountShapeInfo } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { fetchBalances, fetchBlockHeight, fetchTxs } from "../api/api";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import flatMap from "lodash/flatMap";
+import { buildTokenAccounts } from "../erc20/tokenAccounts";
+
+type TxsById = {
+  [id: string]:
+    | {
+        Send: TransactionResponse;
+        Fee?: TransactionResponse;
+      }
+    | {
+        InvokeContract: TransactionResponse;
+        Fee?: TransactionResponse;
+      };
+};
+
+export const getUnit = () => getCryptoCurrencyById("filecoin").units[0];
+
+export const processTxs = (txs: TransactionResponse[]): TransactionResponse[] => {
+  // Group all tx types related to same tx cid into the same object
+  const txsByTxCid = txs.reduce((txsByTxCidResult: TxsById, currentTx) => {
+    const { hash: txCid, type: txType } = currentTx;
+    const txByType = txsByTxCidResult[txCid] || {};
+    switch (txType) {
+      case "Send":
+        (txByType as { Send: TransactionResponse }).Send = currentTx;
+        break;
+      case "InvokeContract":
+        (txByType as { InvokeContract: TransactionResponse }).InvokeContract = currentTx;
+        break;
+      case "Fee":
+        (txByType as { Fee?: TransactionResponse }).Fee = currentTx;
+        break;
+      default:
+        log("warn", `tx type [${txType}] on tx cid [${txCid}] was not recognized.`);
+        break;
+    }
+
+    txsByTxCidResult[txCid] = txByType;
+    return txsByTxCidResult;
+  }, {});
+
+  // Once all tx types have been grouped, we want to find
+  const processedTxs: TransactionResponse[] = [];
+  for (const txCid in txsByTxCid) {
+    const item = txsByTxCid[txCid];
+    const feeTx = item.Fee;
+    let mainTx: TransactionResponse | undefined;
+    if ("Send" in item) {
+      mainTx = item.Send;
+    } else if ("InvokeContract" in item) {
+      mainTx = item.InvokeContract;
+    } else {
+      log(
+        "warn",
+        `unexpected tx type, tx with cid [${txCid}] and payload [${JSON.stringify(item)}]`,
+      );
+    }
+
+    if (!mainTx) {
+      if (feeTx) {
+        log("warn", `feeTx [${feeTx.hash}] found without a mainTx linked to it.`);
+      }
+
+      continue;
+    }
+
+    if (feeTx) {
+      mainTx.fee = feeTx.amount;
+    }
+
+    processedTxs.push(mainTx);
+  }
+
+  return processedTxs;
+};
+
+export const mapTxToOps =
+  (accountId: string, { address }: AccountShapeInfo) =>
+  (tx: TransactionResponse): Operation[] => {
+    const { to, from, hash, timestamp, amount, fee, status } = tx;
+    const ops: Operation[] = [];
+    const date = new Date(timestamp * 1000);
+    const value = parseCurrencyUnit(getUnit(), amount.toString());
+    const feeToUse = parseCurrencyUnit(getUnit(), (fee || 0).toString());
+
+    const isSending = address === from;
+    const isReceiving = address === to;
+    const hasFailed = status !== TxStatus.Ok;
+
+    if (isSending) {
+      const type = value.eq(0) ? "FEES" : "OUT";
+      ops.push({
+        id: encodeOperationId(accountId, hash, type),
+        hash,
+        type,
+        value: value.plus(feeToUse),
+        fee: feeToUse,
+        blockHeight: tx.height,
+        blockHash: null,
+        accountId,
+        senders: [from],
+        recipients: [to],
+        date,
+        extra: {},
+        hasFailed,
+      });
+    }
+
+    if (isReceiving) {
+      const type = value.eq(0) ? "FEES" : "IN";
+      ops.push({
+        id: encodeOperationId(accountId, hash, type),
+        hash,
+        type,
+        value,
+        fee: feeToUse,
+        blockHeight: tx.height,
+        blockHash: null,
+        accountId,
+        senders: [from],
+        recipients: [to],
+        date,
+        extra: {},
+        hasFailed,
+      });
+    }
+
+    return ops;
+  };
+
+export const getAddress = (
+  a: Account,
+): {
+  address: string;
+  derivationPath: string;
+} => ({ address: a.freshAddress, derivationPath: a.freshAddressPath });
+
+export const getTxToBroadcast = (
+  operation: Operation,
+  signature: string,
+  rawData: Record<string, any>,
+): BroadcastTransactionRequest => {
+  const {
+    sender,
+    recipient,
+    gasLimit,
+    gasFeeCap,
+    gasPremium,
+    method,
+    version,
+    nonce,
+    signatureType,
+    params,
+    value,
+  } = rawData;
+
+  return {
+    message: {
+      version,
+      method,
+      nonce,
+      params: params ?? "",
+      to: recipient,
+      from: sender,
+      gaslimit: gasLimit.toNumber(),
+      gaspremium: gasPremium.toString(),
+      gasfeecap: gasFeeCap.toString(),
+      value,
+    },
+    signature: {
+      type: signatureType,
+      data: signature,
+    },
+  };
+};
+
+export const getAccountShape: GetAccountShape = async info => {
+  const { address, currency, derivationMode } = info;
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+
+  const blockHeight = await fetchBlockHeight();
+  const balance = await fetchBalances(address);
+  const rawTxs = await fetchTxs(address);
+  const tokenAccounts = await buildTokenAccounts(address, accountId, info.initialAccount);
+
+  const result: Partial<Account> = {
+    id: accountId,
+    subAccounts: tokenAccounts,
+    balance: new BigNumber(balance.total_balance),
+    spendableBalance: new BigNumber(balance.spendable_balance),
+    operations: flatMap(processTxs(rawTxs), mapTxToOps(accountId, info)).sort(
+      (a, b) => b.date.getTime() - a.date.getTime(),
+    ),
+    blockHeight: blockHeight.current_block_identifier.index,
+  };
+  return result;
+};
+
+export const getSubAccount = (account: Account, tx: Transaction) => {
+  const subAccount =
+    tx.subAccountId && account.subAccounts
+      ? account.subAccounts.find(sa => sa.id === tx.subAccountId)
+      : null;
+
+  return subAccount;
+};
+
+/**
+ * convert a value in a given unit to a normalized value
+ * For instance, for 1 BTC, valueFromUnit(1, btcUnit) returns 100000000
+ * @memberof countervalue
+ */
+export const valueFromUnit = (valueInUnit: BigNumber, unit: Unit) =>
+  valueInUnit.times(new BigNumber(10).pow(unit.magnitude));

package/src/erc20/ERC20.json

@@ -0,0 +1,12 @@
+[
+  {
+    "inputs": [
+      { "internalType": "address", "name": "recipient", "type": "address" },
+      { "internalType": "uint256", "name": "amount", "type": "uint256" }
+    ],
+    "name": "transfer",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]

package/src/erc20/tokenAccounts.ts

@@ -0,0 +1,183 @@
+import cbor from "@zondax/cbor";
+import { Account, Operation, TokenAccount } from "@ledgerhq/types-live";
+import { fetchERC20TokenBalance, fetchERC20Transactions } from "../api";
+import invariant from "invariant";
+import { ERC20Transfer, TxStatus } from "../types";
+import { emptyHistoryCache, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets/tokens";
+import { log } from "@ledgerhq/logs";
+import BigNumber from "bignumber.js";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { convertAddressFilToEth } from "../network";
+import { ethers } from "ethers";
+import contractABI from "./ERC20.json";
+import { RecipientRequired } from "@ledgerhq/errors";
+import { Unit } from "@ledgerhq/types-cryptoassets";
+import { AccountType } from "../bridge/utils";
+import { valueFromUnit } from "../common-logic/utils";
+
+export const erc20TxnToOperation = (
+  tx: ERC20Transfer,
+  address: string,
+  accountId: string,
+  unit: Unit,
+): Operation[] => {
+  try {
+    const { to, from, timestamp, tx_hash, tx_cid, amount, height, status } = tx;
+    const value = valueFromUnit(new BigNumber(amount), unit);
+
+    const isSending = address.toLowerCase() === from.toLowerCase();
+    const isReceiving = address.toLowerCase() === to.toLowerCase();
+
+    const fee = new BigNumber(0);
+
+    const date = new Date(timestamp * 1000);
+    const hash = tx_cid ?? tx_hash;
+    const hasFailed = status !== TxStatus.Ok;
+
+    const ops: Operation[] = [];
+    if (isSending) {
+      ops.push({
+        id: encodeOperationId(accountId, hash, "OUT"),
+        hash,
+        type: "OUT",
+        value: value,
+        fee,
+        blockHeight: height,
+        blockHash: "",
+        accountId,
+        senders: [from],
+        recipients: [to],
+        date,
+        hasFailed,
+        extra: {},
+      });
+    }
+
+    if (isReceiving) {
+      ops.push({
+        id: encodeOperationId(accountId, hash, "IN"),
+        hash,
+        type: "IN",
+        value,
+        fee,
+        blockHeight: height,
+        blockHash: "",
+        accountId,
+        senders: [from],
+        recipients: [to],
+        date,
+        hasFailed,
+        extra: {},
+      });
+    }
+
+    invariant(ops, "filecoin operation is not defined");
+
+    return ops;
+  } catch (e) {
+    log("error", "filecoin error converting erc20 transaction to operation", e);
+    return [];
+  }
+};
+
+export async function buildTokenAccounts(
+  filAddr: string,
+  parentAccountId: string,
+  initialAccount?: Account,
+): Promise<TokenAccount[]> {
+  try {
+    const transfers = await fetchERC20Transactions(filAddr);
+    const transfersUntangled: { [addr: string]: ERC20Transfer[] } = transfers.reduce(
+      (prev: { [addr: string]: ERC20Transfer[] }, curr: ERC20Transfer) => {
+        curr.contract_address = curr.contract_address.toLowerCase();
+        if (prev[curr.contract_address]) {
+          prev[curr.contract_address] = [...prev[curr.contract_address], curr];
+        } else {
+          prev[curr.contract_address] = [curr];
+        }
+        return prev;
+      },
+      {},
+    );
+
+    const subs: TokenAccount[] = [];
+    for (const [cAddr, txns] of Object.entries(transfersUntangled)) {
+      const token = findTokenByAddressInCurrency(cAddr, "filecoin");
+      if (!token) {
+        log("error", `filecoin token not found, addr: ${cAddr}`);
+        continue;
+      }
+
+      const balance = await fetchERC20TokenBalance(filAddr, cAddr);
+      const bnBalance = new BigNumber(balance.toString());
+      const tokenAccountId = encodeTokenAccountId(parentAccountId, token);
+
+      const operations = txns
+        .flatMap(txn => erc20TxnToOperation(txn, filAddr, tokenAccountId, token.units[0]))
+        .flat()
+        .sort((a, b) => b.date.getTime() - a.date.getTime());
+
+      if (operations.length === 0 && bnBalance.isZero()) {
+        continue;
+      }
+
+      const maybeExistingSubAccount =
+        initialAccount &&
+        initialAccount.subAccounts &&
+        initialAccount.subAccounts.find(a => a.id === tokenAccountId);
+
+      const sub: TokenAccount = {
+        type: AccountType.TokenAccount,
+        id: tokenAccountId,
+        parentId: parentAccountId,
+        token,
+        balance: bnBalance,
+        spendableBalance: bnBalance,
+        operationsCount: txns.length,
+        operations,
+        pendingOperations: maybeExistingSubAccount ? maybeExistingSubAccount.pendingOperations : [],
+        creationDate: operations.length > 0 ? operations[0].date : new Date(),
+        swapHistory: maybeExistingSubAccount ? maybeExistingSubAccount.swapHistory : [],
+        balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
+      };
+
+      subs.push(sub);
+    }
+
+    return subs;
+  } catch (e) {
+    log("error", "filecoin error building token accounts", e);
+    return [];
+  }
+}
+
+export const encodeTxnParams = (abiEncodedParams: string) => {
+  log("debug", `filecoin/abiEncodedParams: ${abiEncodedParams}`);
+  if (!abiEncodedParams) {
+    throw new Error("Cannot encode empty abi encoded params");
+  }
+
+  const buffer = Buffer.from(abiEncodedParams.slice(2), "hex"); // buffer/byte array
+  const dataEncoded = cbor.encode(buffer);
+
+  return dataEncoded.toString("base64");
+};
+
+export const abiEncodeTransferParams = (recipient: string, amount: string) => {
+  const contract = new ethers.utils.Interface(contractABI);
+  const data = contract.encodeFunctionData("transfer", [recipient, amount]);
+  return data;
+};
+
+export const generateTokenTxnParams = (recipient: string, amount: BigNumber) => {
+  log("debug", "generateTokenTxnParams", { recipient, amount: amount.toString() });
+
+  if (!recipient) {
+    throw new RecipientRequired();
+  }
+
+  recipient = convertAddressFilToEth(recipient);
+
+  return abiEncodeTransferParams(recipient, amount.toString());
+};