@ledgerhq/coin-icon 0.4.1-next.0

package/src/getTransactionStatus.ts

@@ -0,0 +1,139 @@
+import { BigNumber } from "bignumber.js";
+import {
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  FeeNotLoaded,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  AmountRequired,
+} from "@ledgerhq/errors";
+
+import type { IconAccount, Transaction, TransactionStatus } from "./types";
+
+import {
+  EXISTENTIAL_DEPOSIT,
+  EXISTENTIAL_DEPOSIT_RECOMMENDED_MARGIN,
+  FEES_SAFETY_BUFFER,
+  calculateAmount,
+  getMinimumBalance,
+  isSelfTransaction,
+  isValidAddress,
+} from "./logic";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { IconAllFundsWarning, IconDoMaxSendInstead } from "./errors";
+
+export const getSendTransactionStatus = async (
+  account: IconAccount,
+  transaction: Transaction,
+): Promise<TransactionStatus> => {
+  const errors: any = {};
+  const warnings: any = {};
+
+  // Check if fees are loaded
+  if (!transaction.fees) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  // Validate recipient
+  if (!transaction.recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (isSelfTransaction(account, transaction)) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  } else if (!isValidAddress(transaction.recipient)) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  const estimatedFees = transaction.fees || new BigNumber(0);
+  const amount = calculateAmount({ account, transaction });
+  const totalSpent = amount.plus(estimatedFees);
+
+  // Check if amount is valid
+  if (amount.lte(0) && !transaction.useAllAmount) {
+    errors.amount = new AmountRequired();
+  } else {
+    const minimumBalanceExistential = getMinimumBalance(account);
+    const leftover = account.spendableBalance.minus(totalSpent);
+    if (
+      minimumBalanceExistential.gt(0) &&
+      leftover.lt(minimumBalanceExistential) &&
+      leftover.gt(0)
+    ) {
+      errors.amount = new IconDoMaxSendInstead(
+        "Balance cannot be below {{minimumBalance}}. Send max to empty account.",
+        {
+          minimumBalance: formatCurrencyUnit(account.currency.units[0], EXISTENTIAL_DEPOSIT, {
+            showCode: true,
+          }),
+        },
+      );
+    } else if (
+      !errors.amount &&
+      !transaction.useAllAmount &&
+      account.spendableBalance.lte(EXISTENTIAL_DEPOSIT.plus(EXISTENTIAL_DEPOSIT_RECOMMENDED_MARGIN))
+    ) {
+      errors.amount = new NotEnoughBalance();
+    } else if (totalSpent.gt(account.spendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+
+    if (
+      !errors.amount &&
+      new BigNumber(account.iconResources?.totalDelegated)
+        .plus(account.iconResources?.votingPower)
+        .gt(0) &&
+      (transaction.useAllAmount ||
+        account.spendableBalance.minus(totalSpent).lt(FEES_SAFETY_BUFFER))
+    ) {
+      warnings.amount = new IconAllFundsWarning();
+    }
+
+    if (totalSpent.gt(account.spendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    estimatedFees,
+    amount: amount.lt(0) ? new BigNumber(0) : amount,
+    totalSpent,
+  });
+};
+
+export const getTransactionStatus = async (
+  account: IconAccount,
+  transaction: Transaction,
+): Promise<TransactionStatus> => {
+  switch (transaction.mode) {
+    case "send":
+      return await getSendTransactionStatus(account, transaction);
+    default: {
+      const errors: { amount?: Error; recipient?: Error } = {};
+      const warnings: { amount?: Error } = {};
+
+      const amount = calculateAmount({ account, transaction });
+      const estimatedFees = transaction.fees || new BigNumber(0);
+      const totalSpent = amount.plus(estimatedFees);
+
+      if (totalSpent.gt(account.spendableBalance)) {
+        errors.amount = new NotEnoughBalance();
+      }
+
+      // Validate amount
+      if (amount.lte(0) && !transaction.useAllAmount) {
+        errors.amount = new AmountRequired();
+      }
+
+      return {
+        errors,
+        warnings,
+        estimatedFees,
+        amount: amount.lt(0) ? new BigNumber(0) : amount,
+        totalSpent,
+      };
+    }
+  }
+};

package/src/hw-getAddress.ts

@@ -0,0 +1,19 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { IconAddress, IconSigner } from "./signer";
+
+const resolver = (signerContext: SignerContext<IconSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const r = (await signerContext(deviceId, signer =>
+      signer.getAddress(path, verify || false),
+    )) as IconAddress;
+    return {
+      address: r.address,
+      publicKey: r.publicKey,
+      path,
+    };
+  };
+};
+
+export default resolver;

package/src/initAccount.ts

@@ -0,0 +1,11 @@
+import { BigNumber } from "bignumber.js";
+import { IconAccount } from "./types";
+import { Account } from "@ledgerhq/types-live";
+
+export function initAccount(account: Account): void {
+  (account as IconAccount).iconResources = {
+    nonce: 0,
+    votingPower: BigNumber(0),
+    totalDelegated: BigNumber(0),
+  };
+}

package/src/logic.ts

@@ -0,0 +1,132 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { BigNumber } from "bignumber.js";
+import IconService from "icon-sdk-js";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import type { Account } from "@ledgerhq/types-live";
+import type { IconAccount, Transaction } from "./types";
+const { IconAmount } = IconService;
+import { BERLIN_TESTNET_NID, MAINNET_NID } from "./constants";
+
+/**
+ * @param {string|number|BigNumber} value value as loop
+ * @returns {BigNumber} value as ICX
+ */
+export const convertLoopToIcx = (value: string | number | BigNumber): BigNumber => {
+  return new BigNumber(IconAmount.fromLoop(value, IconAmount.Unit.ICX.toString()));
+};
+
+/**
+ * @param {string|number|BigNumber} value value as ICX
+ * @returns {BigNumber} value as loop
+ */
+export const convertICXtoLoop = (value: string | number | BigNumber): BigNumber => {
+  return new BigNumber(IconAmount.toLoop(value, IconAmount.Unit.ICX.toString()));
+};
+
+export const EXISTENTIAL_DEPOSIT = convertICXtoLoop(0.00125);
+export const EXISTENTIAL_DEPOSIT_RECOMMENDED_MARGIN = convertICXtoLoop(0.00125);
+export const FEES_SAFETY_BUFFER = convertICXtoLoop(0.00125); // Arbitrary buffer for paying fees of next transactions
+export const MAX_AMOUNT_INPUT = convertICXtoLoop(5000);
+/**
+ * Returns true if address is a valid md5
+ *
+ * @param {string} address
+ */
+export const isValidAddress = (address: string): boolean => {
+  if (!address) return false;
+  return !!address.match(/^[a-z0-9]{42}$/);
+};
+
+/**
+ * Returns true if transaction is a self transaction
+ *
+ * @param {Account} account
+ * @param {Transaction} transaction
+ */
+export const isSelfTransaction = (account: Account, transaction: Transaction): boolean => {
+  return transaction.recipient === account.freshAddress;
+};
+
+/**
+ * Returns nonce for an account
+ *
+ * @param {Account} account
+ */
+export const getNonce = (account: IconAccount): number => {
+  const lastPendingOp = account.pendingOperations[0];
+
+  const nonce = Math.max(
+    account.iconResources?.nonce || 0,
+    lastPendingOp && typeof lastPendingOp.transactionSequenceNumber === "number"
+      ? lastPendingOp.transactionSequenceNumber + 1
+      : 0,
+  );
+
+  return nonce;
+};
+
+/**
+ * Returns true if the current currency is testnet
+ *
+ * @param {currency} CryptoCurrency
+ */
+export function isTestnet(currency: CryptoCurrency): boolean {
+  return getCryptoCurrencyById(currency.id).isTestnetFor ? true : false;
+}
+
+export function getNid(currency: CryptoCurrency): number {
+  let nid = MAINNET_NID;
+  if (isTestnet(currency)) {
+    nid = BERLIN_TESTNET_NID;
+  }
+  return nid;
+}
+
+/**
+ * Calculate the real spendable
+ *
+ * @param {*} account
+ * @param {*} transaction
+ */
+const calculateMaxSend = (account: Account, transaction: Transaction): BigNumber => {
+  const amount = account.spendableBalance.minus(transaction.fees || 0);
+  return amount.lt(0) ? new BigNumber(0) : BigNumber(amount.toFixed(5));
+};
+
+/**
+ * Calculates correct amount if useAllAmount
+ *
+ * @param {*} param
+ */
+export const calculateAmount = ({
+  account,
+  transaction,
+}: {
+  account: IconAccount;
+  transaction: Transaction;
+}): BigNumber => {
+  let amount = transaction.amount;
+
+  if (transaction.useAllAmount) {
+    switch (transaction.mode) {
+      case "send":
+        amount = calculateMaxSend(account, transaction);
+        break;
+
+      default:
+        amount = account.spendableBalance.minus(transaction.fees || 0);
+        break;
+    }
+  } else if (transaction.amount.gt(MAX_AMOUNT_INPUT)) {
+    return new BigNumber(MAX_AMOUNT_INPUT);
+  }
+
+  return amount.lt(0) ? new BigNumber(0) : amount;
+};
+
+export const getMinimumBalance = (account: Account): BigNumber => {
+  const lockedBalance = account.balance.minus(account.spendableBalance);
+  return lockedBalance.lte(EXISTENTIAL_DEPOSIT)
+    ? EXISTENTIAL_DEPOSIT.minus(lockedBalance)
+    : new BigNumber(0);
+};

package/src/prepareTransaction.ts

@@ -0,0 +1,24 @@
+import type { IconAccount, Transaction } from "./types";
+import getEstimatedFees from "./getFeesForTransaction";
+import BigNumber from "bignumber.js";
+
+const sameFees = (a: BigNumber, b?: BigNumber | null) => (!a || !b ? a === b : a.eq(b));
+
+/**
+ * Prepare transaction before checking status
+ *
+ * @param {IconAccount} account
+ * @param {Transaction} transaction
+ */
+export const prepareTransaction = async (
+  account: IconAccount,
+  transaction: Transaction,
+): Promise<Transaction> => {
+  let fees = transaction.fees;
+  fees = await getEstimatedFees({ account, transaction });
+
+  if (fees && !sameFees(fees, transaction.fees)) {
+    return { ...transaction, fees };
+  }
+  return transaction;
+};

package/src/serialization.ts

@@ -0,0 +1,34 @@
+import { BigNumber } from "bignumber.js";
+import type { IconResourcesRaw, IconResources, IconAccount, IconAccountRaw } from "./types";
+import { AccountRaw, Account } from "@ledgerhq/types-live";
+
+export function toIconResourcesRaw(resources: IconResources): IconResourcesRaw {
+  const { nonce, votingPower, totalDelegated } = resources;
+  return {
+    nonce,
+    votingPower: votingPower.toString(),
+    totalDelegated: totalDelegated.toString(),
+  };
+}
+
+export function fromIconResourcesRaw(rawResources: IconResourcesRaw): IconResources {
+  const { nonce, votingPower, totalDelegated } = rawResources;
+  return {
+    nonce,
+    votingPower: new BigNumber(votingPower || 0),
+    totalDelegated: new BigNumber(totalDelegated || 0),
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw): void {
+  const iconAccount = account as IconAccount;
+  if (iconAccount.iconResources) {
+    (accountRaw as IconAccountRaw).iconResources = toIconResourcesRaw(iconAccount.iconResources);
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const iconResourcesRaw = (accountRaw as IconAccountRaw).iconResources;
+  if (iconResourcesRaw)
+    (account as IconAccount).iconResources = fromIconResourcesRaw(iconResourcesRaw);
+}

package/src/signOperation.ts

@@ -0,0 +1,140 @@
+import { BigNumber } from "bignumber.js";
+import { Observable } from "rxjs";
+
+import type { IconAccount, Transaction } from "./types";
+import type {
+  Account,
+  AccountBridge,
+  DeviceId,
+  Operation,
+  SignOperationEvent,
+} from "@ledgerhq/types-live";
+
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+
+import { buildTransaction } from "./buildTransaction";
+import { calculateAmount, getNonce } from "./logic";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import IconService, { IcxTransaction } from "icon-sdk-js";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { IconSignature, IconSigner } from "./signer";
+const { IconUtil, IconConverter } = IconService;
+
+const buildOptimisticOperation = (
+  account: Account,
+  transaction: Transaction,
+  fee: BigNumber,
+): Operation => {
+  const type = "OUT";
+  const value = new BigNumber(transaction.amount).plus(fee);
+  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 as IconAccount),
+    date: new Date(),
+    extra: {},
+  };
+
+  return operation;
+};
+
+/**
+ * Adds signature to unsigned transaction. Will likely be a call to Icon SDK
+ */
+const addSignature = (rawTransaction: IcxTransaction, signature: string) => {
+  return {
+    rawTransaction: {
+      ...rawTransaction,
+      signature: signature,
+    },
+    signature,
+  };
+};
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const buildSignOperation =
+  (signerContext: SignerContext<IconSigner>): AccountBridge<Transaction>["signOperation"] =>
+  ({
+    account,
+    transaction,
+    deviceId,
+  }: {
+    account: Account;
+    transaction: Transaction;
+    deviceId: DeviceId;
+  }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      let cancelled = false;
+      async function main() {
+        if (!transaction.fees) {
+          throw new FeeNotLoaded();
+        }
+
+        const transactionToSign = {
+          ...transaction,
+          amount: calculateAmount({
+            account: account as IconAccount,
+            transaction: transaction,
+          }),
+        };
+        const { unsigned } = await buildTransaction(
+          account as IconAccount,
+          transactionToSign,
+          transactionToSign.stepLimit,
+        );
+
+        o.next({ type: "device-signature-requested" });
+
+        const res = (await signerContext(deviceId, signer =>
+          signer.signTransaction(
+            account.freshAddressPath,
+            IconUtil.generateHashKey(IconConverter.toRawTransaction(unsigned)),
+          ),
+        )) as IconSignature;
+
+        const signed = addSignature(unsigned, res.signedRawTxBase64);
+
+        if (cancelled) return;
+        o.next({ type: "device-signature-granted" });
+
+        if (!signed.signature) {
+          throw new Error("No signature");
+        }
+
+        const operation = buildOptimisticOperation(
+          account,
+          transactionToSign,
+          transactionToSign.fees ?? new BigNumber(0),
+        );
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: signed.signature,
+            rawData: signed.rawTransaction,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+
+      return () => {
+        cancelled = true;
+      };
+    });
+
+export default buildSignOperation;

package/src/signer.ts

@@ -0,0 +1,14 @@
+export type IconAddress = {
+  publicKey: string;
+  address: string;
+  chainCode?: string;
+};
+export type IconSignature = {
+  signedRawTxBase64: string;
+  hashHex: string;
+};
+
+export interface IconSigner {
+  getAddress(path: string, shouldDisplay?: boolean): Promise<IconAddress>;
+  signTransaction(path: string, rawTxAscii: string): Promise<IconSignature>;
+}

package/src/specs.ts

@@ -0,0 +1,124 @@
+import invariant from "invariant";
+import { botTest, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { toOperationRaw } from "@ledgerhq/coin-framework/serialization/index";
+import { DeviceModelId } from "@ledgerhq/devices";
+import BigNumber from "bignumber.js";
+import expect from "expect";
+import { acceptTransaction } from "./speculos-deviceActions";
+import {
+  EXISTENTIAL_DEPOSIT,
+  EXISTENTIAL_DEPOSIT_RECOMMENDED_MARGIN,
+  convertICXtoLoop,
+} from "./logic";
+import { Transaction } from "./types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+
+const maxAccounts = 6;
+const currency = getCryptoCurrencyById("icon");
+
+// FIX ME ICON have a bug where the amounts from the API have imprecisions
+const expectedApproximate = (
+  value: BigNumber,
+  expected: BigNumber,
+  delta = convertICXtoLoop(0.000005),
+) => {
+  if (value.minus(expected).abs().gt(delta)) {
+    expect(value.toString()).toEqual(value.toString());
+  }
+};
+
+const icon: AppSpec<Transaction> = {
+  name: "Icon",
+  currency,
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Icon",
+  },
+  genericDeviceAction: acceptTransaction,
+  testTimeout: 2 * 60 * 1000,
+  transactionCheck: ({ maxSpendable }) => {
+    invariant(maxSpendable.gt(EXISTENTIAL_DEPOSIT_RECOMMENDED_MARGIN), "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;
+    delete opExpected.transactionSequenceNumber;
+    botTest("optimistic operation matches", () =>
+      expect(toOperationRaw(operation)).toMatchObject(opExpected),
+    );
+  },
+  mutations: [
+    {
+      name: "send 50%~",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge }) => {
+        invariant(account.spendableBalance.gt(0), "balance is 0");
+        const sibling = pickSiblings(siblings, maxAccounts);
+        let amount = account.spendableBalance.div(2).integerValue();
+
+        if (!sibling.used && amount.lt(EXISTENTIAL_DEPOSIT)) {
+          invariant(
+            account.spendableBalance.gt(EXISTENTIAL_DEPOSIT),
+            "send is too low to activate account",
+          );
+          amount = EXISTENTIAL_DEPOSIT;
+        }
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              recipient: sibling.freshAddress,
+            },
+            {
+              amount,
+            },
+          ],
+        };
+      },
+      test: ({ accountBeforeTransaction, operation, account }) => {
+        botTest("account spendable balance decreased with operation", () =>
+          expectedApproximate(
+            account.spendableBalance,
+            accountBeforeTransaction.spendableBalance.minus(operation.value),
+          ),
+        );
+      },
+    },
+    {
+      name: "send max",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge }) => {
+        invariant(account.spendableBalance.gt(0), "balance is 0");
+        const sibling = pickSiblings(siblings, maxAccounts);
+        return {
+          transaction: bridge.createTransaction(account),
+          updates: [
+            {
+              recipient: sibling.freshAddress,
+            },
+            {
+              useAllAmount: true,
+            },
+          ],
+        };
+      },
+      test: ({ account }) => {
+        botTest("account spendable balance is zero", () =>
+          expectedApproximate(account.spendableBalance, new BigNumber(0)),
+        );
+      },
+    },
+  ],
+};
+
+export default {
+  icon,
+};

package/src/speculos-deviceActions.ts

@@ -0,0 +1,46 @@
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "./types";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { deviceActionFlow, SpeculosButton } from "@ledgerhq/coin-framework/bot/specs";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+
+const confirmWording: Record<string, string> = {
+  send: "transfer",
+};
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Confirm",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => confirmWording[transaction.mode],
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction, account }) =>
+        formatCurrencyUnit(getAccountCurrency(account).units[0], transaction.amount, {
+          disableRounding: true,
+        }),
+    },
+    {
+      title: "Address",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => {
+        return transaction.recipient;
+      },
+    },
+    {
+      title: "Fees",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, status }) =>
+        formatCurrencyUnit(getAccountCurrency(account).units[0], status.estimatedFees, {
+          disableRounding: true,
+        }),
+    },
+    {
+      title: "Accept",
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});