@ledgerhq/coin-icon 0.4.1-next.0

package/src/api/node.ts

@@ -0,0 +1,115 @@
+import { BigNumber } from "bignumber.js";
+import IconService from "icon-sdk-js";
+import type { IcxTransaction, SignedTransaction } from "icon-sdk-js";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { isTestnet } from "../logic";
+import { GOVERNANCE_SCORE_ADDRESS, IISS_SCORE_ADDRESS } from "../constants";
+import { IconAccount } from "../types/index";
+import { SignedOperation } from "@ledgerhq/types-live";
+import { IconDelegationType } from "./api-type";
+import { getCoinConfig } from "../config";
+
+const { HttpProvider } = IconService;
+const { IconBuilder } = IconService;
+
+/**
+ * Returns Testnet RPC URL if the current currency is testnet
+ * @param {currency} currency
+ */
+export function getRpcUrl(currency: CryptoCurrency): string {
+  const currencyConfig = getCoinConfig();
+  let rpcUrl = currencyConfig.infra.node_endpoint;
+  if (isTestnet(currency)) {
+    rpcUrl = currencyConfig.infra.node_testnet_endpoint;
+  }
+  return rpcUrl;
+}
+
+export function getDebugRpcUrl(currency: CryptoCurrency): string {
+  const currencyConfig = getCoinConfig();
+  let rpcUrl = currencyConfig.infra.debug_endpoint;
+  if (isTestnet(currency)) {
+    rpcUrl = currencyConfig.infra.debug_testnet_endpoint;
+  }
+  return rpcUrl;
+}
+
+/**
+ * Broadcast blob to blockchain
+ */
+export const broadcastTransaction = async (
+  signedOperation: SignedOperation,
+  currency: CryptoCurrency,
+) => {
+  const { hash } = await submit(signedOperation, currency);
+  return { hash };
+};
+
+export const submit = async (signedOperation: SignedOperation, currency: CryptoCurrency) => {
+  const rpcURL = getRpcUrl(currency);
+
+  const httpProvider = new HttpProvider(rpcURL);
+  const iconService = new IconService(httpProvider);
+
+  const signedTransaction = {
+    getProperties: () => signedOperation.rawData,
+    getSignature: () => signedOperation.signature,
+  };
+
+  const response = await iconService
+    .sendTransaction(signedTransaction as SignedTransaction)
+    .execute();
+  return {
+    hash: response,
+  };
+};
+
+/**
+ * Obtain fees from blockchain
+ */
+export const getFees = async (
+  unsigned: IcxTransaction,
+  account: IconAccount,
+): Promise<BigNumber> => {
+  const debugRpcUrl = getDebugRpcUrl(account.currency);
+  const httpProvider = new HttpProvider(debugRpcUrl);
+  const iconService = new IconService(httpProvider);
+  const res = await iconService.estimateStep(unsigned).execute();
+  return new BigNumber(res);
+};
+
+/**
+ * Get step price from governance contract
+ */
+export const getStepPrice = async (account: IconAccount): Promise<BigNumber> => {
+  const rpcURL = getRpcUrl(account.currency);
+  const httpProvider = new HttpProvider(rpcURL);
+  const iconService = new IconService(httpProvider);
+  const txBuilder = new IconBuilder.CallBuilder();
+  const stepPriceTx = txBuilder.to(GOVERNANCE_SCORE_ADDRESS).method("getStepPrice").build();
+  const res = await iconService.call(stepPriceTx).execute();
+  return new BigNumber(res);
+};
+
+export const getDelegation = async (
+  address: string,
+  currency: CryptoCurrency,
+): Promise<IconDelegationType> => {
+  const rpcURL = getRpcUrl(currency);
+  const httpProvider = new HttpProvider(rpcURL);
+  const iconService = new IconService(httpProvider);
+  const delegationTx = new IconBuilder.CallBuilder()
+    .to(IISS_SCORE_ADDRESS)
+    .method("getDelegation")
+    .params({
+      address,
+    })
+    .build();
+
+  const res = await iconService.call(delegationTx).execute();
+  return {
+    delegations: res.delegations,
+    totalDelegated: new BigNumber(res.totalDelegated),
+    votingPower: new BigNumber(res.votingPower),
+  };
+};

package/src/bridge/index.ts

@@ -0,0 +1,76 @@
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import {
+  defaultUpdateTransaction,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { CoinConfig } from "@ledgerhq/coin-framework/config";
+
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import resolver from "../hw-getAddress";
+import { initAccount } from "../initAccount";
+import { broadcast } from "../broadcast";
+import { createTransaction } from "../createTransaction";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { getTransactionStatus } from "../getTransactionStatus";
+import { prepareTransaction } from "../prepareTransaction";
+import { buildSignOperation } from "../signOperation";
+import { getAccountShape } from "../synchronization";
+import { assignFromAccountRaw, assignToAccountRaw } from "../serialization";
+import type { Transaction } from "../types/index";
+import { IconSigner } from "../signer";
+import { IconCoinConfig, setCoinConfig } from "../config";
+
+export function buildCurrencyBridge(signerContext: SignerContext<IconSigner>): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddress,
+  });
+
+  return {
+    preload: async () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+}
+
+export function buildAccountBridge(
+  signerContext: SignerContext<IconSigner>,
+): AccountBridge<Transaction> {
+  const getAddress = resolver(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+  const sync = makeSync({ getAccountShape });
+
+  return {
+    createTransaction,
+    updateTransaction: defaultUpdateTransaction,
+    prepareTransaction,
+    getTransactionStatus,
+    sync,
+    receive,
+    assignToAccountRaw,
+    assignFromAccountRaw,
+    initAccount,
+    signOperation,
+    broadcast,
+    estimateMaxSpendable,
+  };
+}
+
+export function createBridges(
+  signerContext: SignerContext<IconSigner>,
+  coinConfig: CoinConfig<IconCoinConfig>,
+) {
+  setCoinConfig(coinConfig);
+
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge.integration.test.ts

@@ -0,0 +1,107 @@
+import type { DatasetTest, CurrenciesData } from "@ledgerhq/types-live";
+import type { Transaction } from "./types";
+import { fromTransactionRaw } from "./transaction";
+import BigNumber from "bignumber.js";
+import {
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  InvalidAddress,
+  NotEnoughBalance,
+} from "@ledgerhq/errors";
+
+const TEST_ADDRESS = "hxe52720d9125586e64c745bf3c2c1917dbb46f9ba";
+
+const icon: CurrenciesData<Transaction> = {
+  scanAccounts: [
+    {
+      name: "icon seed 1",
+      apdus: `
+      => e00200010d038000002c8049435880000000
+      <= 410426dd3cdd69f3604e9c1d8f3021b20e133524f12894b9ef8e35d3f1f5244516d18b7bb0d1fee7b7c2972d5cde08190d66cf932d0addd5ac87f53198d050940ccb2a6878626232396531313463626434303939346136346462303137626363323233616661353135363966669fd5109b2b2077b50f18fee878efef03cef0cfb5c3256ea9e55f44fa0e9ae5289000
+      => e002000115058000002c80494358800000008000000080000000
+      <= 4104c1142d5b765d3026e801fd3946d9673051c7e3c3bd0eecd8ca27b6be079c9ee6b7b9f311b9eecb2995efd7e4a7ef9287a7f8878751d3227689c25a324270e8082a687863663465326339346235323631396637326161346461313333373061613663316333646164303064ff4e5e0cebe9462a469955997216658ce22953f79d272a6a1ecf3b3cdcb3549a9000
+      => e002000115058000002c80494358800000008000000080000001
+      <= 410429e40c4a50f96a32b622e218114c9204f66763c997dadb8c719a95d3a2d98fda3b00ccc9f3d491906d453fa2a63298817eb6af94c77a47f5eb4baa43cbb73a832a6878666330343962346365363063633539363834383764313830643963343236336536333138313733392ed566d1841e629d6f3040a23918ee84015fb60b99824d7dcadde65bcb01bb089000
+      => e002000115058000002c80494358800000008000000080000002
+      <= 41040310ab9742ae76a33cfb81fbb90f7d2c16af8dbe543cea73dc62dda4eb79eea4363cabad566329103dc8c6d1f29d6e005d608e35d97d80337e1ca5fd07f3da5b2a6878303139393332346162343038343733313565633339373264313738316239646363643136323061650ce87de91bb446401889398f585fc09a525bf7841dc254d94def7023b40523069000
+      `,
+    },
+  ],
+  accounts: [
+    {
+      FIXME_tests: ["balance is sum of ops"],
+      raw: {
+        id: `js:2:icon:${TEST_ADDRESS}:`,
+        seedIdentifier: `${TEST_ADDRESS}`,
+        name: "ICON 1",
+        derivationMode: "",
+        index: 0,
+        freshAddress: `${TEST_ADDRESS}`,
+        freshAddressPath: "44'/4801368'/0'/0'/0'",
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "icon",
+        lastSyncDate: "",
+        balance: "299569965",
+      },
+      transactions: [
+        {
+          name: "recipient and sender must not be the same",
+          transaction: fromTransactionRaw({
+            family: "icon",
+            recipient: `${TEST_ADDRESS}`,
+            amount: "100000000",
+            mode: "send",
+            fees: "0.00125",
+          }),
+          expectedStatus: {
+            amount: new BigNumber("100000000"),
+            errors: {
+              recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Not a valid address",
+          transaction: fromTransactionRaw({
+            family: "icon",
+            recipient: "iconinv",
+            amount: "100000000",
+            mode: "send",
+            fees: null,
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new InvalidAddress(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Not enough balance",
+          transaction: fromTransactionRaw({
+            family: "icon",
+            recipient: "hxedaf3b2027fbbc0a31f589299c0b34533cd8edac",
+            amount: "1000000000000000000000000",
+            mode: "send",
+            fees: null,
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+      ],
+    },
+  ],
+};
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    icon,
+  },
+};

package/src/broadcast.ts

@@ -0,0 +1,18 @@
+import { Account, Operation, SignedOperation } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+
+import { broadcastTransaction } from "./api/node";
+
+/**
+ * Broadcast the signed transaction
+ */
+export async function broadcast({
+  account,
+  signedOperation,
+}: {
+  account: Account;
+  signedOperation: SignedOperation;
+}): Promise<Operation> {
+  const { hash } = await broadcastTransaction(signedOperation, account.currency);
+  return patchOperationWithHash(signedOperation.operation, hash);
+}

package/src/buildTransaction.ts

@@ -0,0 +1,53 @@
+import type { IconAccount, Transaction } from "./types";
+import IconService from "icon-sdk-js";
+import type { IcxTransaction } from "icon-sdk-js";
+import { getNid, getNonce } from "./logic";
+import BigNumber from "bignumber.js";
+import { RPC_VERSION } from "./constants";
+
+const { IconBuilder, IconConverter } = IconService;
+
+const buildTransferTransaction = (
+  account: IconAccount,
+  transaction: Transaction,
+  stepLimit?: BigNumber | undefined,
+): IcxTransaction => {
+  const address = account.freshAddress;
+  const icxTransactionBuilder = new IconBuilder.IcxTransactionBuilder();
+  const icxTransferData = icxTransactionBuilder
+    .from(address)
+    .to(transaction.recipient)
+    .value(IconConverter.toHexNumber(transaction.amount))
+    .nid(IconConverter.toHexNumber(getNid(account.currency)))
+    .nonce(IconConverter.toHexNumber(getNonce(account)))
+    .timestamp(IconConverter.toHexNumber(new Date().getTime() * 1000))
+    .version(IconConverter.toHexNumber(RPC_VERSION));
+  if (stepLimit) {
+    icxTransferData.stepLimit(IconConverter.toHexNumber(stepLimit));
+  }
+
+  return icxTransferData.build();
+};
+
+/**
+ *
+ * @param {Account} account
+ * @param {Transaction} transaction
+ */
+export const buildTransaction = async (
+  account: IconAccount,
+  transaction: Transaction,
+  stepLimit?: BigNumber | undefined,
+) => {
+  let unsigned: IcxTransaction | undefined;
+  switch (transaction.mode) {
+    case "send":
+      unsigned = buildTransferTransaction(account, transaction, stepLimit);
+      break;
+    default:
+      throw new Error(`Unsupported transaction mode: ${transaction.mode}`);
+  }
+  return {
+    unsigned,
+  };
+};

package/src/cli-transaction.ts

@@ -0,0 +1,49 @@
+import type { AccountLike } from "@ledgerhq/types-live";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import type { IconAccount, Transaction } from "./types";
+
+const options = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send, stake, unstake",
+  },
+];
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: Record<string, any>,
+): Transaction[] {
+  return flatMap(transactions, ({ transaction, account }) => {
+    invariant(
+      transaction.family === "icon",
+      "[cli-transaction] inferTransactions expects icon family transaction",
+    );
+
+    if (account.type === "Account") {
+      invariant((account as IconAccount).iconResources, "unactivated account");
+    }
+
+    if (account.type === "TokenAccount") {
+      const isDelisted = account.token.delisted === true;
+      invariant(!isDelisted, "token is delisted");
+    }
+
+    return {
+      ...transaction,
+      family: "icon",
+      mode: opts.mode || "send",
+    } as Transaction;
+  });
+}
+
+export default function makeCliTools() {
+  return {
+    options,
+    inferTransactions,
+  };
+}

package/src/config.ts

@@ -0,0 +1,29 @@
+import { CurrencyConfig, CoinConfig } from "@ledgerhq/coin-framework/config";
+import { MissingCoinConfig } from "@ledgerhq/coin-framework/errors";
+
+export type IconConfig = {
+  infra: {
+    indexer: string;
+    indexer_testnet: string;
+    node_endpoint: string;
+    node_testnet_endpoint: string;
+    debug_endpoint: string;
+    debug_testnet_endpoint: string;
+  };
+};
+
+export type IconCoinConfig = CurrencyConfig & IconConfig;
+
+let coinConfig: CoinConfig<IconCoinConfig> | undefined;
+
+export const setCoinConfig = (config: CoinConfig<IconCoinConfig>): void => {
+  coinConfig = config;
+};
+
+export const getCoinConfig = (): IconCoinConfig => {
+  if (!coinConfig) {
+    throw new MissingCoinConfig();
+  }
+
+  return coinConfig();
+};

package/src/constants.ts

@@ -0,0 +1,14 @@
+export const GOVERNANCE_SCORE_ADDRESS = "cx0000000000000000000000000000000000000001";
+export const IISS_SCORE_ADDRESS = "cx0000000000000000000000000000000000000000";
+export const LIMIT = 100;
+export const BERLIN_TESTNET_NID = 7;
+export const MAINNET_NID = 1;
+export const I_SCORE_UNIT = 1000;
+export const RPC_VERSION = 3;
+export const DEFAULT_STEP_LIMIT = 200000;
+
+export const PREP_TYPE = {
+  MAIN: "Main P-Rep",
+  SUB: "Sub P-Rep",
+  CANDIDATE: "Candidate",
+};

package/src/createTransaction.ts

@@ -0,0 +1,16 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "./types";
+
+/**
+ * Create an empty transaction
+ *
+ * @returns {Transaction}
+ */
+export const createTransaction = (): Transaction => ({
+  family: "icon",
+  mode: "send",
+  amount: new BigNumber(0),
+  recipient: "",
+  useAllAmount: false,
+  fees: null,
+});

package/src/deviceTransactionConfig.ts

@@ -0,0 +1,44 @@
+import type { AccountLike, Account } from "@ledgerhq/types-live";
+import type { Transaction, TransactionStatus } from "./types";
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+
+export type ExtraDeviceTransactionField = {
+  type: "icon.fees";
+  label: string;
+};
+
+function getDeviceTransactionConfig({
+  transaction,
+  account,
+  parentAccount,
+  status: { amount },
+}: {
+  account: AccountLike;
+  parentAccount?: Account;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+  const mainAccount = getMainAccount(account, parentAccount);
+  const { mode } = transaction;
+
+  if (!amount.isZero()) {
+    fields.push({
+      type: "amount",
+      label: "Amount",
+    });
+  }
+
+  if (mode !== "send") {
+    fields.push({
+      type: "address",
+      label: "From Address",
+      address: mainAccount.freshAddress,
+    });
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/errors.ts

@@ -0,0 +1,5 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const IconAllFundsWarning = createCustomErrorClass("IconAllFundsWarning");
+export const IconValidatorsRequired = createCustomErrorClass("IconValidatorsRequired");
+export const IconDoMaxSendInstead = createCustomErrorClass("IconDoMaxSendInstead");

package/src/estimateMaxSpendable.ts

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

package/src/getFeesForTransaction.ts

@@ -0,0 +1,46 @@
+import { BigNumber } from "bignumber.js";
+import type { IconAccount, Transaction } from "./types";
+import { getFees } from "./api/node";
+import { buildTransaction } from "./buildTransaction";
+import { getStepPrice } from "./api/node";
+import { FEES_SAFETY_BUFFER, calculateAmount } from "./logic";
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+
+/**
+ * Fetch the transaction fees for a transaction
+ *
+ * @param {IconAccount} account
+ * @param {Transaction} transaction
+ */
+const getEstimatedFees = async ({
+  account,
+  transaction,
+}: {
+  account: IconAccount;
+  transaction: Transaction;
+}): Promise<BigNumber> => {
+  const tx = {
+    ...transaction,
+    recipient: getAbandonSeedAddress(account.currency.id),
+    // Always use a fake recipient to estimate fees
+    amount: calculateAmount({
+      account,
+      transaction: {
+        ...transaction,
+        fees: new BigNumber(0),
+      },
+    }), // Remove fees if present since we are fetching fees
+  };
+  try {
+    const { unsigned } = await buildTransaction(account, tx);
+    const stepLimit = await getFees(unsigned, account);
+    transaction.stepLimit = stepLimit;
+    const stepPrice = await getStepPrice(account);
+    return stepLimit.multipliedBy(stepPrice);
+  } catch (_error) {
+    // Fix ME, the API of Icon throws an error when getting the fee with maximum balance
+    return FEES_SAFETY_BUFFER;
+  }
+};
+
+export default getEstimatedFees;