Nimiq Utils JS ​

import { getExchangeRates, getHistoricExchangeRatesByRange } from '@nimiq/utils/fiat-api'

const rates = await getExchangeRates(['btc'], ['usd'], Provider.CryptoCompare)
console.log(rates)
// Output: { btc: { usd: 23000.5 } }

const historicalRates = await getHistoricExchangeRatesByRange(
  'btc',
  'usd',
  Date.now() - 7 * 24 * 60 * 60 * 1000,
  Date.now()
)
console.log(historicalRates)

import { FormattableNumber, toNonScientificNumberString } from '@nimiq/utils/formattable-number'

// Example: Format a number to a string
const number = new FormattableNumber('12345.6789')
const formatted = number.toString({
  maxDecimals: 2,
  useGrouping: true,
  groupSeparator: ','
})
console.log(formatted) // Output: '12,345.68'

// Example: Convert a number to a non-scientific string
const nonScientific = toNonScientificNumberString('1.23e4')
console.log(nonScientific) // Output: '12300'

// Example: Round a number
const roundedNumber = new FormattableNumber(123.45678)
roundedNumber.round(2)
console.log(roundedNumber.toString()) // Output: '123.46'

// Example: Check equality
const num1 = new FormattableNumber('123.45')
const num2 = new FormattableNumber(123.45)
console.log(num1.equals(num2)) // Output: true

import { Priority, RateLimitScheduler } from '@nimiq/utils/rate-limit-scheduler'

// Define rate limits
const rateLimits = {
  second: 5, // Max 5 tasks per second
  minute: 100, // Max 100 tasks per minute
  parallel: 2, // Max 2 tasks running in parallel
}

// Initialize the RateLimitScheduler
const scheduler = new RateLimitScheduler(rateLimits)

// Schedule tasks
async function task() {
  console.log(`Task started at ${new Date().toISOString()}`)
  await new Promise(resolve => setTimeout(resolve, 200)) // Simulate async work
}

(async () => {
  // Schedule tasks with normal priority
  for (let i = 0; i < 10; i++) {
    scheduler.schedule(task)
  }

  // Schedule a high-priority task
  scheduler.schedule(
    async () => {
      console.log('High-priority task executed!')
    },
    Priority.HIGH,
  )
})()

import {
  createEthereumRequestLink,
  Currency,
  EthereumChain,
  parseEthereumRequestLink,
} from '@nimiq/utils/request-links-encoding'

// Example: Create an Ethereum request link
const ethereumLink = createEthereumRequestLink(
  '0x1234567890abcdef1234567890abcdef12345678',
  Currency.ETH,
  {
    amount: BigInt(1e18), // 1 ETH in Wei
    chainId: EthereumChain.ETHEREUM_MAINNET,
  },
)
console.log(ethereumLink) // Output: "ethereum:0x1234567890abcdef1234567890abcdef12345678?value=1e18"

// Example: Parse an Ethereum request link
const parsedEthereumLink = parseEthereumRequestLink(ethereumLink)
console.log(parsedEthereumLink)
/* Output:
{
    currency: 'eth',
    recipient: '0x1234567890abcdef1234567890abcdef12345678',
    amount: 1000000000000000000n, // 1 ETH in Wei
    chainId: 1, // Ethereum Mainnet
}
*/

import { calculateStakingRewards } from '@nimiq/utils/rewards-calculator'

// Example: Calculate staking rewards for a specific scenario
const stakingParams = {
  stakedSupplyRatio: 0.5, // 50% of the total supply is staked
  amount: 100000, // Staking 100,000 NIM
  days: 365, // Staking duration: 1 year
  autoRestake: true, // Enable compounding
  network: 'main-albatross', // Mainnet
  fee: 0.02, // Pool fee: 2%
}

const result = calculateStakingRewards(stakingParams)

console.log(result)
// Output:
// {
//   totalAmount: 105123.45, // Total after staking
//   gain: 5123.45,          // Gain from staking
//   gainRatio: 0.05123      // Gain as a percentage
// }

import { posSupplyAt } from '@nimiq/utils/supply-calculator'

// Example: Calculate PoS supply at a specific timestamp
const timestampMs = Date.now() // Current timestamp
const supply = posSupplyAt(timestampMs)

console.log(supply)
// Output: 105432.5678 (example value based on current timestamp and network)

import Tweenable from '@nimiq/utils/tweenable'

// Example: Create a Tweenable instance
const tween = new Tweenable(100, 0, 2000) // Target value: 100, Start value: 0, Tween time: 2000ms

// Example: Retrieve the current value during animation
setInterval(() => {
  console.log(`Current Value: ${tween.currentValue}`)
  if (tween.finished)
    console.log('Animation complete!')
}, 100)

// Example: Update the target value and restart the tween
tween.tweenTo(200, 1500) // Tween to 200 over 1500ms

// Example: Use a custom easing function
const customEasing = (t: number) => t * t // Quadratic easing
const tweenWithCustomEasing = new Tweenable(50, 0, 3000, Date.now(), customEasing)

// Example: Access built-in easing functions
const easeInOutValue = Tweenable.Easing.EASE_IN_OUT_CUBIC(0.5) // Calculate easing at progress = 0.5
console.log(`Eased Value (0.5 progress): ${easeInOutValue}`)

import { ValidationUtils } from '@nimiq/utils/validation-utils'

// Example: Validate if an address is valid
const address = 'NQ48 8CKH BA24 2VR3 N249 N8MN J5XX 74DB 5XJ8'
const isValid = ValidationUtils.isValidAddress(address)
console.log(isValid) // Output: true or false

// Example: Normalize an address
const normalizedAddress = ValidationUtils.normalizeAddress(address)
console.log(normalizedAddress) // Output: 'NQ48 8CKH BA24 2VR3 N249 N8MN J5XX 74DB 5XJ8'

// Example: Check if an address is user-friendly
try {
  ValidationUtils.isUserFriendlyAddress(address)
  console.log('The address is user-friendly.')
}
catch (e) {
  console.error(e.message) // Output: error message if the address is invalid
}

// Example: Validate a hash
const hash = 'aGVsbG93b3JsZG5pbWlx'
const isHashValid = ValidationUtils.isValidHash(hash)
console.log(isHashValid) // Output: true or false

// Example: Retrieve the Nimiq Base32 alphabet
const alphabet = ValidationUtils.NIMIQ_ALPHABET
console.log(alphabet) // Output: '0123456789ABCDEFGHJKLMNPQRSTUVXY'