@ledgerhq/coin-polkadot 0.0.2

package/src/cache.ts

@@ -0,0 +1,202 @@
+import { Extrinsics } from "@polkadot/types/metadata/decorate/types";
+import { BigNumber } from "bignumber.js";
+import { TypeRegistry } from "@polkadot/types";
+import { makeLRUCache } from "@ledgerhq/coin-framework/cache";
+import type { CacheRes } from "@ledgerhq/coin-framework/cache";
+import type { PolkadotAccount, Transaction } from "./types";
+import {
+  isNewAccount as apiIsNewAccount,
+  isControllerAddress as apiIsControllerAddress,
+  isElectionClosed as apiIsElectionClosed,
+  getRegistry as apiGetRegistry,
+  getTransactionParams as apiGetTransactionParams,
+  paymentInfo as apiPaymentInfo,
+  getMinimumBondBalance as apiGetMinimumBondBalance,
+} from "./api";
+
+/**
+ * Create a hash for a transaction that is params-specific and stay unchanged if no influcing fees
+ *
+ * @param {*} a
+ * @param {*} t
+ *
+ * @returns {string} hash
+ */
+const hashTransactionParams = (
+  a: PolkadotAccount,
+  t: Transaction,
+  signedTx: string
+) => {
+  // Nonce is added to discard previous estimation when account is synced.
+  const prefix = `${a.id}_${a.polkadotResources?.nonce || 0}_${t.mode}`;
+  // Fees depends on extrinsic bytesize
+  const byteSize = signedTx.length;
+
+  // And on extrinsic weight (which varies with the method called)
+  switch (t.mode) {
+    case "send":
+      return `${prefix}_${byteSize}`;
+
+    case "bond":
+      return t.rewardDestination
+        ? `${prefix}_${byteSize}_${t.rewardDestination}`
+        : `${prefix}_${byteSize}`;
+
+    case "unbond":
+    case "rebond":
+      return `${prefix}_${byteSize}`;
+
+    case "nominate":
+      return `${prefix}_${t.validators?.length ?? "0"}`;
+
+    case "withdrawUnbonded":
+      return `${prefix}_${t.numSlashingSpans ?? "0"}`;
+
+    case "chill":
+      return `${prefix}`;
+    case "setController":
+      return `${prefix}`;
+    case "claimReward":
+      return `${prefix}_${t.era || "0"}`;
+
+    default:
+      throw new Error("Unknown mode in transaction");
+  }
+};
+
+/**
+ * Cache the getTransactionInfo for fees estimation to avoid multiple calls during 5 minutes.
+ * Should be force refresh when signing operation.
+ *
+ * @param {Account} account
+ *
+ * @returns {Promise<Object>} txInfo
+ */
+export const getTransactionParams: CacheRes<
+  Array<void>,
+  Record<string, any>
+> = makeLRUCache(
+  async (): Promise<Record<string, any>> => apiGetTransactionParams(),
+  () => "polkadot",
+  {
+    ttl: 5 * 60 * 1000, // 5 minutes
+  }
+);
+
+/**
+ * Cache the payment info (fee estimate), with a hash depending on fees-changing transaction params and tx size.
+ *
+ * @param {PolkadotAccount} arg1.a
+ * @param {Transaction} arg1.t
+ *
+ * @returns {Promise<BigBumber>}
+ */
+export const getPaymentInfo: CacheRes<
+  Array<{
+    a: PolkadotAccount;
+    t: Transaction;
+    signedTx: string;
+  }>,
+  {
+    partialFee: string;
+  }
+> = makeLRUCache(
+  async ({
+    signedTx,
+  }): Promise<{
+    partialFee: string;
+  }> => {
+    return await apiPaymentInfo(signedTx);
+  },
+  ({ a, t, signedTx }) => hashTransactionParams(a, t, signedTx),
+  {
+    ttl: 5 * 60 * 1000, // 5 minutes
+  }
+);
+export const getRegistry: CacheRes<
+  Array<void>,
+  { registry: TypeRegistry; extrinsics: Extrinsics }
+> = makeLRUCache(
+  async (): Promise<{
+    registry: TypeRegistry;
+    extrinsics: Extrinsics;
+  }> => {
+    return await apiGetRegistry();
+  },
+  () => "polkadot",
+  {
+    ttl: 60 * 60 * 1000, // 1 hour - could be Infinity
+  }
+);
+
+/**
+ * Cache the isNewAccount to avoid multiple calls get checking tx status.
+ *
+ * @param {string} address
+ *
+ * @returns {Promise<boolean>}
+ */
+export const isNewAccount: CacheRes<Array<string>, boolean> = makeLRUCache(
+  async (address): Promise<boolean> => {
+    return apiIsNewAccount(address);
+  },
+  (address) => address,
+  {
+    ttl: 60 * 1000, // 1 minute
+  }
+);
+
+/**
+ * Cache the isControllerAddress to avoid multiple calls get checking tx status.
+ *
+ * @param {string} address
+ *
+ * @returns {Promise<boolean>}
+ */
+export const isControllerAddress: CacheRes<
+  Array<string>,
+  boolean
+> = makeLRUCache(
+  async (address): Promise<boolean> => {
+    return apiIsControllerAddress(address);
+  },
+  (address) => address,
+  {
+    ttl: 5 * 60 * 1000, // 5 minutes
+  }
+);
+
+/**
+ * Cache the isElectionClosed to avoid multiple calls get checking tx status.
+ * Should be unused if currency is preloaded.
+ *
+ * @returns {Promise<boolean>}
+ */
+export const isElectionClosed: CacheRes<Array<void>, boolean> = makeLRUCache(
+  async (): Promise<boolean> => {
+    return apiIsElectionClosed();
+  },
+  () => "",
+  {
+    ttl: 60 * 1000, // 1 minute
+  }
+);
+
+/**
+ * Cache the getMinimumBondBalance to avoid too many calls
+ *
+ * @async
+ *
+ * @returns {Promise<BigNumber>} consts
+ */
+export const getMinimumBondBalance: CacheRes<
+  Array<void>,
+  BigNumber
+> = makeLRUCache(
+  async (): Promise<BigNumber> => apiGetMinimumBondBalance(),
+  () => "polkadot",
+  {
+    max: 1, // Store only one object since we only have polkadot.
+    ttl: 60 * 60 * 1000, // 1 hour
+  }
+);

package/src/cli-transaction.ts

@@ -0,0 +1,184 @@
+import { from, Observable } from "rxjs";
+import { map } from "rxjs/operators";
+import { getValidators } from "./validators";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import { isAccount } from "@ledgerhq/coin-framework/account/index";
+import {
+  getCryptoCurrencyById,
+  formatCurrencyUnit,
+} from "@ledgerhq/coin-framework/currencies/index";
+import {
+  SidecarValidatorsParamAddresses,
+  SidecarValidatorsParamStatus,
+} from "./api/sidecar.types";
+import { AccountLike } from "@ledgerhq/types-live";
+import { PolkadotAccount, Transaction } from "./types";
+const options = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send, nominate, bond, claimReward, withdrawUnbonded",
+  },
+  {
+    name: "fees",
+    type: String,
+    desc: "how much fees",
+  },
+  {
+    name: "validator",
+    type: String,
+    multiple: true,
+    desc: "address of recipient validator that will receive the delegate",
+  },
+  {
+    name: "era",
+    type: String,
+    desc: "Era of when to claim rewards",
+  },
+  /** Different possible destionation :
+  Staked - Pay into the stash account, increasing the amount at stake accordingly.
+  Stash - Pay into the stash account, not increasing the amount at stake.
+  Account - Pay into a custom account, like so: Account DMTHrNcmA8QbqRS4rBq8LXn8ipyczFoNMb1X4cY2WD9tdBX.
+  Controller - Pay into the controller account.
+ */
+  {
+    name: "rewardDestination",
+    type: String,
+    desc: "Reward destination",
+  },
+];
+const polkadotValidatorsFormatters = {
+  json: (list) => JSON.stringify(list),
+  csv: (list) => {
+    const polkadotUnit = getCryptoCurrencyById("polkadot").units[0];
+    const csvHeader =
+      "ADDRESS IDENTITY TOTAL_BONDED SELF_BONDED NOMINATORS_COUNT COMMISSION REWARD_POINTS\n";
+    const csvList = list
+      .map(
+        (v) =>
+          `${v.address} "${v.identity}" ${formatCurrencyUnit(
+            polkadotUnit,
+            v.totalBonded,
+            {
+              showCode: false,
+              disableRounding: true,
+              useGrouping: false,
+            }
+          )} ${formatCurrencyUnit(polkadotUnit, v.selfBonded, {
+            showCode: false,
+            disableRounding: true,
+            useGrouping: false,
+          })} ${v.nominatorsCount} ${v.commission
+            .multipliedBy(100)
+            .toFixed(2)} ${v.rewardPoints}`
+      )
+      .join("\n");
+    return csvHeader + csvList;
+  },
+  default: (list) => {
+    const polkadotUnit = getCryptoCurrencyById("polkadot").units[0];
+    const tableList = list
+      .map(
+        (v) =>
+          `${v.address} "${v.identity}" ${formatCurrencyUnit(
+            polkadotUnit,
+            v.totalBonded,
+            {
+              showCode: true,
+              disableRounding: true,
+              useGrouping: false,
+            }
+          )} ${formatCurrencyUnit(polkadotUnit, v.selfBonded, {
+            showCode: true,
+            disableRounding: true,
+            useGrouping: false,
+          })} ${v.nominatorsCount} ${
+            v.commission.multipliedBy(100).toFixed(2) + "%"
+          } ${v.rewardPoints + " PTS"}`
+      )
+      .join("\n");
+    return tableList;
+  },
+};
+const polkadotValidators = {
+  args: [
+    {
+      name: "format",
+      desc: Object.keys(polkadotValidatorsFormatters).join("|"),
+      type: String,
+    },
+    {
+      name: "status",
+      desc: "The status of the validators to fetch (all|elected|waiting)",
+      type: String,
+    },
+    {
+      name: "validator",
+      type: String,
+      multiple: true,
+      desc: "address of recipient validator that will receive the delegate",
+    },
+  ],
+  job: ({
+    format,
+    status,
+    validator,
+  }: Partial<{
+    format: string;
+    status: SidecarValidatorsParamStatus | SidecarValidatorsParamAddresses;
+    validator: string[];
+  }>): Observable<string> =>
+    from(
+      getValidators(validator && validator.length ? validator : status)
+    ).pipe(
+      map((validators) => {
+        const f =
+          (format && polkadotValidatorsFormatters[format]) ||
+          polkadotValidatorsFormatters.default;
+        return f(validators);
+      })
+    ),
+};
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: Record<string, any>,
+  { inferAmount }: any
+): Transaction[] {
+  return flatMap(transactions, ({ transaction, account }) => {
+    invariant(transaction.family === "polkadot", "polkadot family");
+
+    if (isAccount(account)) {
+      invariant(
+        (account as PolkadotAccount).polkadotResources,
+        "unactivated account"
+      );
+    }
+
+    const validators: string[] = opts["validator"] || [];
+    return {
+      ...transaction,
+      family: "polkadot",
+      fees: opts.fees ? inferAmount(account, opts.fees) : null,
+      mode: opts.mode || "send",
+      validators,
+      era: opts.era || null,
+      rewardDestination: opts.rewardDestination || null,
+      numSlashingSpans: isAccount(account)
+        ? (account as PolkadotAccount).polkadotResources?.numSlashingSpans
+        : null,
+    };
+  });
+}
+
+export default {
+  options,
+  inferTransactions,
+  commands: {
+    polkadotValidators,
+  },
+};

package/src/deviceTransactionConfig.ts

@@ -0,0 +1,209 @@
+import type { AccountLike, Account } from "@ledgerhq/types-live";
+import type { PolkadotAccount, Transaction, TransactionStatus } from "./types";
+import type { CommonDeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import {
+  formatCurrencyUnit,
+  getCryptoCurrencyById,
+} from "@ledgerhq/coin-framework/currencies/index";
+import { isStash } from "./logic";
+const currency = getCryptoCurrencyById("polkadot");
+export type ExtraDeviceTransactionField = {
+  type: "polkadot.validators";
+  label: string;
+};
+type DeviceTransactionField = CommonDeviceTransactionField &
+  ExtraDeviceTransactionField;
+
+const getSendFields = ({
+  transaction,
+  status: { amount },
+}: {
+  transaction: Transaction;
+  status: TransactionStatus;
+}) => {
+  const fields: { type: string; label: string; value: string }[] = [];
+  fields.push({
+    type: "text",
+    label: "Balances",
+    value:
+      transaction && transaction.useAllAmount
+        ? "Transfer"
+        : "Transfer keep alive",
+  });
+  fields.push({
+    type: "text",
+    label: "Amount",
+    value: formatCurrencyUnit(currency.units[0], amount, {
+      showCode: true,
+      disableRounding: true,
+    }),
+  });
+  return fields;
+};
+
+function getDeviceTransactionConfig({
+  account,
+  parentAccount,
+  transaction,
+  status,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const { mode, recipient, rewardDestination } = transaction;
+  const { amount } = status;
+  const mainAccount = getMainAccount(account, parentAccount) as PolkadotAccount;
+  let fields: { type: string; label: string; value?: string }[] = [];
+
+  switch (mode) {
+    case "send":
+      fields = getSendFields({
+        transaction,
+        status,
+      });
+      break;
+
+    case "nominate":
+      fields.push({
+        type: "text",
+        label: "Staking",
+        value: "Nominate",
+      });
+      fields.push({
+        type: "polkadot.validators",
+        label: "Targets",
+      });
+      break;
+
+    case "bond":
+      if (!isStash(mainAccount)) {
+        fields.push({
+          type: "text",
+          label: "Staking",
+          value: "Bond",
+        });
+        fields.push({
+          type: "text",
+          label: "Controller",
+          value: recipient,
+        });
+        fields.push({
+          type: "text",
+          label: "Amount",
+          value: formatCurrencyUnit(currency.units[0], amount, {
+            showCode: true,
+            disableRounding: true,
+          }),
+        });
+        fields.push({
+          type: "text",
+          label: "Payee",
+          value: rewardDestination || "Stash",
+        });
+      } else {
+        fields.push({
+          type: "text",
+          label: "Staking",
+          value: "Bond extra",
+        });
+        fields.push({
+          type: "text",
+          label: "Amount",
+          value: formatCurrencyUnit(currency.units[0], amount, {
+            showCode: true,
+            disableRounding: true,
+          }),
+        });
+      }
+
+      break;
+
+    case "rebond":
+      fields.push({
+        type: "text",
+        label: "Staking",
+        value: "Rebond",
+      });
+      fields.push({
+        type: "text",
+        label: "Amount",
+        value: formatCurrencyUnit(currency.units[0], amount, {
+          showCode: true,
+          disableRounding: true,
+        }),
+      });
+      break;
+
+    case "unbond":
+      fields.push({
+        type: "text",
+        label: "Staking",
+        value: "Unbond",
+      });
+      fields.push({
+        type: "text",
+        label: "Amount",
+        value: formatCurrencyUnit(currency.units[0], amount, {
+          showCode: true,
+          disableRounding: true,
+        }),
+      });
+      break;
+
+    case "chill":
+      fields.push({
+        type: "text",
+        label: "Staking",
+        value: "Chill",
+      });
+      break;
+
+    case "withdrawUnbonded":
+      fields.push({
+        type: "text",
+        label: "Staking",
+        value: "Withdraw Unbonded",
+      });
+      break;
+
+    case "setController":
+      fields.push({
+        type: "text",
+        label: "Staking",
+        value: "Set controller",
+      });
+      fields.push({
+        type: "text",
+        label: "Controller",
+        value:
+          // NOTE: I added this here as TokenAccount and ChildAccount
+          // both don't have freshAddress
+          account.type === "Account"
+            ? account.freshAddress
+            : mainAccount.freshAddress,
+      });
+      break;
+
+    case "claimReward":
+      fields.push({
+        type: "text",
+        label: "Staking",
+        value: "Payout Stakers",
+      });
+      break;
+
+    default:
+      break;
+  }
+
+  fields.push({
+    type: "fees",
+    label: "Fees",
+  });
+  return fields as DeviceTransactionField[];
+}
+
+export default getDeviceTransactionConfig;

package/src/errors.ts

@@ -0,0 +1,39 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+export const PolkadotUnauthorizedOperation = createCustomErrorClass(
+  "PolkadotUnauthorizedOperation"
+);
+export const PolkadotElectionClosed = createCustomErrorClass(
+  "PolkadotElectionClosed"
+);
+export const PolkadotNotValidator = createCustomErrorClass(
+  "PolkadotNotValidator"
+);
+export const PolkadotLowBondedBalance = createCustomErrorClass(
+  "PolkadotLowBondedBalance"
+);
+export const PolkadotNoUnlockedBalance = createCustomErrorClass(
+  "PolkadotNoUnlockedBalance"
+);
+export const PolkadotNoNominations = createCustomErrorClass(
+  "PolkadotNoNominations"
+);
+export const PolkadotAllFundsWarning = createCustomErrorClass(
+  "PolkadotAllFundsWarning"
+);
+export const PolkadotBondMinimumAmount = createCustomErrorClass(
+  "PolkadotBondMinimumAmount"
+);
+
+export const PolkadotBondMinimumAmountWarning = createCustomErrorClass(
+  "PolkadotBondMinimumAmountWarning"
+);
+
+export const PolkadotMaxUnbonding = createCustomErrorClass(
+  "PolkadotMaxUnbonding"
+);
+export const PolkadotValidatorsRequired = createCustomErrorClass(
+  "PolkadotValidatorsRequired"
+);
+export const PolkadotDoMaxSendInstead = createCustomErrorClass(
+  "PolkadotDoMaxSendInstead"
+);

package/src/hw-getAddress.ts

@@ -0,0 +1,14 @@
+import Polkadot from "@ledgerhq/hw-app-polkadot";
+import type { Resolver } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+
+const resolver: Resolver = async (transport, { path, verify }) => {
+  const polkadot = new Polkadot(transport);
+  const r = await polkadot.getAddress(path, verify);
+  return {
+    address: r.address,
+    publicKey: r.pubKey,
+    path,
+  };
+};
+
+export default resolver;