@ledgerhq/coin-multiversx 0.2.0-next.0

package/src/buildTransaction.unit.test.ts

@@ -0,0 +1,49 @@
+import BigNumber from "bignumber.js";
+import { doBuildTransactionToSign } from "./buildTransaction";
+
+describe("doBuildTransactionToSign", () => {
+  it("should serialize transaction without data field", async () => {
+    const serializedTransaction = await doBuildTransactionToSign({
+      transaction: {
+        family: "multiversx",
+        mode: "send",
+        fees: null,
+        amount: new BigNumber("1"),
+        recipient: "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th",
+        gasLimit: 50000000,
+      },
+      sender: "erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx",
+      nonce: 1,
+      value: "0",
+      minGasLimit: 50000000,
+      chainID: "1",
+    });
+
+    expect(serializedTransaction).toEqual(
+      `{"nonce":1,"value":"0","receiver":"erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th","sender":"erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx","gasPrice":1000000000,"gasLimit":50000000,"chainID":"1","version":2,"options":1}`,
+    );
+  });
+
+  it("should serialize transaction with data field", async () => {
+    const serializedTransaction = await doBuildTransactionToSign({
+      transaction: {
+        family: "multiversx",
+        mode: "send",
+        fees: null,
+        amount: new BigNumber("1"),
+        recipient: "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th",
+        data: Buffer.from("ESDTTransfer@55544b2d326638306539@0de0b6b3a7640000").toString("base64"),
+        gasLimit: 50000000,
+      },
+      sender: "erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx",
+      nonce: 1,
+      value: "0",
+      minGasLimit: 50000000,
+      chainID: "1",
+    });
+
+    expect(serializedTransaction).toEqual(
+      `{"nonce":1,"value":"0","receiver":"erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th","sender":"erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx","gasPrice":1000000000,"gasLimit":50000000,"data":"RVNEVFRyYW5zZmVyQDU1NTQ0YjJkMzI2NjM4MzA2NTM5QDBkZTBiNmIzYTc2NDAwMDA=","chainID":"1","version":2,"options":1}`,
+    );
+  });
+});

package/src/cli-transaction.ts

@@ -0,0 +1,41 @@
+import type { AccountLike } from "@ledgerhq/types-live";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import type { MultiversXAccount, Transaction } from "./types";
+const options = [
+  {
+    name: "mode",
+    type: String,
+    desc: "mode of transaction: send, delegate, unDelegate, claimRewards",
+  },
+];
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  _opts: Record<string, any>,
+): Transaction[] {
+  return flatMap(transactions, ({ transaction, account }) => {
+    invariant(transaction.family === "multiversx", "multiversx family");
+
+    if (account.type === "Account") {
+      invariant((account as MultiversXAccount).multiversxResources, "unactivated account");
+    }
+
+    transaction.family = "multiversx";
+
+    return {
+      ...transaction,
+      mode: _opts.mode || "send",
+    };
+  });
+}
+
+export default function makeCliTools() {
+  return {
+    options,
+    inferTransactions,
+  };
+}

package/src/config.ts

@@ -0,0 +1,26 @@
+import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type MultiversXCoinConfig = () => CurrencyConfig & {
+  config_currency_multiversx: {
+    type: "object";
+    default: {
+      status: {
+        type: "active";
+      };
+    };
+  };
+};
+
+let coinConfig: MultiversXCoinConfig | undefined;
+
+export const setCoinConfig = (config: MultiversXCoinConfig): void => {
+  coinConfig = config;
+};
+
+export const getCoinConfig = (): ReturnType<MultiversXCoinConfig> => {
+  if (!coinConfig?.()) {
+    throw new Error("MultiversX module config not set");
+  }
+
+  return coinConfig();
+};

package/src/constants.ts

@@ -0,0 +1,24 @@
+import BigNumber from "bignumber.js";
+
+export const TRANSACTION_OPTIONS_TX_HASH_SIGN = 0b0001;
+export const TRANSACTION_VERSION_DEFAULT = 2;
+export const METACHAIN_SHARD = 4294967295;
+export const MAX_PAGINATION_SIZE = 50;
+export const GAS = {
+  ESDT_TRANSFER: 500000,
+  DELEGATE: 75000000,
+  CLAIM: 6000000,
+};
+export const GAS_PRICE = 1000000000;
+export const MIN_GAS_LIMIT = 50000;
+export const GAS_PER_DATA_BYTE = 1500;
+export const GAS_PRICE_MODIFIER = 0.01;
+export const CHAIN_ID = "1";
+export const MIN_DELEGATION_AMOUNT: BigNumber = new BigNumber("1000000000000000000");
+export const DECIMALS_LIMIT = 18;
+
+export const MULTIVERSX_EXPLORER_URL = "https://explorer.multiversx.com";
+export const MULTIVERSX_STAKING_POOL =
+  "erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqplllst77y4l";
+export const MULTIVERSX_LEDGER_VALIDATOR_ADDRESS =
+  "erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqppllllls9ftvxy";

package/src/createTransaction.ts

@@ -0,0 +1,21 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { MIN_GAS_LIMIT } from "./constants";
+import { Transaction } from "./types";
+
+/**
+ * Create an empty t
+ *
+ * @returns {Transaction}
+ */
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => {
+  return {
+    family: "multiversx",
+    mode: "send",
+    amount: new BigNumber(0),
+    recipient: "",
+    useAllAmount: false,
+    fees: new BigNumber(50000),
+    gasLimit: MIN_GAS_LIMIT,
+  };
+};

package/src/datasets/multiversx1.ts

@@ -0,0 +1,19 @@
+import { AccountRaw } from "@ledgerhq/types-live";
+
+export const multiversx1: AccountRaw = {
+  id: "js:2:multiversx:erd1rnq7m8kdrpyfany4fweqtydsk4pgx0l6dtl6tvcad5wesagruxts62e9rk:",
+  seedIdentifier: "erd1rnq7m8kdrpyfany4fweqtydsk4pgx0l6dtl6tvcad5wesagruxts62e9rk",
+  name: "MultiversX 1",
+  derivationMode: "",
+  index: 0,
+  freshAddress: "erd1rnq7m8kdrpyfany4fweqtydsk4pgx0l6dtl6tvcad5wesagruxts62e9rk",
+  freshAddressPath: "44'/508'/0'/0'/0'",
+  pendingOperations: [],
+  operations: [],
+  // currencyId: "multiversx",
+  currencyId: "elrond",
+  balance: "",
+  blockHeight: 0,
+  lastSyncDate: "",
+  xpub: "",
+};

package/src/deviceTransactionConfig.ts

@@ -0,0 +1,74 @@
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import type { TransactionStatus, Transaction } from "./types";
+import BigNumber from "bignumber.js";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { decodeTokenAccountId, getAccountCurrency } from "@ledgerhq/coin-framework/account";
+import { Account } from "@ledgerhq/types-live";
+import { isAmountSpentFromBalance } from "./logic";
+
+function getDeviceTransactionConfig({
+  account,
+  transaction,
+  status: { estimatedFees },
+}: {
+  account: Account;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+
+  const { subAccountId } = transaction;
+  const isEsdtTransfer = subAccountId !== undefined && subAccountId !== null;
+
+  if (isEsdtTransfer) {
+    const { token } = decodeTokenAccountId(subAccountId);
+
+    if (token) {
+      fields.push({
+        type: "text",
+        label: "Token",
+        value: token.name,
+      });
+
+      fields.push({
+        type: "amount",
+        label: "Value",
+      });
+    }
+  }
+
+  fields.push({
+    type: "address",
+    label: "Receiver",
+    address: transaction.recipient,
+  });
+
+  if (!isEsdtTransfer) {
+    if (!isAmountSpentFromBalance(transaction.mode)) {
+      fields.push({
+        type: "text",
+        label: "Amount",
+        value: formatCurrencyUnit(getAccountCurrency(account).units[0], new BigNumber(0), {
+          showCode: true,
+          disableRounding: true,
+        }),
+      });
+    } else {
+      fields.push({
+        type: "amount",
+        label: "Amount",
+      });
+    }
+  }
+
+  if (!estimatedFees.isZero()) {
+    fields.push({
+      type: "fees",
+      label: "Fee",
+    });
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/encode.ts

@@ -0,0 +1,46 @@
+import { SubAccount } from "@ledgerhq/types-live";
+import { decodeTokenAccountId } from "@ledgerhq/coin-framework/account";
+import type { Transaction } from "./types";
+import { extractTokenId } from "./logic";
+
+export class MultiversXEncodeTransaction {
+  static ESDTTransfer(t: Transaction, ta: SubAccount): string {
+    const { token } = decodeTokenAccountId(ta.id);
+    const tokenIdentifierHex = token && extractTokenId(token.id);
+    let amountHex = t.useAllAmount ? ta.balance.toString(16) : t.amount.toString(16);
+
+    //hex amount length must be even so protocol would treat it as an ESDT transfer
+    if (amountHex.length % 2 !== 0) {
+      amountHex = "0" + amountHex;
+    }
+
+    return Buffer.from(`ESDTTransfer@${tokenIdentifierHex}@${amountHex}`).toString("base64");
+  }
+
+  static delegate(): string {
+    return Buffer.from(`delegate`).toString("base64");
+  }
+
+  static claimRewards(): string {
+    return Buffer.from(`claimRewards`).toString("base64");
+  }
+
+  static withdraw(): string {
+    return Buffer.from(`withdraw`).toString("base64");
+  }
+
+  static reDelegateRewards(): string {
+    return Buffer.from(`reDelegateRewards`).toString("base64");
+  }
+
+  static unDelegate(t: Transaction): string {
+    let amountHex = t.amount.toString(16);
+
+    //hex amount length must be even
+    if (amountHex.length % 2 !== 0) {
+      amountHex = "0" + amountHex;
+    }
+
+    return Buffer.from(`unDelegate@${amountHex}`).toString("base64");
+  }
+}

package/src/errors.ts

@@ -0,0 +1,19 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const MultiversXDecimalsLimitReached = createCustomErrorClass(
+  "MultiversXDecimalsLimitReached",
+);
+
+export const MultiversXMinDelegatedAmountError = createCustomErrorClass(
+  "MultiversXMinDelegatedAmountError",
+);
+
+export const MultiversXMinUndelegatedAmountError = createCustomErrorClass(
+  "MultiversXMinUndelegatedAmountError",
+);
+
+export const MultiversXDelegationBelowMinimumError = createCustomErrorClass(
+  "MultiversXDelegationBelowMinimumError",
+);
+
+export const NotEnoughEGLDForFees = createCustomErrorClass("NotEnoughEGLDForFees");

package/src/estimateMaxSpendable.ts

@@ -0,0 +1,43 @@
+import { BigNumber } from "bignumber.js";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { findSubAccountById, getMainAccount } from "@ledgerhq/coin-framework/account";
+import type { Transaction } from "./types";
+import { getFees } from "./api";
+import { createTransaction } from "./createTransaction";
+
+/**
+ * Returns the maximum possible amount for transaction
+ *
+ * @param {Object} param - the account, parentAccount and transaction
+ */
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const tx: Transaction = {
+    ...createTransaction(account),
+    subAccountId: account.type === "Account" ? null : account.id,
+    ...transaction,
+    useAllAmount: true,
+  };
+
+  const tokenAccount = tx.subAccountId
+    ? findSubAccountById(mainAccount, tx.subAccountId)
+    : undefined;
+
+  if (tokenAccount) {
+    return tokenAccount.balance;
+  }
+
+  const fees = await getFees(tx);
+
+  if (fees.gt(mainAccount.spendableBalance)) {
+    return new BigNumber(0);
+  }
+
+  return mainAccount.spendableBalance.minus(fees);
+};
+
+export default estimateMaxSpendable;

package/src/formatters.ts

@@ -0,0 +1,76 @@
+import invariant from "invariant";
+import type { Operation } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+import type { MultiversXAccount, MultiversXOperation } from "./types";
+import BigNumber from "bignumber.js";
+
+function formatAccountSpecifics(account: MultiversXAccount): string {
+  const { multiversxResources } = account;
+  invariant(multiversxResources, "multiversx account expected");
+  const unit = getAccountCurrency(account).units[0];
+  const formatConfig = {
+    disableRounding: true,
+    alwaysShowSign: false,
+    showCode: true,
+  };
+  let str = " ";
+
+  if (account.spendableBalance) {
+    str += formatCurrencyUnit(unit, account.spendableBalance, formatConfig) + " spendable. ";
+  } else {
+    str += " 0 spendable.";
+  }
+
+  if (multiversxResources && multiversxResources.nonce) {
+    str += "\n  nonce : " + multiversxResources.nonce;
+  }
+
+  if (multiversxResources && multiversxResources.delegations) {
+    let delegated = new BigNumber(0);
+    let undelegating = new BigNumber(0);
+    let rewards = new BigNumber(0);
+    for (const delegation of multiversxResources.delegations) {
+      delegated = delegated.plus(delegation.userActiveStake);
+      undelegating = delegation.userUndelegatedList.reduce(
+        (sum, undelegation) => sum.plus(undelegation.amount),
+        undelegating,
+      );
+      rewards = rewards.plus(delegation.claimableRewards);
+    }
+
+    str +=
+      delegated && delegated.gt(0)
+        ? `\n  delegated: ${unit ? formatCurrencyUnit(unit, delegated, formatConfig) : delegated}`
+        : undelegating && undelegating.gt(0)
+          ? `\n  undelegating: ${
+              unit ? formatCurrencyUnit(unit, undelegating, formatConfig) : undelegating
+            }`
+          : rewards && rewards.gt(0)
+            ? `\n  rewards: ${unit ? formatCurrencyUnit(unit, rewards, formatConfig) : rewards}`
+            : "";
+  }
+
+  return str;
+}
+
+function formatOperationSpecifics(op: Operation, unit: Unit | null | undefined): string {
+  const { amount } = (op as MultiversXOperation).extra;
+  return amount?.gt && amount.gt(0)
+    ? " amount: " +
+        `${
+          unit
+            ? formatCurrencyUnit(unit, new BigNumber(amount), {
+                showCode: true,
+                disableRounding: true,
+              }).padEnd(16)
+            : amount
+        }`
+    : "";
+}
+
+export default {
+  formatAccountSpecifics,
+  formatOperationSpecifics,
+};

package/src/getTransactionStatus.ts

@@ -0,0 +1,151 @@
+import BigNumber from "bignumber.js";
+import {
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  FeeNotLoaded,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  FeeTooHigh,
+  AmountRequired,
+} from "@ledgerhq/errors";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account";
+import { DECIMALS_LIMIT, MIN_DELEGATION_AMOUNT } from "./constants";
+import type { MultiversXAccount, Transaction, TransactionStatus } from "./types";
+import { isValidAddress, isSelfTransaction, isAmountSpentFromBalance } from "./logic";
+import {
+  MultiversXDecimalsLimitReached,
+  MultiversXMinDelegatedAmountError,
+  MultiversXMinUndelegatedAmountError,
+  MultiversXDelegationBelowMinimumError,
+  NotEnoughEGLDForFees,
+} from "./errors";
+import { AccountBridge } from "@ledgerhq/types-live";
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  MultiversXAccount,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+
+  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,
+    });
+  }
+
+  if (!transaction.fees) {
+    errors.fees = new FeeNotLoaded();
+  }
+
+  if (
+    !errors.amount &&
+    transaction.amount.eq(0) &&
+    !transaction.useAllAmount &&
+    !["unDelegate", "withdraw", "reDelegateRewards", "claimRewards"].includes(transaction.mode)
+  ) {
+    errors.amount = new AmountRequired();
+  }
+
+  let totalSpent = new BigNumber(0); // Will be in token amount for token transactions
+  let totalSpentEgld = new BigNumber(0); // Amount spent in main currency (EGLD)
+
+  const tokenAccount =
+    (transaction.subAccountId &&
+      account.subAccounts &&
+      account.subAccounts.find(ta => ta.id === transaction.subAccountId)) ||
+    null;
+
+  if (tokenAccount) {
+    totalSpent = transaction.amount;
+    totalSpentEgld = transaction.fees || new BigNumber(0);
+
+    if (!errors.amount && transaction.amount.gt(tokenAccount.balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+
+    if (!errors.amount && !totalSpentEgld.decimalPlaces(DECIMALS_LIMIT).isEqualTo(totalSpentEgld)) {
+      errors.amount = new MultiversXDecimalsLimitReached();
+    }
+  } else {
+    totalSpent = totalSpentEgld = isAmountSpentFromBalance(transaction.mode)
+      ? transaction.fees?.plus(transaction.amount) || transaction.amount
+      : transaction.fees || new BigNumber(0);
+
+    if (
+      transaction.mode === "send" &&
+      transaction.fees &&
+      transaction.amount.div(10).lt(transaction.fees)
+    ) {
+      warnings.feeTooHigh = new FeeTooHigh();
+    }
+
+    // All delegate and undelegate transactions must have an amount >= 1 EGLD
+    if (!errors.amount && transaction.amount.lt(MIN_DELEGATION_AMOUNT)) {
+      const formattedAmount = formatCurrencyUnit(
+        getAccountCurrency(account).units[0],
+        MIN_DELEGATION_AMOUNT,
+        {
+          showCode: true,
+        },
+      );
+      if (transaction.mode === "delegate") {
+        errors.amount = new MultiversXMinDelegatedAmountError("", {
+          formattedAmount,
+        });
+      } else if (transaction.mode === "unDelegate") {
+        errors.amount = new MultiversXMinUndelegatedAmountError("", {
+          formattedAmount,
+        });
+      }
+    }
+
+    // When undelegating, unless undelegating all, the delegation must remain >= 1 EGLD
+    const delegationBalance = account.multiversxResources.delegations.find(
+      d => d.contract === transaction.recipient,
+    )?.userActiveStake;
+
+    const delegationRemainingBalance = new BigNumber(delegationBalance || 0).minus(
+      transaction.amount,
+    );
+
+    const delegationBalanceForbidden =
+      delegationRemainingBalance.gt(0) && delegationRemainingBalance.lt(MIN_DELEGATION_AMOUNT);
+
+    if (!errors.amount && transaction.mode === "unDelegate" && delegationBalanceForbidden) {
+      const formattedAmount = formatCurrencyUnit(
+        getAccountCurrency(account).units[0],
+        MIN_DELEGATION_AMOUNT,
+        {
+          showCode: true,
+        },
+      );
+      errors.amount = new MultiversXDelegationBelowMinimumError("", {
+        formattedAmount,
+      });
+    }
+  }
+
+  if (!errors.amount && totalSpentEgld.gt(account.spendableBalance)) {
+    errors.amount =
+      tokenAccount || !["delegate", "send"].includes(transaction.mode)
+        ? new NotEnoughEGLDForFees()
+        : new NotEnoughBalance();
+  }
+
+  return {
+    errors,
+    warnings,
+    estimatedFees: transaction.fees || new BigNumber(0),
+    amount: transaction.amount,
+    totalSpent,
+  };
+};
+
+export default getTransactionStatus;

package/src/helpers/denominate.ts

@@ -0,0 +1,95 @@
+/*
+ * Declare the type of the denomination function's parameters.
+ */
+
+export interface DenominateType {
+  input: string;
+  denomination?: number;
+  decimals?: number;
+  showLastNonZeroDecimal?: boolean;
+  addCommas?: boolean;
+}
+
+/*
+ * Declare function itself and return the denominated value as a string.
+ */
+
+export const denominate = (parameters: DenominateType) => {
+  const { denomination, decimals, showLastNonZeroDecimal = false, addCommas = true } = parameters;
+  let { input } = parameters;
+
+  if (input === "...") {
+    return input;
+  }
+  if (input === "" || input === "0" || input === undefined) {
+    input = "0";
+  }
+
+  const format = (
+    big: string,
+    denomination = 18,
+    decimals = 2,
+    showLastNonZeroDecimal: boolean,
+    addCommas: boolean,
+  ) => {
+    const showLastNonZeroDecimalCheck =
+      typeof showLastNonZeroDecimal !== "undefined" ? showLastNonZeroDecimal : false;
+
+    let array = big.toString().split("");
+    if (denomination !== 0) {
+      // make sure we have enough characters
+      while (array.length < denomination + 1) {
+        array.unshift("0");
+      }
+      // add our dot
+      array.splice(array.length - denomination, 0, ".");
+      // make sure there are enough decimals after the dot
+      while (array.length - array.indexOf(".") <= decimals) {
+        array.push("0");
+      }
+
+      if (showLastNonZeroDecimalCheck) {
+        let nonZeroDigitIndex = 0;
+        for (let i = array.length - 1; i > 0; i--) {
+          if (array[i] !== "0") {
+            nonZeroDigitIndex = i + 1;
+            break;
+          }
+        }
+        const decimalsIndex = array.indexOf(".") + decimals + 1;
+        const sliceIndex = Math.max(decimalsIndex, nonZeroDigitIndex);
+        array = array.slice(0, sliceIndex);
+      } else {
+        // trim unnecessary characters after the dot
+        array = array.slice(0, array.indexOf(".") + decimals + 1);
+      }
+    }
+    if (addCommas) {
+      // add comas every 3 characters
+      array = array.reverse();
+      const reference = denomination ? array.length - array.indexOf(".") - 1 : array.length;
+      const count = Math.floor(reference / 3);
+      for (let i = 1; i <= count; i++) {
+        const position = array.indexOf(".") + 3 * i + i;
+        if (position !== array.length) {
+          array.splice(position, 0, ",");
+        }
+      }
+      array = array.reverse();
+    }
+
+    const allDecimalsZero = array
+      .slice(array.indexOf(".") + 1)
+      .every(digit => digit.toString() === "0");
+
+    const string = array.join("");
+
+    if (allDecimalsZero) {
+      return string.split(".")[0];
+    }
+
+    return decimals === 0 ? string.split(".").join("") : string;
+  };
+
+  return format(input, denomination, decimals, showLastNonZeroDecimal, addCommas);
+};