@evmexplorer/utility/dist/index.js

EVM Explorer utility sdk

// src/hashes.ts
function parseHash(address) {
  if (address) {
    const begin = address.substring(0, 7);
    const end = address.substring(address.length - 3, address.length);
    const formatted = `${begin}...${end}`;
    return formatted;
  }
  return "0x00000...000";
}

// src/networks.ts
var networkNameTitles = {
  1: "Ethereum",
  10: "Optimism",
  137: "Polygon MATIC",
  690: "Redstone",
  8453: "Base",
  34443: "Mode Network",
  42161: "Arbitrum One Nitro",
  7777777: "Zora"
};
var networkNames = {
  1: "mainnet",
  10: "optimism",
  137: "polygon",
  314: "filecoin",
  690: "redstone",
  8453: "base",
  34443: "mode",
  42161: "arbitrum",
  7777777: "zora"
};
var networkNameUniswap = {
  1: "ethereum",
  10: "optimism",
  137: "polygon",
  42161: "arbitrum"
};
var networkIds = {
  mainnet: 1,
  optimism: 10,
  polygon: 137,
  filecoin: 314,
  redstone: 690,
  base: 8453,
  mode: 34443,
  arbitrum: 42161,
  zora: 7777777
};
function getNetworkNameTitle(chainId) {
  return networkNameTitles[chainId];
}
function getNetworkName(chainId) {
  return networkNames[chainId];
}
function getNetworkNameUniswap(chainId) {
  return networkNameUniswap[chainId];
}
function getNetworkId(chainId) {
  return networkIds[chainId];
}
function getNativeCurrency(chainId) {
  if (chainId === 137) return "MATIC";
  if (chainId === 314) return "FIL";
  return "ETH";
}

// src/parseNames.ts
function camelToFlat(c) {
  const result = c.replace(/(_)+/g, " ").replace(/([a-z])([A-Z][a-z])/g, "$1 $2").replace(/([A-Z][a-z])([A-Z])/g, "$1 $2").replace(/([a-z])([A-Z]+[a-z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z][a-z])/g, "$1 $2").replace(/([a-z]+)([A-Z0-9]+)/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-rt-z][a-z]*)/g, "$1 $2").replace(/([0-9])([A-Z][a-z]+)/g, "$1 $2").replace(/([A-Z]{2,})([0-9]{2,})/g, "$1 $2").replace(/([0-9]{2,})([A-Z]{2,})/g, "$1 $2").trim();
  return result;
}
function parseCamelCase(name) {
  if (name) return camelToFlat(name);
}
function parseStringToWords(types) {
  const result = types.replaceAll(",", ", ");
  return result;
}

// src/parseNumbers.ts
import { formatEther, formatUnits } from "viem";
function parseNumber(variable) {
  if (variable) return Number(variable).toLocaleString("en-GB");
  return "0";
}
function parseNumberFixed(variable) {
  const fixedNumber = Number(variable).toFixed(2);
  return parseNumber(fixedNumber);
}
function deserializeWeiToGwei(serializedWei) {
  const gweiNumber = Number(formatEther(BigInt(serializedWei), "gwei"));
  return gweiNumber;
}
function parseWei(serializedWei) {
  const gweiNumber = deserializeWeiToGwei(serializedWei);
  const parsedGweiNumber = gweiNumber.toFixed(2);
  return parsedGweiNumber;
}
function deserializeWeiToEther(serializedWei) {
  if (!serializedWei) return 0;
  const etherNumber = Number(formatEther(BigInt(serializedWei)));
  return etherNumber;
}
function parseWithER(serializedWei, exchangeRate) {
  const etherNumber = deserializeWeiToEther(serializedWei);
  const formattedString = parseNumberFixed(etherNumber * Number(exchangeRate));
  return formattedString;
}
function parseToken(tokenValue, tokenDecimals) {
  if (tokenValue && tokenDecimals) {
    const tokenDecimalsformattedTokenValue = formatUnits(
      BigInt(tokenValue),
      Number(tokenDecimals)
    );
    const formattedTokenValue = parseNumberFixed(
      tokenDecimalsformattedTokenValue
    );
    return formattedTokenValue;
  }
  if (tokenValue) {
    return tokenValue;
  }
  return "NaN";
}
function parseTokenWithER(tokenValue, tokenDecimals, exchangeRate) {
  const formattedTokenValue = formatUnits(
    BigInt(tokenValue),
    Number(tokenDecimals)
  );
  const formattedString = parseNumberFixed(
    Number(formattedTokenValue) * Number(exchangeRate)
  );
  return formattedString;
}
function parseTokenPrice(token) {
  const numberTokenPrice = Number(token);
  if (numberTokenPrice >= 1e3) return parseNumberFixed(numberTokenPrice);
  if (numberTokenPrice >= 0.98 && numberTokenPrice <= 1.02)
    return numberTokenPrice.toLocaleString("en-GB", {
      maximumSignificantDigits: 6
    });
  if (numberTokenPrice >= 1e-4)
    return numberTokenPrice.toLocaleString("en-GB", {
      maximumSignificantDigits: 4
    });
  return numberTokenPrice.toLocaleString("en-GB", {
    maximumSignificantDigits: 5
  });
}

// src/time.ts
var delay = (ms) => new Promise((res) => setTimeout(res, ms));
function parseTimestampToMinutesAgo(timestamp) {
  const currentDate = /* @__PURE__ */ new Date();
  const currentTimestamp = Math.floor(currentDate.getTime() / 1e3);
  const seconds = currentTimestamp - timestamp;
  if (seconds > 360 * 24 * 3600) {
    return "more than a year ago";
  }
  if (seconds > 60 * 24 * 3600) {
    return Math.floor(seconds / (60 * 12 * 3600)) + " months ago";
  }
  if (seconds > 30 * 24 * 3600) {
    return "a month ago";
  }
  if (seconds > 14 * 24 * 3600) {
    return Math.floor(seconds / (24 * 3600) / 7) + " weeks ago";
  }
  if (seconds > 7 * 24 * 3600) {
    return "a week ago";
  }
  if (seconds > 2 * 24 * 3600) {
    return Math.floor(seconds / (60 * 3600)) + " days ago";
  }
  if (seconds > 24 * 3600) {
    return "yesterday";
  }
  if (seconds > 3600) {
    return Math.floor(seconds / 3600) + " hours ago";
  }
  if (seconds > 60) {
    return Math.floor(seconds / 60) + " minutes ago";
  }
  if (seconds < 60) {
    return "a few seconds ago";
  }
  throw new Error("date not converted");
}
export {
  camelToFlat,
  delay,
  deserializeWeiToEther,
  deserializeWeiToGwei,
  getNativeCurrency,
  getNetworkId,
  getNetworkName,
  getNetworkNameTitle,
  getNetworkNameUniswap,
  parseCamelCase,
  parseHash,
  parseNumber,
  parseNumberFixed,
  parseStringToWords,
  parseTimestampToMinutesAgo,
  parseToken,
  parseTokenPrice,
  parseTokenWithER,
  parseWei,
  parseWithER
};