@ledgerhq/coin-polkadot 0.0.2

package/src/js-buildTransaction.ts

@@ -0,0 +1,206 @@
+import { stringCamelCase } from "@polkadot/util";
+import type { PolkadotAccount, Transaction } from "./types";
+import { getRegistry, getTransactionParams } from "./cache";
+import { isFirstBond, getNonce } from "./logic";
+import { loadPolkadotCrypto } from "./polkadot-crypto";
+const EXTRINSIC_VERSION = 4;
+// Default values for tx parameters, if the user doesn't specify any
+const DEFAULTS = {
+  tip: 0,
+  eraPeriod: 64,
+};
+
+const getExtrinsicParams = (a: PolkadotAccount, t: Transaction) => {
+  const validator = t.validators ? t.validators[0] : null;
+
+  switch (t.mode) {
+    case "send":
+      // Construct a balance transfer transaction offline.
+      return {
+        args: {
+          dest: t.recipient,
+          value: t.amount.toString(),
+        },
+        name: t.useAllAmount ? "transfer" : "transferKeepAlive",
+        pallet: "balances",
+      };
+
+    case "bond":
+      if (isFirstBond(a)) {
+        return {
+          pallet: "staking",
+          name: "bond",
+          args: {
+            // Spec choice: we always set the account as both the stash and its controller
+            controller: a.freshAddress,
+            value: t.amount.toString(),
+            // The rewards destination. Can be "Stash", "Staked", "Controller" or "{ Account: accountId }"".
+            payee: t.rewardDestination || "Stash",
+          },
+        };
+      } else {
+        // Add some extra amount from the stash's `free_balance` into the staking balance.
+        // Can only be called when `EraElectionStatus` is `Closed`.
+        return {
+          pallet: "staking",
+          name: "bondExtra",
+          args: {
+            maxAdditional: t.amount.toString(),
+          },
+        };
+      }
+
+    case "unbond":
+      // Construct a transaction to unbond funds from a Stash account.
+      // Must be signed by the controller, and can be only called when `EraElectionStatus` is `Closed`.
+      return {
+        pallet: "staking",
+        name: "unbond",
+        args: {
+          value: t.amount.toString(),
+        },
+      };
+
+    case "rebond":
+      // Rebond a portion of the stash scheduled to be unlocked.
+      // Must be signed by the controller, and can be only called when `EraElectionStatus` is `Closed`.
+      return {
+        pallet: "staking",
+        name: "rebond",
+        args: {
+          value: t.amount.toString(),
+        },
+      };
+
+    case "withdrawUnbonded":
+      // Remove any unbonded chunks from the `unbonding` queue from our management
+      // Must be signed by the controller, and can be only called when `EraElectionStatus` is `Closed`.
+      return {
+        pallet: "staking",
+        name: "withdrawUnbonded",
+        args: {
+          numSlashingSpans: a.polkadotResources?.numSlashingSpans || 0,
+        },
+      };
+
+    case "setController":
+      // Set the current account as its own controller
+      return {
+        pallet: "staking",
+        name: "setController",
+        args: { controller: a.freshAddress },
+      };
+
+    case "nominate":
+      // Construct a transaction to nominate validators.
+      // Must be signed by the controller, and can be only called when `EraElectionStatus` is `Closed`.
+      return {
+        pallet: "staking",
+        name: "nominate",
+        args: {
+          targets: t.validators,
+        },
+      };
+
+    case "chill":
+      // Declare the desire to cease validating or nominating. Does not unbond funds.
+      // Must be signed by the controller, and can be only called when `EraElectionStatus` is `Closed`.
+      return {
+        pallet: "staking",
+        name: "chill",
+        args: {},
+      };
+
+    case "claimReward":
+      // Pay out all the stakers behind a single validator for a single era.
+      // Any account can call this function, even if it is not one of the stakers.
+      // Can only be called when `EraElectionStatus` is `Closed`.
+      return {
+        pallet: "staking",
+        name: "payoutStakers",
+        args: {
+          validatorStash: validator,
+          era: t.era,
+        },
+      };
+
+    default:
+      throw new Error("Unknown mode in transaction");
+  }
+};
+
+/**
+ *
+ * @param {Account} a
+ * @param {Transaction} t
+ * @param {boolean} forceLatestParams - forces the use of latest transaction params
+ */
+export const buildTransaction = async (
+  a: PolkadotAccount,
+  t: Transaction,
+  forceLatestParams = false
+) => {
+  await loadPolkadotCrypto();
+
+  const { extrinsics, registry } = await getRegistry();
+  const info = forceLatestParams
+    ? await getTransactionParams.force()
+    : await getTransactionParams();
+  // Get the correct extrinsics params depending on transaction
+  const extrinsicParams = getExtrinsicParams(a, t);
+  const address = a.freshAddress;
+  const { blockHash, genesisHash } = info;
+  const blockNumber = registry
+    .createType("BlockNumber", info.blockNumber)
+    .toHex();
+  const era = registry
+    .createType("ExtrinsicEra", {
+      current: info.blockNumber,
+      period: DEFAULTS.eraPeriod,
+    })
+    .toHex();
+  const nonce = registry.createType("Compact<Index>", getNonce(a)).toHex();
+  const specVersion = registry.createType("u32", info.specVersion).toHex();
+  const tip = registry
+    .createType("Compact<Balance>", info.tip || DEFAULTS.tip)
+    .toHex();
+  const transactionVersion = registry
+    .createType("u32", info.transactionVersion)
+    .toHex();
+  const methodFunction =
+    extrinsics[extrinsicParams.pallet][extrinsicParams.name];
+  const methodArgs = methodFunction.meta.args;
+  const method = methodFunction(
+    ...methodArgs.map((arg) => {
+      if (
+        extrinsicParams.args[stringCamelCase(arg.name.toString())] === undefined
+      ) {
+        throw new Error(
+          `Method ${extrinsicParams.pallet}::${
+            extrinsicParams.name
+          } expects argument ${arg.toString()}, but got undefined`
+        );
+      }
+
+      return extrinsicParams.args[stringCamelCase(arg.name.toString())];
+    })
+  ).toHex();
+  const unsigned = {
+    address,
+    blockHash,
+    blockNumber,
+    era,
+    genesisHash,
+    method,
+    nonce,
+    signedExtensions: registry.signedExtensions,
+    specVersion,
+    tip,
+    transactionVersion,
+    version: EXTRINSIC_VERSION,
+  };
+  return {
+    registry,
+    unsigned,
+  };
+};

package/src/js-createTransaction.ts

@@ -0,0 +1,22 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "./types";
+
+/**
+ * Create an empty transaction
+ *
+ * @returns {Transaction}
+ */
+const createTransaction = (): Transaction => ({
+  family: "polkadot",
+  mode: "send",
+  amount: new BigNumber(0),
+  recipient: "",
+  useAllAmount: false,
+  fees: null,
+  validators: [],
+  era: null,
+  rewardDestination: null,
+  numSlashingSpans: Number(0),
+});
+
+export default createTransaction;

package/src/js-estimateMaxSpendable.ts

@@ -0,0 +1,37 @@
+import { BigNumber } from "bignumber.js";
+import type { AccountLike, Account } from "@ledgerhq/types-live";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import type { PolkadotAccount, Transaction } from "./types";
+import { calculateAmount } from "./logic";
+import getEstimatedFees from "./js-getFeesForTransaction";
+import createTransaction from "./js-createTransaction";
+import { loadPolkadotCrypto } from "./polkadot-crypto";
+
+/**
+ * Returns the maximum possible amount for transaction
+ *
+ * @param {Object} param - the account, parentAccount and transaction
+ */
+const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction | null | undefined;
+}): Promise<BigNumber> => {
+  await loadPolkadotCrypto();
+  const a = getMainAccount(account, parentAccount) as PolkadotAccount;
+  const t = { ...createTransaction(), ...transaction, useAllAmount: true };
+  const fees = await getEstimatedFees({
+    a,
+    t,
+  });
+  return calculateAmount({
+    a,
+    t: { ...t, fees },
+  });
+};
+
+export default estimateMaxSpendable;

package/src/js-getFeesForTransaction.ts

@@ -0,0 +1,41 @@
+import { BigNumber } from "bignumber.js";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+import type { PolkadotAccount, Transaction } from "./types";
+import { getPaymentInfo } from "./cache";
+import { calculateAmount } from "./logic";
+import { buildTransaction } from "./js-buildTransaction";
+import { fakeSignExtrinsic } from "./js-signOperation";
+
+/**
+ * Fetch the transaction fees for a transaction
+ *
+ * @param {Account} a
+ * @param {Transaction} t
+ */
+const getEstimatedFees = async ({
+  a,
+  t,
+}: {
+  a: PolkadotAccount;
+  t: Transaction;
+}): Promise<BigNumber> => {
+  const transaction = {
+    ...t,
+    recipient: getAbandonSeedAddress(a.currency.id),
+    // Always use a fake recipient to estimate fees
+    amount: calculateAmount({
+      a,
+      t: { ...t, fees: new BigNumber(0) },
+    }), // Remove fees if present since we are fetching fees
+  };
+  const { unsigned, registry } = await buildTransaction(a, transaction);
+  const fakeSignedTx = await fakeSignExtrinsic(unsigned, registry);
+  const payment = await getPaymentInfo({
+    a,
+    t: transaction,
+    signedTx: fakeSignedTx,
+  });
+  return new BigNumber(payment.partialFee);
+};
+
+export default getEstimatedFees;

package/src/js-getTransactionStatus.ts

@@ -0,0 +1,350 @@
+import { BigNumber } from "bignumber.js";
+import {
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  AmountRequired,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+  FeeNotLoaded,
+} from "@ledgerhq/errors";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import type { PolkadotAccount, Transaction, TransactionStatus } from "./types";
+import {
+  PolkadotUnauthorizedOperation,
+  PolkadotElectionClosed,
+  PolkadotNotValidator,
+  PolkadotNoUnlockedBalance,
+  PolkadotNoNominations,
+  PolkadotAllFundsWarning,
+  PolkadotBondMinimumAmount,
+  PolkadotBondMinimumAmountWarning,
+  PolkadotMaxUnbonding,
+  PolkadotValidatorsRequired,
+  PolkadotDoMaxSendInstead,
+} from "./errors";
+import { verifyValidatorAddresses } from "./api";
+import {
+  EXISTENTIAL_DEPOSIT,
+  FEES_SAFETY_BUFFER,
+  isFirstBond,
+  isController,
+  isStash,
+  hasLockedBalance,
+  hasMaxUnlockings,
+  calculateAmount,
+  getMinimumAmountToBond,
+  getMinimumBalance,
+  EXISTENTIAL_DEPOSIT_RECOMMENDED_MARGIN,
+} from "./logic";
+import { isValidAddress } from "./address";
+import { getCurrentPolkadotPreloadData } from "./preload";
+import { isControllerAddress, isNewAccount, isElectionClosed } from "./cache";
+import { loadPolkadotCrypto } from "./polkadot-crypto";
+
+// Should try to refacto
+const getSendTransactionStatus = async (
+  a: PolkadotAccount,
+  t: Transaction
+): Promise<TransactionStatus> => {
+  const errors: any = {};
+  const warnings: any = {};
+
+  if (!t.fees) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  if (!t.recipient) {
+    errors.recipient = new RecipientRequired("");
+  } else if (a.freshAddress === t.recipient) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  } else if (!isValidAddress(t.recipient)) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: a.currency.name,
+    });
+  }
+
+  const estimatedFees = t.fees || new BigNumber(0);
+  const amount = calculateAmount({
+    a,
+    t,
+  });
+  const totalSpent = amount.plus(estimatedFees);
+
+  if (amount.lte(0) && !t.useAllAmount) {
+    errors.amount = new AmountRequired();
+  }
+
+  const minimumBalanceExistential = getMinimumBalance(a);
+  const leftover = a.spendableBalance.minus(totalSpent);
+
+  if (
+    minimumBalanceExistential.gt(0) &&
+    leftover.lt(minimumBalanceExistential) &&
+    leftover.gt(0)
+  ) {
+    errors.amount = new PolkadotDoMaxSendInstead("", {
+      minimumBalance: formatCurrencyUnit(
+        a.currency.units[0],
+        EXISTENTIAL_DEPOSIT,
+        { showCode: true }
+      ),
+    });
+  } else if (
+    !errors.amount &&
+    !t.useAllAmount &&
+    a.spendableBalance.lte(
+      EXISTENTIAL_DEPOSIT.plus(EXISTENTIAL_DEPOSIT_RECOMMENDED_MARGIN)
+    )
+  ) {
+    errors.amount = new NotEnoughBalance();
+  } else if (totalSpent.gt(a.spendableBalance)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  if (
+    !errors.amount &&
+    a.polkadotResources?.lockedBalance.gt(0) &&
+    (t.useAllAmount ||
+      a.spendableBalance.minus(totalSpent).lt(FEES_SAFETY_BUFFER))
+  ) {
+    warnings.amount = new PolkadotAllFundsWarning();
+  }
+
+  if (
+    !errors.recipient &&
+    amount.lt(EXISTENTIAL_DEPOSIT) &&
+    (await isNewAccount(t.recipient))
+  ) {
+    errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
+      minimalAmount: formatCurrencyUnit(
+        a.currency.units[0],
+        EXISTENTIAL_DEPOSIT,
+        {
+          showCode: true,
+        }
+      ),
+    });
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount: amount.lt(0) ? new BigNumber(0) : amount,
+    totalSpent,
+    family: t.family,
+  });
+};
+
+const getTransactionStatus = async (a: PolkadotAccount, t: Transaction) => {
+  await loadPolkadotCrypto();
+
+  const errors: {
+    staking?: Error;
+    amount?: Error;
+    recipient?: Error;
+    unbondings?: Error;
+  } = {};
+  const warnings: {
+    amount?: Error;
+  } = {};
+  const preloaded = getCurrentPolkadotPreloadData();
+  const { staking, validators } = preloaded;
+  const minimumBondBalance = new BigNumber(preloaded.minimumBondBalance);
+
+  if (t.mode === "send") {
+    return await getSendTransactionStatus(a, t);
+  }
+
+  if (
+    (staking && !staking.electionClosed) || // Preloaded
+    (!staking && (await !isElectionClosed())) // Fallback
+  ) {
+    errors.staking = new PolkadotElectionClosed();
+  }
+
+  const amount = calculateAmount({
+    a,
+    t,
+  });
+  const unlockingBalance =
+    a.polkadotResources?.unlockingBalance || new BigNumber(0);
+  const unlockedBalance =
+    a.polkadotResources?.unlockedBalance || new BigNumber(0);
+  const currentBonded =
+    a.polkadotResources?.lockedBalance.minus(unlockingBalance) ||
+    new BigNumber(0);
+
+  const minimumAmountToBond = getMinimumAmountToBond(a, minimumBondBalance);
+
+  switch (t.mode) {
+    case "bond":
+      if (amount.lt(minimumAmountToBond)) {
+        errors.amount = new PolkadotBondMinimumAmount("", {
+          minimumBondAmount: formatCurrencyUnit(
+            a.currency.units[0],
+            minimumAmountToBond,
+            { showCode: true }
+          ),
+        });
+      }
+
+      if (isFirstBond(a)) {
+        // Not a stash yet -> bond method sets the controller
+        if (!t.recipient) {
+          errors.recipient = new RecipientRequired("");
+        } else if (!isValidAddress(t.recipient)) {
+          errors.recipient = new InvalidAddress("", {
+            currencyName: a.currency.name,
+          });
+        } else if (await isControllerAddress(t.recipient)) {
+          errors.recipient = new PolkadotUnauthorizedOperation(
+            "Recipient is already a controller"
+          );
+        }
+      }
+
+      break;
+
+    case "unbond":
+      if (!isController(a) || !hasLockedBalance(a)) {
+        errors.staking = new PolkadotUnauthorizedOperation();
+      }
+
+      if (hasMaxUnlockings(a)) {
+        errors.unbondings = new PolkadotMaxUnbonding();
+      }
+
+      if (amount.lte(0)) {
+        errors.amount = new AmountRequired();
+      } else if (
+        amount.gt(currentBonded.minus(minimumBondBalance)) &&
+        amount.lt(currentBonded)
+      ) {
+        warnings.amount = new PolkadotBondMinimumAmountWarning("", {
+          minimumBondBalance: formatCurrencyUnit(
+            a.currency.units[0],
+            minimumBondBalance,
+            { showCode: true }
+          ),
+        });
+      } else if (amount.gt(currentBonded)) {
+        errors.amount = new NotEnoughBalance();
+      }
+
+      break;
+
+    case "rebond":
+      if (!isController(a)) {
+        errors.staking = new PolkadotUnauthorizedOperation();
+      }
+
+      if (amount.lte(0)) {
+        errors.amount = new AmountRequired();
+      } else if (amount.gt(unlockingBalance)) {
+        errors.amount = new NotEnoughBalance();
+      } else if (amount.lt(minimumAmountToBond)) {
+        warnings.amount = new PolkadotBondMinimumAmountWarning("", {
+          minimumBondBalance: formatCurrencyUnit(
+            a.currency.units[0],
+            minimumBondBalance,
+            { showCode: true }
+          ),
+        });
+      }
+
+      break;
+
+    case "withdrawUnbonded":
+      if (!isController(a)) {
+        errors.staking = new PolkadotUnauthorizedOperation();
+      }
+
+      if (unlockedBalance.lte(0)) {
+        errors.amount = new PolkadotNoUnlockedBalance();
+      }
+
+      break;
+
+    case "nominate":
+      if (!isController(a)) {
+        errors.staking = new PolkadotUnauthorizedOperation();
+      } else if (!t.validators || t.validators?.length === 0) {
+        errors.staking = new PolkadotValidatorsRequired();
+      } else {
+        if (validators && validators.length) {
+          // Validate directly with preloaded data
+          const notValidators = t.validators?.filter(
+            (address) => !validators.find((v) => v.address === address)
+          );
+
+          if (notValidators && notValidators.length) {
+            errors.staking = new PolkadotNotValidator(undefined, {
+              validators: notValidators,
+            });
+          }
+        } else {
+          // Fallback with api call
+          const notValidators = await verifyValidatorAddresses(
+            t.validators || []
+          );
+
+          if (notValidators.length) {
+            errors.staking = new PolkadotNotValidator(undefined, {
+              validators: notValidators,
+            });
+            break;
+          }
+        }
+      }
+
+      break;
+
+    case "chill":
+      if (!isController(a)) {
+        errors.staking = new PolkadotUnauthorizedOperation();
+      } else if (!a.polkadotResources?.nominations) {
+        errors.staking = new PolkadotNoNominations();
+      }
+
+      break;
+
+    case "setController":
+      if (!isStash(a)) {
+        errors.staking = new PolkadotUnauthorizedOperation();
+      }
+      break;
+  }
+
+  const estimatedFees = t.fees || new BigNumber(0);
+  const totalSpent =
+    t.mode === "bond" ? amount.plus(estimatedFees) : estimatedFees;
+
+  if (t.mode === "bond" || t.mode === "unbond" || t.mode === "rebond") {
+    if (amount.lte(0)) {
+      errors.amount = new AmountRequired();
+    }
+  }
+
+  if (
+    t.mode === "bond" &&
+    a.spendableBalance.minus(totalSpent).lt(FEES_SAFETY_BUFFER)
+  ) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  if (totalSpent.gt(a.spendableBalance)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount: amount.lt(0) ? new BigNumber(0) : amount,
+    totalSpent,
+  });
+};
+
+export default getTransactionStatus;

package/src/js-prepareTransaction.ts

@@ -0,0 +1,27 @@
+import type { PolkadotAccount, Transaction } from "./types";
+import getEstimatedFees from "./js-getFeesForTransaction";
+import { loadPolkadotCrypto } from "./polkadot-crypto";
+
+const sameFees = (a, b) => (!a || !b ? a === b : a.eq(b));
+
+/**
+ * Calculate fees for the current transaction
+ * @param {PolkadotAccount} a
+ * @param {Transaction} t
+ */
+const prepareTransaction = async (a: PolkadotAccount, t: Transaction) => {
+  await loadPolkadotCrypto();
+  let fees = t.fees;
+  fees = await getEstimatedFees({
+    a,
+    t,
+  });
+
+  if (!sameFees(t.fees, fees)) {
+    return { ...t, fees };
+  }
+
+  return t;
+};
+
+export default prepareTransaction;