@ledgerhq/coin-polkadot 0.0.2

package/src/preload.ts

@@ -0,0 +1,148 @@
+/* eslint-disable no-prototype-builtins */
+import { BigNumber } from "bignumber.js";
+import { Observable, Subject } from "rxjs";
+import { log } from "@ledgerhq/logs";
+import { PRELOAD_MAX_AGE } from "./logic";
+import { getRegistry, getMinimumBondBalance } from "./cache";
+import type { PolkadotPreloadData, PolkadotValidator } from "./types";
+import { getStakingProgress, getValidators } from "./validators";
+import { loadPolkadotCrypto } from "./polkadot-crypto";
+
+let currentPolkadotPreloadedData: PolkadotPreloadData = {
+  validators: [],
+  staking: undefined,
+  minimumBondBalance: "0",
+};
+
+function fromHydrateValidator(
+  validatorRaw: Record<string, any>
+): PolkadotValidator {
+  return {
+    address: validatorRaw.address,
+    identity: validatorRaw.identity,
+    nominatorsCount: Number(validatorRaw.nominatorsCount),
+    rewardPoints:
+      validatorRaw.rewardPoints === null
+        ? null
+        : new BigNumber(validatorRaw.rewardPoints),
+    commission: new BigNumber(validatorRaw.commission),
+    totalBonded: new BigNumber(validatorRaw.totalBonded),
+    selfBonded: new BigNumber(validatorRaw.selfBonded),
+    isElected: !!validatorRaw.isElected,
+    isOversubscribed: !!validatorRaw.isOversubscribed,
+  };
+}
+
+function fromHydratePreloadData(data: any): PolkadotPreloadData {
+  let validators = [];
+  let staking:
+    | {
+        electionClosed: boolean;
+        activeEra: number;
+        maxNominatorRewardedPerValidator: number;
+        bondingDuration: number;
+      }
+    | undefined = undefined;
+  let minimumBondBalance = "0";
+
+  if (typeof data === "object" && data) {
+    if (Array.isArray(data.validators)) {
+      validators = data.validators.map(fromHydrateValidator);
+    }
+
+    if (data.staking !== null && typeof data.staking === "object") {
+      const {
+        electionClosed,
+        activeEra,
+        maxNominatorRewardedPerValidator,
+        bondingDuration,
+      } = data.staking;
+      staking = {
+        electionClosed: !!electionClosed,
+        activeEra: Number(activeEra),
+        maxNominatorRewardedPerValidator:
+          Number(maxNominatorRewardedPerValidator) || 128,
+        bondingDuration: Number(bondingDuration) || 28,
+      };
+    }
+
+    if (
+      data.minimumBondBalance !== null &&
+      typeof data.minimumBondBalance === "string"
+    ) {
+      minimumBondBalance = data.minimumBondBalance || "0";
+    }
+  }
+
+  return {
+    validators,
+    staking,
+    minimumBondBalance,
+  };
+}
+
+const updates = new Subject<PolkadotPreloadData>();
+export function getCurrentPolkadotPreloadData(): PolkadotPreloadData {
+  return currentPolkadotPreloadedData;
+}
+export function setPolkadotPreloadData(data: PolkadotPreloadData) {
+  if (data === currentPolkadotPreloadedData) return;
+  currentPolkadotPreloadedData = data;
+  updates.next(data);
+}
+export function getPolkadotPreloadDataUpdates(): Observable<PolkadotPreloadData> {
+  return updates.asObservable();
+}
+
+/**
+ * load max cache time for the validators
+ */
+export const getPreloadStrategy = () => ({
+  preloadMaxAge: PRELOAD_MAX_AGE,
+});
+
+const shouldRefreshValidators = (previousState, currentState) => {
+  return !previousState || currentState.activeEra !== previousState.activeEra;
+};
+
+export const preload = async (): Promise<PolkadotPreloadData> => {
+  await loadPolkadotCrypto();
+  await getRegistry(); // ensure registry is already in cache.
+  const minimumBondBalance = await getMinimumBondBalance();
+  const minimumBondBalanceStr = minimumBondBalance.toString();
+
+  const currentStakingProgress = await getStakingProgress();
+  const { validators: previousValidators, staking: previousStakingProgress } =
+    currentPolkadotPreloadedData;
+  let validators = previousValidators;
+
+  if (
+    !validators ||
+    !validators.length ||
+    shouldRefreshValidators(previousStakingProgress, currentStakingProgress)
+  ) {
+    log("polkadot/preload", "refreshing polkadot validators...");
+
+    try {
+      validators = await getValidators("all");
+    } catch (error) {
+      log("polkadot/preload", "failed to fetch validators", {
+        error,
+      });
+    }
+  }
+
+  return {
+    validators,
+    staking: currentStakingProgress,
+    minimumBondBalance: minimumBondBalanceStr,
+  };
+};
+export const hydrate = (data: unknown) => {
+  const hydrated = fromHydratePreloadData(data);
+  log(
+    "polkadot/preload",
+    "hydrate " + hydrated.validators.length + " polkadot validators"
+  );
+  setPolkadotPreloadData(hydrated);
+};

package/src/serialization.ts

@@ -0,0 +1,48 @@
+import { BigNumber } from "bignumber.js";
+import type { PolkadotResourcesRaw, PolkadotResources } from "./types";
+export function toPolkadotResourcesRaw(
+  r: PolkadotResources
+): PolkadotResourcesRaw {
+  const { nonce, controller, stash } = r;
+  return {
+    controller,
+    stash,
+    nonce,
+    lockedBalance: r.lockedBalance.toString(),
+    unlockedBalance: r.unlockedBalance.toString(),
+    unlockingBalance: r.unlockingBalance.toString(),
+    unlockings: r.unlockings?.map((u) => ({
+      amount: u.amount.toString(),
+      completionDate: u.completionDate.toISOString(),
+    })),
+    nominations: r.nominations?.map((n) => ({
+      address: n.address,
+      value: n.value.toString(),
+      status: n.status,
+    })),
+    numSlashingSpans: r.numSlashingSpans,
+  };
+}
+export function fromPolkadotResourcesRaw(
+  r: PolkadotResourcesRaw
+): PolkadotResources {
+  const { nonce, controller, stash } = r;
+  return {
+    controller,
+    stash,
+    nonce,
+    lockedBalance: new BigNumber(r.lockedBalance),
+    unlockedBalance: new BigNumber(r.unlockedBalance),
+    unlockingBalance: new BigNumber(r.unlockingBalance),
+    unlockings: r.unlockings?.map((u) => ({
+      amount: new BigNumber(u.amount),
+      completionDate: new Date(u.completionDate),
+    })),
+    nominations: r.nominations?.map((n) => ({
+      address: n.address,
+      value: new BigNumber(n.value),
+      status: n.status,
+    })),
+    numSlashingSpans: Number(r.numSlashingSpans) || 0,
+  };
+}

package/src/specs.ts

@@ -0,0 +1,305 @@
+import expect from "expect";
+import invariant from "invariant";
+import sampleSize from "lodash/sampleSize";
+import { BigNumber } from "bignumber.js";
+import { getCurrentPolkadotPreloadData } from "./preload";
+import type { PolkadotAccount, PolkadotResources, Transaction } from "./types";
+import {
+  getCryptoCurrencyById,
+  parseCurrencyUnit,
+} from "@ledgerhq/coin-framework/currencies/index";
+import {
+  botTest,
+  expectSiblingsHaveSpendablePartGreaterThan,
+  genericTestDestination,
+  pickSiblings,
+} from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { toOperationRaw } from "@ledgerhq/coin-framework/account/index";
+import {
+  canBond,
+  canUnbond,
+  canNominate,
+  isFirstBond,
+  hasMinimumBondBalance,
+  getMinimumBalance,
+} from "./logic";
+import { DeviceModelId } from "@ledgerhq/devices";
+import { acceptTransaction } from "./speculos-deviceActions";
+
+const maxAccounts = 32;
+const currency = getCryptoCurrencyById("polkadot");
+// FIXME Should be replaced with EXISTENTIAL_DEPOSIT_RECOMMENDED_MARGIN in logic.ts
+const POLKADOT_MIN_SAFE = parseCurrencyUnit(currency.units[0], "0.1");
+// FIXME Should be replaced with EXISTENTIAL_DEPOSIT in logic.ts
+const EXISTENTIAL_DEPOSIT = parseCurrencyUnit(currency.units[0], "1.0");
+const MIN_LOCKED_BALANCE_REQ = parseCurrencyUnit(currency.units[0], "1.0");
+
+const polkadot: AppSpec<Transaction> = {
+  name: "Polkadot",
+  currency: getCryptoCurrencyById("polkadot"),
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Polkadot",
+  },
+  testTimeout: 2 * 60 * 1000,
+  genericDeviceAction: acceptTransaction,
+  minViableAmount: POLKADOT_MIN_SAFE,
+  transactionCheck: ({ maxSpendable }) => {
+    invariant(maxSpendable.gt(POLKADOT_MIN_SAFE), "balance is too low");
+  },
+  test: ({ operation, optimisticOperation }) => {
+    const opExpected: Record<string, any> = toOperationRaw({
+      ...optimisticOperation,
+    });
+    delete opExpected.value;
+    delete opExpected.fee;
+    delete opExpected.date;
+    delete opExpected.blockHash;
+    delete opExpected.blockHeight;
+    botTest("optimistic operation matches", () =>
+      expect(toOperationRaw(operation)).toMatchObject(opExpected)
+    );
+  },
+  mutations: [
+    {
+      name: "send 50%~",
+      maxRun: 4,
+      testDestination: genericTestDestination,
+      transaction: ({ account, siblings, bridge }) => {
+        invariant(
+          (account as PolkadotAccount).polkadotResources,
+          "polkadot resource"
+        );
+        const sibling = pickSiblings(siblings, maxAccounts);
+        let amount = account.spendableBalance
+          .minus(EXISTENTIAL_DEPOSIT)
+          .div(1.9 + 0.2 * Math.random())
+          .integerValue();
+
+        if (!sibling.used && amount.lt(EXISTENTIAL_DEPOSIT)) {
+          invariant(
+            account.spendableBalance.gt(
+              EXISTENTIAL_DEPOSIT.plus(POLKADOT_MIN_SAFE)
+            ),
+            "send is too low to activate account"
+          );
+          amount = EXISTENTIAL_DEPOSIT;
+        }
+
+        const minimumBalanceExistential = getMinimumBalance(account);
+        const leftover = account.spendableBalance.minus(
+          amount.plus(POLKADOT_MIN_SAFE)
+        );
+        if (
+          minimumBalanceExistential.gt(0) &&
+          leftover.lt(minimumBalanceExistential) &&
+          leftover.gt(0)
+        ) {
+          throw new Error("risk of PolkadotDoMaxSendInstead");
+        }
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              recipient: sibling.freshAddress,
+            },
+            {
+              amount,
+            },
+          ],
+        };
+      },
+    },
+    {
+      name: "send max",
+      maxRun: 1,
+      testDestination: genericTestDestination,
+      transaction: ({ account, siblings, bridge }) => {
+        invariant(
+          (account as PolkadotAccount).polkadotResources,
+          "polkadot resources"
+        );
+        const sibling = pickSiblings(siblings, maxAccounts);
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              recipient: sibling.freshAddress,
+            },
+            {
+              useAllAmount: true,
+            },
+          ],
+        };
+      },
+    },
+    {
+      name: "bond - bondExtra",
+      maxRun: 1,
+      transaction: ({ siblings, account, bridge }) => {
+        expectSiblingsHaveSpendablePartGreaterThan(siblings, 0.5);
+
+        invariant((account as PolkadotAccount).polkadotResources, "polkadot");
+        invariant(canBond(account), "can't bond");
+        invariant(
+          hasMinimumBondBalance(account as PolkadotAccount),
+          "not enough balance to bond"
+        );
+        const options: {
+          recipient?: string;
+          rewardDestination?: string;
+          amount?: BigNumber;
+        }[] = [];
+
+        if (isFirstBond(account as PolkadotAccount)) {
+          invariant(
+            account.balance.gt(EXISTENTIAL_DEPOSIT.plus(POLKADOT_MIN_SAFE)),
+            "cant cover fee + bonding amount"
+          );
+          options.push({
+            recipient: account.freshAddress,
+            rewardDestination: "Stash",
+          });
+          options.push({
+            amount: EXISTENTIAL_DEPOSIT,
+          });
+        } else {
+          invariant(
+            account.spendableBalance.gt(POLKADOT_MIN_SAFE),
+            "cant cover fee + bonding amount"
+          );
+          options.push({
+            amount: new BigNumber(100000),
+          });
+        }
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "bond",
+            },
+            ...options,
+          ],
+        };
+      },
+    },
+    {
+      name: "unbond",
+      maxRun: 2,
+      transaction: ({ account, bridge }) => {
+        const { polkadotResources } = account as PolkadotAccount;
+        invariant(polkadotResources, "polkadot");
+        invariant(canUnbond(account as PolkadotAccount), "can't unbond");
+        invariant(
+          account.spendableBalance.gt(POLKADOT_MIN_SAFE),
+          "can't cover fee"
+        );
+        const amount = (polkadotResources as PolkadotResources).lockedBalance
+          .minus((polkadotResources as PolkadotResources).unlockingBalance)
+          .times(0.2);
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "unbond",
+            },
+            {
+              amount,
+            },
+          ],
+        };
+      },
+    },
+    {
+      name: "rebond",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        const { polkadotResources } = account as PolkadotAccount;
+        invariant(polkadotResources, "polkadot");
+        invariant(
+          polkadotResources?.unlockingBalance.gt(MIN_LOCKED_BALANCE_REQ),
+          "can't rebond"
+        );
+        invariant(
+          account.spendableBalance.gt(POLKADOT_MIN_SAFE),
+          "can't cover fee"
+        );
+        const amount = BigNumber.maximum(
+          (polkadotResources as PolkadotResources).unlockingBalance.times(0.2),
+          MIN_LOCKED_BALANCE_REQ
+        );
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "rebond",
+            },
+            {
+              amount,
+            },
+          ],
+        };
+      },
+    },
+    {
+      name: "nominate",
+      maxRun: 1,
+      transaction: ({ account, bridge }) => {
+        invariant((account as PolkadotAccount).polkadotResources, "polkadot");
+        invariant(canNominate(account as PolkadotAccount), "can't nominate");
+        invariant(
+          account.spendableBalance.gt(POLKADOT_MIN_SAFE),
+          "cant cover fee"
+        );
+        const data = getCurrentPolkadotPreloadData();
+        const validators = sampleSize(
+          data.validators.map((v) => v.address),
+          2
+        );
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "nominate",
+            },
+            ...validators.map((_, i) => ({
+              validators: validators.slice(0, i + 1),
+            })),
+          ],
+        };
+      },
+    },
+    {
+      name: "withdraw",
+      maxRun: 2,
+      transaction: ({ account, bridge }) => {
+        const { polkadotResources } = account as PolkadotAccount;
+        invariant(polkadotResources, "polkadot");
+        invariant(
+          polkadotResources?.unlockedBalance.gt(0),
+          "nothing to withdraw"
+        );
+        invariant(
+          account.spendableBalance.gt(POLKADOT_MIN_SAFE),
+          "can't cover fee"
+        );
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              mode: "withdrawUnbonded",
+            },
+          ],
+        };
+      },
+    },
+  ],
+};
+
+export default {
+  polkadot,
+};

package/src/speculos-deviceActions.ts

@@ -0,0 +1,84 @@
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import type { PolkadotAccount, Transaction } from "./types";
+import {
+  deviceActionFlow,
+  formatDeviceAmount,
+  SpeculosButton,
+} from "@ledgerhq/coin-framework/bot/specs";
+
+export const acceptTransaction: DeviceAction<Transaction, any> =
+  deviceActionFlow({
+    steps: [
+      {
+        title: "Staking",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Balances",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Dest",
+        button: SpeculosButton.RIGHT,
+        expectedValue: ({ transaction }) => transaction.recipient,
+      },
+      {
+        title: "Amount",
+        button: SpeculosButton.RIGHT,
+        expectedValue: ({ account, status }) => {
+          return formatDeviceAmount(account.currency, status.amount, {
+            forceFloating: true,
+          });
+        },
+      },
+      {
+        title: "Chain",
+        button: SpeculosButton.RIGHT,
+        expectedValue: () => "Polkadot",
+      },
+      {
+        title: "Nonce",
+        button: SpeculosButton.RIGHT,
+        expectedValue: ({ account }) =>
+          (
+            (account as PolkadotAccount).polkadotResources?.nonce || 0
+          ).toString(),
+      },
+      {
+        title: "Tip",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Controller",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Payee",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Max additional",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Targets",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Era Phase",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Era Period",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "Block",
+        button: SpeculosButton.RIGHT,
+      },
+      {
+        title: "APPROVE",
+        button: SpeculosButton.BOTH,
+      },
+    ],
+  });

package/src/transaction.ts

@@ -0,0 +1,64 @@
+import type { Transaction, TransactionRaw } from "./types";
+import { BigNumber } from "bignumber.js";
+import {
+  formatTransactionStatusCommon as formatTransactionStatus,
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/transaction/common";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountUnit } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+export const formatTransaction = (
+  { mode, amount, recipient, validators, useAllAmount }: Transaction,
+  account: Account
+): string => `
+${mode.toUpperCase()} ${
+  useAllAmount
+    ? "MAX"
+    : amount.isZero()
+    ? ""
+    : " " +
+      formatCurrencyUnit(getAccountUnit(account), amount, {
+        showCode: true,
+        disableRounding: true,
+      })
+}${recipient ? `\nTO ${recipient}` : ""}${
+  !validators ? "" : validators.join("\n")
+}`;
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+  return {
+    ...common,
+    family: tr.family,
+    mode: tr.mode,
+    fees: tr.fees ? new BigNumber(tr.fees) : null,
+    validators: tr.validators,
+    era: tr.era,
+    rewardDestination: tr.rewardDestination,
+    numSlashingSpans: tr.numSlashingSpans,
+  };
+};
+export const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+  return {
+    ...common,
+    family: t.family,
+    mode: t.mode,
+    fees: t.fees?.toString() || null,
+    validators: t.validators,
+    era: t.era,
+    rewardDestination: t.rewardDestination,
+    numSlashingSpans: t.numSlashingSpans,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};