@ledgerhq/coin-filecoin 1.3.2

package/src/errors.ts

@@ -0,0 +1,13 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+/*
+ * When the recipient is non f0, f4 or eth address during token transfer
+ */
+export const InvalidRecipientForTokenTransfer = createCustomErrorClass(
+  "InvalidRecipientForTokenTransfer",
+);
+
+/*
+ * When the fee estimation endpoint fails
+ */
+export const FilecoinFeeEstimationFailed = createCustomErrorClass("FilecoinFeeEstimationFailed");

package/src/hw-signMessage.ts

@@ -0,0 +1,27 @@
+import { log } from "@ledgerhq/logs";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { Account, AnyMessage } from "@ledgerhq/types-live";
+import { getBufferFromString } from "./bridge/utils";
+import { FilecoinSigner } from "./types";
+
+export const signMessage =
+  (signerContext: SignerContext<FilecoinSigner>) =>
+  async (deviceId: string, account: Account, { message }: AnyMessage) => {
+    log("debug", "start signMessage process");
+
+    if (typeof message !== "string") throw new Error("Invalid message type");
+    if (!message) throw new Error("Message cannot be empty");
+
+    const r = await signerContext(deviceId, signer =>
+      signer.sign(account.freshAddressPath, getBufferFromString(message)),
+    );
+
+    return {
+      rsv: {
+        r: Buffer.from(r.signature_compact.slice(0, 32)).toString("hex"),
+        s: Buffer.from(r.signature_compact.slice(32, 64)).toString("hex"),
+        v: parseInt(Buffer.from(r.signature_compact.slice(64, 65)).toString("hex"), 16),
+      },
+      signature: `0x${Buffer.from(r.signature_compact).toString("hex")}`,
+    };
+  };

package/src/index.ts

@@ -0,0 +1 @@
+export { createBridges } from "./bridge/index";

package/src/network/addresses.ts

@@ -0,0 +1,93 @@
+import {
+  IAddress,
+  PROTOCOL_INDICATOR,
+  fromEthAddress,
+  isEthAddress,
+  fromString,
+  toEthAddress,
+} from "iso-filecoin/address";
+import { log } from "@ledgerhq/logs";
+
+export type ValidateAddressResult =
+  | {
+      isValid: true;
+      parsedAddress: IAddress;
+    }
+  | {
+      isValid: false;
+    };
+
+export const isFilEthAddress = (addr: IAddress) =>
+  addr.protocol === PROTOCOL_INDICATOR.DELEGATED && addr.namespace === 10;
+
+export const isIdAddress = (addr: IAddress) => addr.protocol === PROTOCOL_INDICATOR.ID;
+
+export const isEthereumConvertableAddr = (addr: IAddress) =>
+  isIdAddress(addr) || isFilEthAddress(addr);
+
+export const validateAddress = (input: string): ValidateAddressResult => {
+  try {
+    const parsedAddress = fromString(input);
+    return { isValid: true, parsedAddress };
+  } catch (error) {
+    log("debug", `[validateAddress] fromString invalid address`);
+  }
+
+  try {
+    const parsedAddress = fromEthAddress(input, "mainnet");
+    return { isValid: true, parsedAddress };
+  } catch (error) {
+    log("debug", `[validateAddress] fromEthAddress invalid address`);
+  }
+
+  return { isValid: false };
+};
+
+export const isRecipientValidForTokenTransfer = (addr: string): boolean => {
+  if (addr.length < 2) {
+    return false;
+  }
+
+  const valid = validateAddress(addr);
+  if (!valid.isValid) {
+    return false;
+  }
+
+  if (isEthereumConvertableAddr(valid.parsedAddress)) {
+    return true;
+  }
+
+  return false;
+};
+
+export const getEquivalentAddress = (addr: string): string => {
+  if (isEthAddress(addr)) {
+    return fromEthAddress(addr, "mainnet").toString();
+  } else {
+    const parsed = fromString(addr);
+    if (isEthereumConvertableAddr(parsed)) {
+      return toEthAddress(parsed);
+    }
+    return "";
+  }
+};
+
+export const convertAddressFilToEth = (addr: string): string => {
+  if (isEthAddress(addr)) {
+    return addr;
+  }
+
+  const parsed = fromString(addr);
+  if (isEthereumConvertableAddr(parsed)) {
+    return toEthAddress(parsed);
+  }
+  throw new Error("address is not convertible to ethereum address");
+};
+
+export const convertAddressEthToFil = (addr: string): string => {
+  if (!isEthAddress(addr)) {
+    return addr;
+  }
+
+  return fromEthAddress(addr, "mainnet").toString();
+};

package/src/network/index.ts

@@ -0,0 +1 @@
+export * from "./addresses";

package/src/signer/getAddress.ts

@@ -0,0 +1,28 @@
+import { log } from "@ledgerhq/logs";
+
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { FilecoinSigner } from "../types";
+
+function resolver(signerContext: SignerContext<FilecoinSigner>): GetAddressFn {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    log("debug", "start getAddress process");
+
+    const { r } = await signerContext(deviceId, async signer => {
+      const r = verify
+        ? await signer.showAddressAndPubKey(path)
+        : await signer.getAddressAndPubKey(path);
+
+      return { r };
+    });
+
+    return {
+      path,
+      address: r.addrString,
+      publicKey: Buffer.from(r.compressed_pk).toString("hex"),
+    };
+  };
+}
+
+export default resolver;

package/src/signer/index.ts

@@ -0,0 +1,3 @@
+import resolver from "./getAddress";
+
+export default resolver;

package/src/test/bot-specs.ts

@@ -0,0 +1,163 @@
+import invariant from "invariant";
+import { DeviceModelId } from "@ledgerhq/devices";
+import BigNumber from "bignumber.js";
+import type { Transaction } from "../types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { botTest, genericTestDestination, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { generateDeviceActionFlow } from "./speculos-deviceActions";
+import { AccountType, BotScenario } from "../bridge/utils";
+
+const F4_RECIPIENT = "f410fncojwmrseefktoco6rcnb3zv2eiqfli7muhvqma";
+const ETH_RECIPIENT = "0x689c9b3232210aa9b84ef444d0ef35d11102ad1f";
+const MIN_SAFE = new BigNumber(100000);
+const maxAccount = 6;
+
+const filecoinSpecs: AppSpec<Transaction> = {
+  name: "Filecoin",
+  currency: getCryptoCurrencyById("filecoin"),
+  appQuery: {
+    model: DeviceModelId.nanoSP,
+    appName: "Filecoin",
+    appVersion: "0.24.3",
+  },
+  genericDeviceAction: generateDeviceActionFlow(BotScenario.DEFAULT),
+  testTimeout: 16 * 60 * 1000,
+  minViableAmount: MIN_SAFE,
+  transactionCheck: ({ maxSpendable }) => {
+    invariant(maxSpendable.gt(MIN_SAFE), "balance is too low");
+  },
+  mutations: [
+    {
+      name: "Send small to f4 address",
+      maxRun: 1,
+      deviceAction: generateDeviceActionFlow(BotScenario.F4_RECIPIENT),
+      testDestination: genericTestDestination,
+      transaction: ({ account, bridge }) => {
+        const amount = new BigNumber("100");
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              recipient: F4_RECIPIENT,
+            },
+            {
+              amount,
+            },
+          ],
+        };
+      },
+    },
+    {
+      name: "Send small to eth address",
+      maxRun: 1,
+      deviceAction: generateDeviceActionFlow(BotScenario.ETH_RECIPIENT),
+      testDestination: genericTestDestination,
+      transaction: ({ account, bridge }) => {
+        const amount = new BigNumber("100");
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              recipient: ETH_RECIPIENT,
+            },
+            {
+              amount,
+            },
+          ],
+        };
+      },
+    },
+    {
+      name: "Send 50%~",
+      maxRun: 1,
+      testDestination: genericTestDestination,
+      transaction: ({ account, siblings, bridge }) => {
+        const sibling = pickSiblings(siblings, maxAccount);
+        let amount = account.spendableBalance.div(1.9 + 0.2 * Math.random()).integerValue();
+
+        if (!sibling.used && amount.lt(MIN_SAFE)) {
+          invariant(account.spendableBalance.gt(MIN_SAFE), "send is too low to activate account");
+          amount = MIN_SAFE;
+        }
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              recipient: sibling.freshAddress,
+            },
+            {
+              amount,
+            },
+          ],
+        };
+      },
+    },
+    {
+      name: "Transfer Max",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge }) => {
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              recipient: pickSiblings(siblings, maxAccount).freshAddress,
+            },
+            {
+              useAllAmount: true,
+            },
+          ],
+        };
+      },
+    },
+    {
+      name: "Send ~50% WFIL",
+      maxRun: 1,
+      deviceAction: generateDeviceActionFlow(BotScenario.TOKEN_TRANSFER),
+      transaction: ({ account, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(0), "Spendable balance is too low");
+        const subAccount = account.subAccounts?.find(
+          a => a.type === AccountType.TokenAccount && a.spendableBalance.gt(0),
+        );
+        invariant(
+          subAccount && subAccount.type === AccountType.TokenAccount,
+          "no subAccount with WFIL",
+        );
+        const amount = subAccount.balance.div(1.9 + 0.2 * Math.random()).integerValue();
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              subAccountId: subAccount.id,
+            },
+            {
+              recipient: F4_RECIPIENT,
+            },
+            {
+              amount,
+            },
+          ],
+        };
+      },
+      test: ({ account, accountBeforeTransaction, transaction, status }) => {
+        const subAccountId = transaction.subAccountId;
+        const subAccount = account.subAccounts?.find(sa => sa.id === subAccountId);
+        const subAccountBeforeTransaction = accountBeforeTransaction.subAccounts?.find(
+          sa => sa.id === subAccountId,
+        );
+        botTest("subAccount balance moved with the tx status amount", () =>
+          expect(subAccount?.balance.toString()).toBe(
+            subAccountBeforeTransaction?.balance.minus(status.amount).toString(),
+          ),
+        );
+      },
+    },
+  ],
+};
+
+export default {
+  filecoinSpecs,
+};