@ledgerhq/coin-polkadot 0.0.2

package/src/js-signOperation.ts

@@ -0,0 +1,232 @@
+import { BigNumber } from "bignumber.js";
+import { Observable } from "rxjs";
+import { TypeRegistry } from "@polkadot/types";
+import { u8aConcat } from "@polkadot/util";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import Polkadot from "@ledgerhq/hw-app-polkadot";
+import type { PolkadotAccount, Transaction } from "./types";
+import type {
+  Account,
+  Operation,
+  OperationType,
+  SignOperationEvent,
+  SignOperationFnSignature,
+} from "@ledgerhq/types-live";
+import { DeviceCommunication } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { buildTransaction } from "./js-buildTransaction";
+import { calculateAmount, getNonce, isFirstBond } from "./logic";
+const MODE_TO_TYPE = {
+  send: "OUT",
+  bond: "BOND",
+  unbond: "UNBOND",
+  rebond: "BOND",
+  withdrawUnbonded: "WITHDRAW_UNBONDED",
+  nominate: "NOMINATE",
+  chill: "CHILL",
+  setController: "SET_CONTROLLER",
+  claimReward: "REWARD_PAYOUT",
+  default: "FEES",
+};
+const MODE_TO_PALLET_METHOD = {
+  send: "balances.transferKeepAlive",
+  sendMax: "balances.transfer",
+  bond: "staking.bond",
+  bondExtra: "staking.bondExtra",
+  unbond: "staking.unbond",
+  rebond: "staking.rebond",
+  withdrawUnbonded: "staking.withdrawUnbonded",
+  nominate: "staking.nominate",
+  chill: "staking.chill",
+  setController: "staking.setController",
+  claimReward: "staking.payoutStakers",
+};
+
+const getExtra = (
+  type: string,
+  account: PolkadotAccount,
+  transaction: Transaction
+) => {
+  const extra = {
+    palletMethod: MODE_TO_PALLET_METHOD[transaction.mode],
+  };
+
+  if (transaction.mode == "send" && transaction.useAllAmount) {
+    extra.palletMethod = MODE_TO_PALLET_METHOD["sendMax"];
+  } else if (transaction.mode === "bond" && !isFirstBond(account)) {
+    extra.palletMethod = MODE_TO_PALLET_METHOD["bondExtra"];
+  }
+
+  switch (type) {
+    case "OUT":
+      return { ...extra, transferAmount: new BigNumber(transaction.amount) };
+
+    case "BOND":
+      return { ...extra, bondedAmount: new BigNumber(transaction.amount) };
+
+    case "UNBOND":
+      return { ...extra, unbondedAmount: new BigNumber(transaction.amount) };
+
+    case "WITHDRAW_UNBONDED":
+      return {
+        ...extra,
+        withdrawUnbondedAmount: new BigNumber(
+          account.polkadotResources?.unlockedBalance || 0
+        ),
+      };
+
+    case "NOMINATE":
+      return { ...extra, validators: transaction.validators };
+  }
+
+  return extra;
+};
+
+const buildOptimisticOperation = (
+  account: PolkadotAccount,
+  transaction: Transaction,
+  fee: BigNumber
+): Operation => {
+  const type = (MODE_TO_TYPE[transaction.mode] ??
+    MODE_TO_TYPE.default) as OperationType;
+  const value =
+    type === "OUT"
+      ? new BigNumber(transaction.amount).plus(fee)
+      : new BigNumber(fee);
+  const extra = getExtra(type, account, transaction);
+  const operation: Operation = {
+    id: encodeOperationId(account.id, "", type),
+    hash: "",
+    type,
+    value,
+    fee,
+    blockHash: null,
+    blockHeight: null,
+    senders: [account.freshAddress],
+    recipients: [transaction.recipient].filter(Boolean),
+    accountId: account.id,
+    transactionSequenceNumber: getNonce(account),
+    date: new Date(),
+    extra,
+  };
+  return operation;
+};
+
+/**
+ * Serialize a signed transaction in a format that can be submitted over the
+ * Node RPC Interface from the signing payload and signature produced by the
+ * remote signer.
+ *
+ * @param unsigned - The JSON representing the unsigned transaction.
+ * @param signature - Signature of the signing payload produced by the remote signer.
+ * @param registry - Registry used for constructing the payload.
+ */
+export const signExtrinsic = async (
+  unsigned: Record<string, any>,
+  signature: any,
+  registry: TypeRegistry
+): Promise<string> => {
+  const extrinsic = registry.createType("Extrinsic", unsigned, {
+    version: unsigned.version,
+  });
+  extrinsic.addSignature(unsigned.address, signature, unsigned as any);
+  return extrinsic.toHex();
+};
+
+/**
+ * Sign Extrinsic with a fake signature (for fees estimation).
+ *
+ * @param unsigned - The JSON representing the unsigned transaction.
+ * @param registry - Registry used for constructing the payload.
+ */
+export const fakeSignExtrinsic = async (
+  unsigned: Record<string, any>,
+  registry: TypeRegistry
+): Promise<string> => {
+  const fakeSignature = u8aConcat(
+    new Uint8Array([1]),
+    new Uint8Array(64).fill(0x42)
+  );
+  return signExtrinsic(unsigned, fakeSignature, registry);
+};
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+const buildSignOperation =
+  (withDevice: DeviceCommunication): SignOperationFnSignature<Transaction> =>
+  ({
+    account,
+    deviceId,
+    transaction,
+  }: {
+    account: Account;
+    deviceId: any;
+    transaction: Transaction;
+  }): Observable<SignOperationEvent> =>
+    withDevice(deviceId)(
+      (transport) =>
+        new Observable((o) => {
+          async function main() {
+            o.next({
+              type: "device-signature-requested",
+            });
+
+            if (!transaction.fees) {
+              throw new FeeNotLoaded();
+            }
+
+            // Ensure amount is filled when useAllAmount
+            const transactionToSign = {
+              ...transaction,
+              amount: calculateAmount({
+                a: account as PolkadotAccount,
+                t: transaction,
+              }),
+            };
+            const { unsigned, registry } = await buildTransaction(
+              account as PolkadotAccount,
+              transactionToSign,
+              true
+            );
+            const payload = registry
+              .createType("ExtrinsicPayload", unsigned, {
+                version: unsigned.version,
+              })
+              .toU8a({
+                method: true,
+              });
+            // Sign by device
+            const polkadot = new Polkadot(transport);
+            // FIXME: the type of payload Uint8Array is not compatible with the signature of sign which accept a string
+            const r = await polkadot.sign(
+              account.freshAddressPath,
+              payload as any
+            );
+            const signed = await signExtrinsic(unsigned, r.signature, registry);
+            o.next({
+              type: "device-signature-granted",
+            });
+            const operation = buildOptimisticOperation(
+              account as PolkadotAccount,
+              transactionToSign,
+              transactionToSign.fees ?? new BigNumber(0)
+            );
+            o.next({
+              type: "signed",
+              signedOperation: {
+                operation,
+                signature: signed,
+                expirationDate: null,
+              },
+            });
+          }
+
+          main().then(
+            () => o.complete(),
+            (e) => o.error(e)
+          );
+        })
+    );
+
+export default buildSignOperation;

package/src/js-synchronisation.ts

@@ -0,0 +1,57 @@
+import type { Account } from "@ledgerhq/types-live";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import type { GetAccountShape } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getAccount, getOperations } from "./api";
+import { loadPolkadotCrypto } from "./polkadot-crypto";
+
+export const getAccountShape: GetAccountShape = async (info) => {
+  await loadPolkadotCrypto();
+  const { address, initialAccount, currency, derivationMode } = info;
+  const oldOperations = initialAccount?.operations || [];
+  const startAt = oldOperations.length
+    ? (oldOperations[0].blockHeight || 0) + 1
+    : 0;
+  const {
+    blockHeight,
+    balance,
+    spendableBalance,
+    nonce,
+    lockedBalance,
+    controller,
+    stash,
+    unlockedBalance,
+    unlockingBalance,
+    unlockings,
+    nominations,
+    numSlashingSpans,
+  } = await getAccount(address);
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+  const newOperations = await getOperations(accountId, address, startAt);
+  const operations = mergeOps(oldOperations, newOperations);
+  const shape = {
+    id: accountId,
+    balance,
+    spendableBalance,
+    operationsCount: operations.length,
+    blockHeight,
+    polkadotResources: {
+      nonce,
+      controller,
+      stash,
+      lockedBalance,
+      unlockedBalance,
+      unlockingBalance,
+      unlockings,
+      nominations,
+      numSlashingSpans,
+    },
+  };
+  return { ...shape, operations } as Partial<Account>;
+};

package/src/logic.ts

@@ -0,0 +1,266 @@
+import { BigNumber } from "bignumber.js";
+import type { Account, OperationType } from "@ledgerhq/types-live";
+import type { PolkadotAccount, Transaction } from "./types";
+import { getCurrentPolkadotPreloadData } from "./preload";
+
+export const EXISTENTIAL_DEPOSIT = new BigNumber(10000000000);
+export const EXISTENTIAL_DEPOSIT_RECOMMENDED_MARGIN = new BigNumber(1000000000); // Polkadot recommended Existential Deposit error margin
+export const MAX_NOMINATIONS = 16;
+export const MAX_UNLOCKINGS = 32;
+export const PRELOAD_MAX_AGE = 60 * 1000;
+// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+export const MAX_AMOUNT_INPUT = 0xffffffffffffffff;
+export const FEES_SAFETY_BUFFER = new BigNumber(1000000000); // Arbitrary buffer for paying fees of next transactions
+
+/**
+ * Returns true if account is a stash.
+ * When the account is a stash, we have the information of which account is the controller
+ *
+ * @param {PolkadotAccount} a
+ */
+export const isStash = (a: PolkadotAccount): boolean => {
+  return !!a.polkadotResources?.controller;
+};
+
+/**
+ * Returns true if account is a controller.
+ * when account is a controller, we have the information of which stash it controls
+ *
+ * @param {PolkadotAccount} a
+ */
+export const isController = (a: PolkadotAccount): boolean => {
+  return !!a.polkadotResources?.stash;
+};
+
+/**
+ * Returns true if account is controlled by an external account (not self)
+ *
+ * @param {PolkadotAccount} a
+ */
+export const hasExternalController = (a: PolkadotAccount): boolean => {
+  return a.polkadotResources?.controller
+    ? a.polkadotResources?.controller !== a.freshAddress
+    : false;
+};
+
+/**
+ * Returns true if account controls an external stash (not self)
+ *
+ * @param {PolkadotAccount} a
+ */
+export const hasExternalStash = (a: PolkadotAccount): boolean => {
+  return a.polkadotResources?.stash
+    ? a.polkadotResources?.stash !== a.freshAddress
+    : false;
+};
+
+/**
+ * Must have the minimum balance to bond
+ *
+ * @param {PolkadotAccount} a
+ */
+export const canBond = (a: Account): boolean => {
+  const { balance } = a;
+  return EXISTENTIAL_DEPOSIT.lte(balance);
+};
+
+/**
+ * Get the minimum bond amount required to bond/rebond
+ *
+ * @param {PolkadotAccount} a
+ */
+export const getMinimumAmountToBond = (
+  a: PolkadotAccount,
+  minimumBondBalance: BigNumber | undefined
+): BigNumber => {
+  const currentlyBondedBalance = calculateMaxUnbond(a);
+
+  if (minimumBondBalance && currentlyBondedBalance.lt(minimumBondBalance)) {
+    return minimumBondBalance.minus(currentlyBondedBalance);
+  }
+
+  return new BigNumber(0);
+};
+
+/**
+ * Return true if the account has at least the current minimum bonded balance required by the network
+ *
+ * @param {PolkadotAccount} a
+ */
+export const hasMinimumBondBalance = (a: PolkadotAccount): boolean => {
+  const { minimumBondBalance } = getCurrentPolkadotPreloadData();
+  return (
+    !a.polkadotResources ||
+    a.polkadotResources.lockedBalance.gte(new BigNumber(minimumBondBalance))
+  );
+};
+
+/**
+ * Return true if some operation with type is pending and not yet synchronized
+ *
+ * @param {PolkadotAccount} a
+ */
+export const hasPendingOperationType = (
+  a: Account,
+  type: OperationType
+): boolean => {
+  return a.pendingOperations?.some((op) => op.type === type) ?? false;
+};
+
+/**
+ * Retyrns true if has reached the maximum of unlocking slots
+ *
+ * @param {PolkadotAccount} a
+ */
+export const hasMaxUnlockings = (a: PolkadotAccount) => {
+  const { unlockings = [] } = a.polkadotResources || {};
+  return (unlockings?.length || 0) >= MAX_UNLOCKINGS;
+};
+
+/**
+ * Return true if account has enough Locked Balance to rebond
+ *
+ * @param {PolkadotAccount} a
+ */
+export const hasLockedBalance = (a: PolkadotAccount) => {
+  const {
+    lockedBalance = new BigNumber(0),
+    unlockingBalance = new BigNumber(0),
+  } = a.polkadotResources || {};
+  return lockedBalance.minus(unlockingBalance).gt(0);
+};
+
+/**
+ * Must have locked Balance
+ *
+ * @param {PolkadotAccount} a
+ */
+export const canUnbond = (a: PolkadotAccount): boolean => {
+  return hasLockedBalance(a) && !hasMaxUnlockings(a);
+};
+
+/**
+ * Returns true if an account can nominate
+ *
+ * @param {PolkadotAccount} a
+ */
+export const canNominate = (a: PolkadotAccount): boolean => isController(a);
+
+/**
+ * Returns true if account must do a first bond - false for a bond extra
+ *
+ * @param {Account} a
+ */
+export const isFirstBond = (a: PolkadotAccount): boolean => !isStash(a);
+
+/**
+ * Returns nonce for an account
+ *
+ * @param {Account} a
+ */
+export const getNonce = (a: PolkadotAccount): number => {
+  const lastPendingOp = a.pendingOperations[0];
+  const nonce = Math.max(
+    a.polkadotResources?.nonce || 0,
+    lastPendingOp && typeof lastPendingOp.transactionSequenceNumber === "number"
+      ? lastPendingOp.transactionSequenceNumber + 1
+      : 0
+  );
+  return nonce;
+};
+
+/**
+ * Calculate max bond which is the actual spendable minus a safety buffer,
+ * so the user still has funds to pay the fees for next transactions
+ *
+ * @param {*} a
+ * @param {*} t
+ */
+const calculateMaxBond = (a: PolkadotAccount, t: Transaction): BigNumber => {
+  const amount = a.spendableBalance
+    .minus(t.fees || 0)
+    .minus(FEES_SAFETY_BUFFER);
+  return amount.lt(0) ? new BigNumber(0) : amount;
+};
+
+/**
+ * Calculates max unbond amount which is the remaining active locked balance (not unlocking)
+ *
+ * @param {*} account
+ */
+const calculateMaxUnbond = (a: PolkadotAccount): BigNumber => {
+  return (
+    a.polkadotResources?.lockedBalance.minus(
+      a.polkadotResources.unlockingBalance
+    ) ?? new BigNumber(0)
+  );
+};
+
+/**
+ * Calculates max rebond amount which is the current unlocking balance (including unlocked)
+ *
+ * @param {*} account
+ */
+const calculateMaxRebond = (a: PolkadotAccount): BigNumber => {
+  return a.polkadotResources?.unlockingBalance ?? new BigNumber(0);
+};
+
+/**
+ * Calculate the real spendable
+ *
+ * @param {*} a
+ * @param {*} t
+ */
+const calculateMaxSend = (a: Account, t: Transaction): BigNumber => {
+  const amount = a.spendableBalance.minus(t.fees || 0);
+  return amount.lt(0) ? new BigNumber(0) : amount;
+};
+
+/**
+ * Calculates correct amount if useAllAmount
+ *
+ * @param {*} param
+ */
+export const calculateAmount = ({
+  a,
+  t,
+}: {
+  a: PolkadotAccount;
+  t: Transaction;
+}): BigNumber => {
+  let amount = t.amount;
+
+  if (t.useAllAmount) {
+    switch (t.mode) {
+      case "send":
+        amount = calculateMaxSend(a, t);
+        break;
+
+      case "bond":
+        amount = calculateMaxBond(a, t);
+        break;
+
+      case "unbond":
+        amount = calculateMaxUnbond(a);
+        break;
+
+      case "rebond":
+        amount = calculateMaxRebond(a);
+        break;
+
+      default:
+        amount = a.spendableBalance.minus(t.fees || 0);
+        break;
+    }
+  } else if (t.amount.gt(MAX_AMOUNT_INPUT)) {
+    return new BigNumber(MAX_AMOUNT_INPUT);
+  }
+
+  return amount.lt(0) ? new BigNumber(0) : amount;
+};
+export const getMinimumBalance = (a: Account): BigNumber => {
+  const lockedBalance = a.balance.minus(a.spendableBalance);
+  return lockedBalance.lte(EXISTENTIAL_DEPOSIT)
+    ? EXISTENTIAL_DEPOSIT.minus(lockedBalance)
+    : new BigNumber(0);
+};

package/src/platformAdapter.test.ts

@@ -0,0 +1,61 @@
+import dot from "./platformAdapter";
+import { PolkadotTransaction as PlatformTransaction } from "@ledgerhq/live-app-sdk";
+import { FAMILIES } from "@ledgerhq/live-app-sdk";
+import BigNumber from "bignumber.js";
+import { Transaction } from "./types";
+
+describe("getPlatformTransactionSignFlowInfos", () => {
+  describe("should properly get infos for DOT platform tx", () => {
+    it("with most basic tx", () => {
+      const dotPlatformTx: PlatformTransaction = {
+        family: FAMILIES.POLKADOT,
+        amount: new BigNumber(100000),
+        recipient: "0xABCDEF",
+        mode: "send",
+      };
+
+      const expectedLiveTx: Partial<Transaction> = {
+        family: dotPlatformTx.family,
+        amount: dotPlatformTx.amount,
+        recipient: dotPlatformTx.recipient,
+        mode: dotPlatformTx.mode,
+      };
+
+      const { canEditFees, hasFeesProvided, liveTx } =
+        dot.getPlatformTransactionSignFlowInfos(dotPlatformTx);
+
+      expect(canEditFees).toBe(false);
+
+      expect(hasFeesProvided).toBe(false);
+
+      expect(liveTx).toEqual(expectedLiveTx);
+    });
+
+    it("with era provided", () => {
+      const dotPlatformTx: PlatformTransaction = {
+        family: FAMILIES.POLKADOT,
+        amount: new BigNumber(100000),
+        recipient: "0xABCDEF",
+        mode: "send",
+        era: 1,
+      };
+
+      const expectedLiveTx: Partial<Transaction> = {
+        family: dotPlatformTx.family,
+        amount: dotPlatformTx.amount,
+        recipient: dotPlatformTx.recipient,
+        mode: dotPlatformTx.mode,
+        era: `${dotPlatformTx.era}`,
+      };
+
+      const { canEditFees, hasFeesProvided, liveTx } =
+        dot.getPlatformTransactionSignFlowInfos(dotPlatformTx);
+
+      expect(canEditFees).toBe(false);
+
+      expect(hasFeesProvided).toBe(false);
+
+      expect(liveTx).toEqual(expectedLiveTx);
+    });
+  });
+});

package/src/platformAdapter.ts

@@ -0,0 +1,29 @@
+// TODO: to remove once live-app-sdk is depreciated and removed from LL
+
+import { PolkadotTransaction as PlatformTransaction } from "@ledgerhq/live-app-sdk";
+import { Transaction } from "./types";
+
+const CAN_EDIT_FEES = false;
+
+const convertToLiveTransaction = (
+  tx: PlatformTransaction
+): Partial<Transaction> => ({
+  ...tx,
+  era: tx.era ? `${tx.era}` : undefined,
+});
+
+const getPlatformTransactionSignFlowInfos = (
+  tx: PlatformTransaction
+): {
+  canEditFees: boolean;
+  hasFeesProvided: boolean;
+  liveTx: Partial<Transaction>;
+} => {
+  return {
+    canEditFees: CAN_EDIT_FEES,
+    liveTx: convertToLiveTransaction(tx),
+    hasFeesProvided: false,
+  };
+};
+
+export default { getPlatformTransactionSignFlowInfos };

package/src/polkadot-crypto.ts

@@ -0,0 +1,10 @@
+import { cryptoWaitReady } from "@polkadot/util-crypto";
+
+let loadingPromise: null | Promise<boolean>;
+
+export function loadPolkadotCrypto(): Promise<boolean> {
+  if (loadingPromise) return loadingPromise;
+  const p = cryptoWaitReady();
+  loadingPromise = p;
+  return p;
+}