@ledgerhq/coin-polkadot 0.0.2

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@ledgerhq/coin-polkadot",
+  "version": "0.0.2",
+  "description": "Ledger Polkadot Coin integration",
+  "keywords": [
+    "Ledger",
+    "LedgerWallet",
+    "dot",
+    "Polkadot",
+    "Hardware Wallet"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LedgerHQ/ledger-live.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LedgerHQ/ledger-live/issues"
+  },
+  "homepage": "https://github.com/LedgerHQ/ledger-live/tree/develop/libs/coin-polkadot",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/index.js",
+  "module": "lib-es/index.js",
+  "types": "lib/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "lib/*": [
+        "lib/*"
+      ],
+      "lib-es/*": [
+        "lib-es/*"
+      ],
+      "*": [
+        "lib/*"
+      ]
+    }
+  },
+  "exports": {
+    "./lib/*": "./lib/*.js",
+    "./lib-es/*": "./lib-es/*.js",
+    "./*": {
+      "require": "./lib/*.js",
+      "default": "./lib-es/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@ledgerhq/live-app-sdk": "^0.8.1",
+    "@polkadot/types": "9.8.1",
+    "@polkadot/types-known": "9.8.1",
+    "@polkadot/util": "10.3.1",
+    "@polkadot/util-crypto": "10.3.1",
+    "bignumber.js": "^9.1.0",
+    "expect": "^27.4.6",
+    "invariant": "^2.2.2",
+    "lodash": "^4.17.21",
+    "rxjs": "^6.6.7",
+    "@ledgerhq/coin-framework": "^0.0.2",
+    "@ledgerhq/cryptoassets": "^9.0.0",
+    "@ledgerhq/devices": "^8.0.0",
+    "@ledgerhq/errors": "^6.12.3",
+    "@ledgerhq/hw-app-polkadot": "^6.27.12",
+    "@ledgerhq/logs": "^6.10.1",
+    "@ledgerhq/types-cryptoassets": "^7.0.0",
+    "@ledgerhq/types-live": "^6.31.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.2.4",
+    "@typescript-eslint/eslint-plugin": "^5.46.1",
+    "@typescript-eslint/parser": "^5.46.1",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-config-typescript": "^3.0.0",
+    "eslint-formatter-pretty": "^3.0.1",
+    "eslint-plugin-prettier": "^3.4.0",
+    "eslint-plugin-typescript": "^0.14.0",
+    "jest": "^28.1.1",
+    "prettier": "^2.8.1",
+    "ts-jest": "^28.0.5",
+    "typescript": "^4.9.4"
+  },
+  "gitHead": "dd0dea64b58e5a9125c8a422dcffd29e5ef6abec",
+  "scripts": {
+    "clean": "rimraf lib lib-es",
+    "build": "tsc && tsc -m ES6 --outDir lib-es",
+    "prewatch": "pnpm build",
+    "watch": "tsc --watch",
+    "doc": "documentation readme src/** --section=API --pe ts --re ts --re d.ts",
+    "lint": "eslint ./src --no-error-on-unmatched-pattern --ext .ts,.tsx",
+    "lint:fix": "pnpm lint --fix",
+    "test": "jest"
+  }
+}

package/src/account.ts

@@ -0,0 +1,170 @@
+import invariant from "invariant";
+import { BigNumber } from "bignumber.js";
+import type { Operation } from "@ledgerhq/types-live";
+import { getAccountUnit } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { PolkadotAccount, PolkadotResources } from "./types";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+
+function formatOperationSpecifics(
+  op: Operation,
+  unit: Unit | null | undefined
+): string {
+  const {
+    validators,
+    bondedAmount,
+    unbondedAmount,
+    withdrawUnbondedAmount,
+    validatorStash,
+    amount,
+  } = op.extra;
+  let str = (validators || []).map((v) => `\n    ${v}`).join("");
+  const formatConfig = {
+    disableRounding: true,
+    alwaysShowSign: false,
+    showCode: true,
+  };
+  str +=
+    bondedAmount && !bondedAmount.isNaN()
+      ? `\n    bondedAmount: ${
+          unit
+            ? formatCurrencyUnit(unit, bondedAmount, formatConfig)
+            : bondedAmount
+        }`
+      : unbondedAmount && !unbondedAmount.isNaN()
+      ? `\n    unbondedAmount: ${
+          unit
+            ? formatCurrencyUnit(unit, unbondedAmount, formatConfig)
+            : unbondedAmount
+        }`
+      : withdrawUnbondedAmount && !withdrawUnbondedAmount.isNaN()
+      ? `\n    withdrawUnbondedAmount: ${
+          unit
+            ? formatCurrencyUnit(unit, withdrawUnbondedAmount, formatConfig)
+            : withdrawUnbondedAmount
+        }`
+      : "";
+  str += validatorStash ? `\n    validatorStash: ${validatorStash}` : "";
+  str += amount
+    ? `\n    amount: ${
+        unit ? formatCurrencyUnit(unit, amount, formatConfig) : amount
+      }`
+    : "";
+  return str;
+}
+
+function formatAccountSpecifics(account: PolkadotAccount): string {
+  const { polkadotResources } = account;
+  invariant(polkadotResources, "polkadot account expected");
+  const unit = getAccountUnit(account);
+  const formatConfig = {
+    disableRounding: true,
+    alwaysShowSign: false,
+    showCode: true,
+  };
+  let str = " ";
+  str +=
+    formatCurrencyUnit(unit, account.spendableBalance, formatConfig) +
+    " spendable. ";
+
+  if ((polkadotResources as PolkadotResources).lockedBalance.gt(0)) {
+    str +=
+      formatCurrencyUnit(
+        unit,
+        (polkadotResources as PolkadotResources).lockedBalance,
+        formatConfig
+      ) + " locked. ";
+  }
+
+  if ((polkadotResources as PolkadotResources).unlockedBalance.gt(0)) {
+    str +=
+      formatCurrencyUnit(
+        unit,
+        (polkadotResources as PolkadotResources).unlockedBalance,
+        formatConfig
+      ) + " unlocked. ";
+  }
+
+  if ((polkadotResources as PolkadotResources).stash) {
+    str += "\nstash : " + (polkadotResources as PolkadotResources).stash;
+  }
+
+  if ((polkadotResources as PolkadotResources).controller) {
+    str +=
+      "\ncontroller : " + (polkadotResources as PolkadotResources).controller;
+  }
+
+  if ((polkadotResources as PolkadotResources).nominations?.length) {
+    str += "\nNominations\n";
+    str += ((polkadotResources as PolkadotResources).nominations as any[])
+      .map((v) => `  to ${v.address}`)
+      .join("\n");
+  }
+
+  return str;
+}
+
+export function fromOperationExtraRaw(
+  extra: Record<string, any> | null | undefined
+) {
+  if (extra && extra.transferAmount) {
+    extra = { ...extra, transferAmount: extra.transferAmount.toString() };
+  }
+
+  if (extra && extra.bondedAmount) {
+    return { ...extra, bondedAmount: new BigNumber(extra.bondedAmount) };
+  }
+
+  if (extra && extra.unbondedAmount) {
+    return { ...extra, unbondedAmount: new BigNumber(extra.unbondedAmount) };
+  }
+
+  if (extra && extra.withdrawUnbondedAmount) {
+    return {
+      ...extra,
+      withdrawUnbondedAmount: new BigNumber(extra.withdrawUnbondedAmount),
+    };
+  }
+
+  // for subscan reward & slash
+  if (extra && extra.amount) {
+    return { ...extra, amount: new BigNumber(extra.amount) };
+  }
+
+  return extra;
+}
+export function toOperationExtraRaw(
+  extra: Record<string, any> | null | undefined
+) {
+  if (extra && extra.transferAmount) {
+    extra = { ...extra, transferAmount: extra.transferAmount.toString() };
+  }
+
+  if (extra && extra.bondedAmount) {
+    return { ...extra, bondedAmount: extra.bondedAmount.toString() };
+  }
+
+  if (extra && extra.unbondedAmount) {
+    return { ...extra, unbondedAmount: extra.unbondedAmount.toString() };
+  }
+
+  if (extra && extra.withdrawUnbondedAmount) {
+    return {
+      ...extra,
+      withdrawUnbondedAmount: extra.withdrawUnbondedAmount.toString(),
+    };
+  }
+
+  // for subscan reward & slash
+  if (extra && extra.amount) {
+    return { ...extra, amount: extra.amount.toString() };
+  }
+
+  return extra;
+}
+export default {
+  formatAccountSpecifics,
+  formatOperationSpecifics,
+  fromOperationExtraRaw,
+  toOperationExtraRaw,
+};

package/src/address.ts

@@ -0,0 +1,28 @@
+import { encodeAddress, decodeAddress } from "@polkadot/util-crypto";
+import { hexToU8a, isHex } from "@polkadot/util";
+
+const POLKADOT_SS58_PREFIX = 0;
+
+/**
+ * Returns true if address is valid, false if it's invalid (can't parse or wrong checksum)
+ *
+ * @param {*} address
+ */
+// TODO Cache this to improve perf
+export const isValidAddress = (
+  address: string,
+  ss58Format: number = POLKADOT_SS58_PREFIX
+): boolean => {
+  if (!address) return false;
+
+  try {
+    encodeAddress(
+      isHex(address)
+        ? hexToU8a(address)
+        : decodeAddress(address, false, ss58Format)
+    );
+    return true;
+  } catch (err) {
+    return false;
+  }
+};

package/src/api/bisontrails.ts

@@ -0,0 +1,343 @@
+import network from "@ledgerhq/coin-framework/network";
+import querystring from "querystring";
+import { BigNumber } from "bignumber.js";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { getEnv } from "@ledgerhq/coin-framework/env";
+import { getOperationType } from "./common";
+import type { OperationType, Operation } from "@ledgerhq/types-live";
+import { isValidAddress } from "../address";
+
+const LIMIT = 200;
+
+/**
+ * Return the url of the indexer
+ *
+ * @returns {string}
+ */
+const getBaseApiUrl = (): string => getEnv("API_POLKADOT_INDEXER");
+
+/**
+ * Fetch operation lists from indexer
+ *
+ * @param {string} addr
+ * @param {number} offset
+ * @param {number} startAt
+ * @param {number} limit
+ *
+ * @returns {string}
+ */
+const getAccountOperationUrl = (
+  addr: string,
+  offset: number,
+  startAt: number,
+  limit: number = LIMIT
+): string =>
+  `${getBaseApiUrl()}/accounts/${addr}/operations?${querystring.stringify({
+    limit,
+    offset,
+    startAt,
+  })}`;
+
+const getWithdrawUnbondedAmount = (extrinsic) => {
+  return (
+    extrinsic?.staking?.eventStaking.reduce((acc, curr) => {
+      return curr.method === "Withdrawn"
+        ? new BigNumber(acc).plus(curr.value)
+        : new BigNumber(0);
+    }, new BigNumber(0)) || new BigNumber(0)
+  );
+};
+
+const getController = (_extrinsic) => {
+  // TODO: ask BisonTrails to provide the info
+  return "";
+};
+
+/**
+ * add Extra info for operation details
+ *
+ * @param {OperationType} type
+ * @param {*} extrinsic
+ *
+ * @returns {Object}
+ */
+const getExtra = (type: OperationType, extrinsic: any): Record<string, any> => {
+  let extra: {
+    transferAmount?: BigNumber;
+    palletMethod: string;
+    bondedAmount?: BigNumber;
+    unbondedAmount?: BigNumber;
+    amount?: BigNumber;
+    withdrawUnbondedAmount?: any;
+    validatorStash?: any;
+    validators?: any;
+    controller?: any;
+  } = {
+    palletMethod: `${extrinsic.section}.${extrinsic.method}`,
+  };
+
+  switch (type) {
+    case "IN":
+    case "OUT":
+      if (extrinsic.amount || extrinsic.amount === 0) {
+        extra = { ...extra, transferAmount: new BigNumber(extrinsic.amount) };
+      }
+
+      break;
+
+    case "BOND":
+      if (extrinsic.amount || extrinsic.amount === 0) {
+        extra = { ...extra, bondedAmount: new BigNumber(extrinsic.amount) };
+      }
+
+      break;
+
+    case "UNBOND":
+      if (extrinsic.amount || extrinsic.amount === 0) {
+        extra = { ...extra, unbondedAmount: new BigNumber(extrinsic.amount) };
+      }
+
+      break;
+
+    case "WITHDRAW_UNBONDED":
+      extra = {
+        ...extra,
+        withdrawUnbondedAmount: getWithdrawUnbondedAmount(extrinsic),
+      };
+      break;
+
+    case "SET_CONTROLLER":
+      extra = {
+        ...extra,
+        controller: getController(extrinsic),
+      };
+      break;
+
+    case "REWARD_PAYOUT":
+    case "SLASH":
+      extra = {
+        ...extra,
+        validatorStash: extrinsic.validatorStash,
+        amount: new BigNumber(extrinsic.value),
+      };
+      break;
+
+    case "NOMINATE":
+      extra = {
+        ...extra,
+        validators:
+          extrinsic.staking?.validators?.reduce((acc, current) => {
+            return [...acc, current.address];
+          }, []) ?? [],
+      };
+      break;
+  }
+
+  return extra;
+};
+
+/**
+ * Returns the operation value (amount if relevant + fees) depending on type
+ *
+ * @param {*} extrinsic
+ * @param {OperationType} type
+ *
+ * @returns {BigNumber}
+ */
+const getValue = (extrinsic, type: OperationType): BigNumber => {
+  if (!extrinsic.isSuccess) {
+    return type === "IN"
+      ? new BigNumber(0)
+      : new BigNumber(extrinsic.partialFee || 0);
+  }
+
+  switch (type) {
+    case "OUT":
+      return extrinsic.signer !== extrinsic.affectedAddress1
+        ? new BigNumber(extrinsic.amount).plus(extrinsic.partialFee)
+        : new BigNumber(extrinsic.partialFee);
+
+    case "IN":
+    case "SLASH":
+      return new BigNumber(extrinsic.amount);
+
+    default:
+      return new BigNumber(extrinsic.partialFee);
+  }
+};
+
+/**
+ * Map extrinsic into the live operation type
+ *
+ * @param {string} addr
+ * @param {string} accountId
+ * @param {*} extrinsic
+ *
+ * @returns {Operation | null}
+ */
+const extrinsicToOperation = (
+  addr: string,
+  accountId: string,
+  extrinsic
+): Partial<Operation> | null => {
+  let type = getOperationType(extrinsic.section, extrinsic.method);
+
+  if (
+    type === "OUT" &&
+    extrinsic.affectedAddress1 === addr &&
+    extrinsic.signer !== addr
+  ) {
+    type = "IN";
+  }
+
+  if (type !== "IN" && extrinsic.signer !== addr) {
+    return null;
+  }
+
+  return {
+    id: encodeOperationId(accountId, extrinsic.hash, type),
+    accountId,
+    fee: new BigNumber(extrinsic.partialFee || 0),
+    value: getValue(extrinsic, type),
+    type,
+    hash: extrinsic.hash,
+    blockHeight: extrinsic.blockNumber,
+    date: new Date(extrinsic.timestamp),
+    extra: getExtra(type, extrinsic),
+    senders: [extrinsic.signer],
+    recipients: [extrinsic.affectedAddress1, extrinsic.affectedAddress2]
+      .filter(Boolean)
+      .filter(isValidAddress),
+    transactionSequenceNumber:
+      extrinsic.signer === addr ? extrinsic.nonce : undefined,
+    hasFailed: !extrinsic.isSuccess,
+  };
+};
+
+/**
+ * Map reward to live operation type
+ *
+ * @param {string} addr
+ * @param {string} accountId
+ * @param {*} reward
+ *
+ * @returns {Operation | null}
+ */
+const rewardToOperation = (
+  addr: string,
+  accountId: string,
+  reward
+): Partial<Operation> => {
+  const hash = reward.extrinsicHash;
+  const type = "REWARD_PAYOUT";
+  return {
+    id: encodeOperationId(accountId, `${hash}+${reward.index}`, type),
+    accountId,
+    fee: new BigNumber(0),
+    value: new BigNumber(reward.value),
+    type: type,
+    hash,
+    blockHeight: reward.blockNumber,
+    date: new Date(reward.timestamp),
+    extra: getExtra(type, reward),
+    senders: [reward.validatorStash].filter(Boolean),
+    recipients: [reward.accountId].filter(Boolean),
+  };
+};
+
+/**
+ * Map slash to live operation type
+ *
+ * @param {string} addr
+ * @param {string} accountId
+ * @param {*} slash
+ *
+ * @returns {Operation | null}
+ */
+const slashToOperation = (
+  addr: string,
+  accountId: string,
+  slash
+): Partial<Operation> => {
+  const hash = `${slash.blockNumber}`;
+  const type = "SLASH";
+  return {
+    id: encodeOperationId(accountId, `${hash}+${slash.index}`, type),
+    accountId,
+    fee: new BigNumber(0),
+    value: new BigNumber(slash.value),
+    type: type,
+    hash: hash,
+    blockHeight: slash.blockNumber,
+    senders: [slash.validatorStash].filter(Boolean),
+    recipients: [slash.accountId].filter(Boolean),
+    date: new Date(slash.timestamp),
+    extra: getExtra(type, slash),
+  };
+};
+
+/**
+ * Fetch loop with multiple operations per page / offsite / start
+ *
+ * @param {string} accountId
+ * @param {string} addr
+ * @param {number} startAt
+ * @param {number} offset
+ *
+ * @param {Operation[]} prevOperations
+ */
+const fetchOperationList = async (
+  accountId: string,
+  addr: string,
+  startAt: number,
+  offset = 0,
+  prevOperations: Operation[] = []
+) => {
+  const { data } = await network({
+    method: "GET",
+    url: getAccountOperationUrl(addr, offset, startAt),
+  });
+  const operations = data.extrinsics.map((extrinsic) =>
+    extrinsicToOperation(addr, accountId, extrinsic)
+  );
+  const rewards = data.rewards.map((reward) =>
+    rewardToOperation(addr, accountId, reward)
+  );
+  const slashes = data.slashes.map((slash) =>
+    slashToOperation(addr, accountId, slash)
+  );
+  const mergedOp = [...prevOperations, ...operations, ...rewards, ...slashes];
+
+  if (
+    operations.length < LIMIT &&
+    rewards.length < LIMIT &&
+    slashes.length < LIMIT
+  ) {
+    return mergedOp.filter(Boolean).sort((a, b) => b.date - a.date);
+  }
+
+  return await fetchOperationList(
+    accountId,
+    addr,
+    startAt,
+    offset + LIMIT,
+    mergedOp
+  );
+};
+
+/**
+ * Fetch all operations for a single account from indexer
+ *
+ * @param {string} accountId
+ * @param {string} addr
+ * @param {number} startAt - blockHeight after which you fetch this op (included)
+ *
+ * @return {Operation[]}
+ */
+export const getOperations = async (
+  accountId: string,
+  addr: string,
+  startAt = 0
+) => {
+  return await fetchOperationList(accountId, addr, startAt);
+};

package/src/api/common.ts

@@ -0,0 +1,52 @@
+import { log } from "@ledgerhq/logs";
+import type { OperationType } from "@ledgerhq/types-live";
+
+/**
+ * Returns the operation type by using his palletMethod
+ * the method case depends from which indexer you are using
+ *
+ * @param {*} pallet
+ * @param {*} palletMethod
+ *
+ * @returns {string} - OperationType
+ */
+export const getOperationType = (
+  pallet: string,
+  palletMethod: string
+): OperationType => {
+  switch (palletMethod) {
+    case "transfer":
+    case "transferKeepAlive":
+      return "OUT";
+
+    case "bond":
+    case "bondExtra":
+    case "rebond":
+      return "BOND";
+
+    case "unbond":
+      return "UNBOND";
+
+    case "nominate":
+      return "NOMINATE";
+
+    case "chill":
+      return "CHILL";
+
+    case "withdrawUnbonded":
+      return "WITHDRAW_UNBONDED";
+
+    case "setController":
+      return "SET_CONTROLLER";
+
+    case "payoutStakers":
+      return "FEES";
+
+    default:
+      log(
+        "polkadot/api",
+        `Unknown operation type ${pallet}.${palletMethod} - fallback to FEES`
+      );
+      return "FEES";
+  }
+};