@chainflip/utils 0.4.0 → 0.4.2

package/dist/date.d.cts

@@ -0,0 +1,17 @@
+import { UTCDate } from '@date-fns/utc';
+import { Interval } from 'date-fns';
+
+declare const toISODateString: (date: Date) => string;
+declare const fromUnixTime: (time: string | number) => Date;
+declare const formatTimestamp: (timestamp: string, locale?: string | undefined, timeZone?: undefined | "UTC") => string;
+declare const formatTimestampShort: (timestamp: string, locale?: string | undefined, timeZone?: undefined | "UTC") => string;
+declare const differenceInTimeAgo: (time: string, ago?: boolean, endTime?: string) => string;
+declare const intervalToDurationWords: (interval: Interval) => string;
+declare const toStartOfUtcDayString: (date: Date) => string;
+declare const toEndOfUtcDayString: (date: Date) => string;
+declare const eachUtcDayOfInterval: (interval: {
+    start: Date;
+    end: Date;
+}) => UTCDate[];
+
+export { differenceInTimeAgo, eachUtcDayOfInterval, formatTimestamp, formatTimestampShort, fromUnixTime, intervalToDurationWords, toEndOfUtcDayString, toISODateString, toStartOfUtcDayString };

package/dist/date.d.ts

@@ -0,0 +1,17 @@
+import { UTCDate } from '@date-fns/utc';
+import { Interval } from 'date-fns';
+
+declare const toISODateString: (date: Date) => string;
+declare const fromUnixTime: (time: string | number) => Date;
+declare const formatTimestamp: (timestamp: string, locale?: string | undefined, timeZone?: undefined | "UTC") => string;
+declare const formatTimestampShort: (timestamp: string, locale?: string | undefined, timeZone?: undefined | "UTC") => string;
+declare const differenceInTimeAgo: (time: string, ago?: boolean, endTime?: string) => string;
+declare const intervalToDurationWords: (interval: Interval) => string;
+declare const toStartOfUtcDayString: (date: Date) => string;
+declare const toEndOfUtcDayString: (date: Date) => string;
+declare const eachUtcDayOfInterval: (interval: {
+    start: Date;
+    end: Date;
+}) => UTCDate[];
+
+export { differenceInTimeAgo, eachUtcDayOfInterval, formatTimestamp, formatTimestampShort, fromUnixTime, intervalToDurationWords, toEndOfUtcDayString, toISODateString, toStartOfUtcDayString };

package/dist/date.js

@@ -0,0 +1,89 @@
+import {
+  isNullish
+} from "./chunk-HBIFE4XN.js";
+
+// src/date.ts
+import { utc } from "@date-fns/utc";
+import {
+  differenceInDays,
+  differenceInHours,
+  differenceInMinutes,
+  differenceInSeconds,
+  intervalToDuration,
+  eachDayOfInterval,
+  endOfDay,
+  startOfDay
+} from "date-fns";
+var pluralize = (word, numb) => numb !== 1 ? `${word}s` : word;
+var pad = (number) => String(number).padStart(2, "0");
+var toISODateString = (date) => date.toISOString().slice(0, 10);
+var fromUnixTime = (time) => {
+  const date = new Date(Number(time) * 1e3);
+  if (Number.isNaN(date.valueOf())) {
+    throw new Error("date is invalid");
+  }
+  return date;
+};
+var formatTimestamp = (timestamp, locale = void 0, timeZone = void 0) => new Date(timestamp).toLocaleString(locale, {
+  timeZone,
+  weekday: "short",
+  month: "short",
+  day: "numeric",
+  year: "numeric",
+  timeZoneName: "short",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric"
+});
+var formatTimestampShort = (timestamp, locale = void 0, timeZone = void 0) => new Date(timestamp).toLocaleString(locale, {
+  timeZone,
+  month: "numeric",
+  day: "numeric",
+  year: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric"
+});
+var differenceInTimeAgo = (time, ago = true, endTime = (/* @__PURE__ */ new Date()).toISOString()) => {
+  const end = new Date(endTime);
+  const timeNumber = Date.parse(time);
+  const seconds = differenceInSeconds(end, timeNumber);
+  if (seconds < 60) return `${seconds} sec${ago ? " ago" : ""}`;
+  const minutes = differenceInMinutes(end, timeNumber);
+  if (minutes < 60) return `${minutes} min${ago ? " ago" : ""}`;
+  const hours = differenceInHours(end, timeNumber);
+  if (hours < 48) return `${hours} ${pluralize("hour", hours)}${ago ? " ago" : ""}`;
+  const days = differenceInDays(end, timeNumber);
+  return `${days} days${ago ? " ago" : ""}`;
+};
+var intervalToDurationWords = (interval) => {
+  if (isNullish(interval.start) || isNullish(interval.end)) return "??";
+  if (interval.end === 0) return "??";
+  const duration = intervalToDuration(interval);
+  if (duration.months) return ">1 month";
+  if (duration.days) {
+    return `${pad(duration.days)}${duration.days === 1 ? "day" : "days"} ${pad(
+      duration.hours ?? 0
+    )}h ${pad(duration.minutes ?? 0)}min ${pad(duration.seconds ?? 0)}s`;
+  }
+  if (duration.hours) {
+    return `${pad(duration.hours)}h ${pad(duration.minutes)}min ${pad(duration.seconds)}s`;
+  }
+  if (duration.minutes) return `${pad(duration.minutes)}min ${pad(duration.seconds)}s`;
+  if (duration.seconds) return `${pad(duration.seconds)}s`;
+  return "A few seconds";
+};
+var toStartOfUtcDayString = (date) => startOfDay(date, { in: utc }).toISOString();
+var toEndOfUtcDayString = (date) => endOfDay(date, { in: utc }).toISOString();
+var eachUtcDayOfInterval = (interval) => eachDayOfInterval(interval, { in: utc });
+export {
+  differenceInTimeAgo,
+  eachUtcDayOfInterval,
+  formatTimestamp,
+  formatTimestampShort,
+  fromUnixTime,
+  intervalToDurationWords,
+  toEndOfUtcDayString,
+  toISODateString,
+  toStartOfUtcDayString
+};

package/dist/guard.cjs

@@ -22,12 +22,15 @@ var guard_exports = {};
 __export(guard_exports, {
   isBigInt: () => isBigInt,
   isBoolean: () => isBoolean,
+  isFullfilled: () => isFullfilled,
   isNotNullish: () => isNotNullish,
   isNullish: () => isNullish,
   isNumber: () => isNumber,
   isObject: () => isObject,
+  isRejected: () => isRejected,
   isString: () => isString,
   isSymbol: () => isSymbol,
+  isTruthy: () => isTruthy,
   isUndefined: () => isUndefined
 });
 module.exports = __toCommonJS(guard_exports);
@@ -41,15 +44,21 @@ var isObject = createIsGuard("object");
 var isUndefined = createIsGuard("undefined");
 var isNotNullish = (value) => value != null;
 var isNullish = (value) => value == null;
+var isTruthy = (value) => Boolean(value);
+var isFullfilled = (value) => value.status === "fulfilled";
+var isRejected = (value) => value.status === "rejected";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   isBigInt,
   isBoolean,
+  isFullfilled,
   isNotNullish,
   isNullish,
   isNumber,
   isObject,
+  isRejected,
   isString,
   isSymbol,
+  isTruthy,
   isUndefined
 });

package/dist/guard.d.cts

@@ -7,14 +7,17 @@ type TypeMap = {
     object: object;
     undefined: undefined;
 };
-declare const isString: (value: unknown) => value is string;
-declare const isNumber: (value: unknown) => value is number;
-declare const isBigInt: (value: unknown) => value is bigint;
-declare const isBoolean: (value: unknown) => value is boolean;
-declare const isSymbol: (value: unknown) => value is symbol;
-declare const isObject: (value: unknown) => value is object;
-declare const isUndefined: (value: unknown) => value is undefined;
+declare const isString: (value: unknown) => value is TypeMap["string"];
+declare const isNumber: (value: unknown) => value is TypeMap["number"];
+declare const isBigInt: (value: unknown) => value is TypeMap["bigint"];
+declare const isBoolean: (value: unknown) => value is TypeMap["boolean"];
+declare const isSymbol: (value: unknown) => value is TypeMap["symbol"];
+declare const isObject: (value: unknown) => value is TypeMap["object"];
+declare const isUndefined: (value: unknown) => value is TypeMap["undefined"];
 declare const isNotNullish: <T>(value: T) => value is NonNullable<T>;
 declare const isNullish: (value: unknown) => value is null | undefined;
+declare const isTruthy: <T>(value: T | null | undefined) => value is T;
+declare const isFullfilled: <T>(value: PromiseSettledResult<T>) => value is PromiseFulfilledResult<T>;
+declare const isRejected: <T>(value: PromiseSettledResult<T>) => value is PromiseRejectedResult;
 
-export { type TypeMap, isBigInt, isBoolean, isNotNullish, isNullish, isNumber, isObject, isString, isSymbol, isUndefined };
+export { type TypeMap, isBigInt, isBoolean, isFullfilled, isNotNullish, isNullish, isNumber, isObject, isRejected, isString, isSymbol, isTruthy, isUndefined };

package/dist/guard.d.ts

@@ -7,14 +7,17 @@ type TypeMap = {
     object: object;
     undefined: undefined;
 };
-declare const isString: (value: unknown) => value is string;
-declare const isNumber: (value: unknown) => value is number;
-declare const isBigInt: (value: unknown) => value is bigint;
-declare const isBoolean: (value: unknown) => value is boolean;
-declare const isSymbol: (value: unknown) => value is symbol;
-declare const isObject: (value: unknown) => value is object;
-declare const isUndefined: (value: unknown) => value is undefined;
+declare const isString: (value: unknown) => value is TypeMap["string"];
+declare const isNumber: (value: unknown) => value is TypeMap["number"];
+declare const isBigInt: (value: unknown) => value is TypeMap["bigint"];
+declare const isBoolean: (value: unknown) => value is TypeMap["boolean"];
+declare const isSymbol: (value: unknown) => value is TypeMap["symbol"];
+declare const isObject: (value: unknown) => value is TypeMap["object"];
+declare const isUndefined: (value: unknown) => value is TypeMap["undefined"];
 declare const isNotNullish: <T>(value: T) => value is NonNullable<T>;
 declare const isNullish: (value: unknown) => value is null | undefined;
+declare const isTruthy: <T>(value: T | null | undefined) => value is T;
+declare const isFullfilled: <T>(value: PromiseSettledResult<T>) => value is PromiseFulfilledResult<T>;
+declare const isRejected: <T>(value: PromiseSettledResult<T>) => value is PromiseRejectedResult;
 
-export { type TypeMap, isBigInt, isBoolean, isNotNullish, isNullish, isNumber, isObject, isString, isSymbol, isUndefined };
+export { type TypeMap, isBigInt, isBoolean, isFullfilled, isNotNullish, isNullish, isNumber, isObject, isRejected, isString, isSymbol, isTruthy, isUndefined };

package/dist/guard.js

@@ -1,22 +1,28 @@
 import {
   isBigInt,
   isBoolean,
+  isFullfilled,
   isNotNullish,
   isNullish,
   isNumber,
   isObject,
+  isRejected,
   isString,
   isSymbol,
+  isTruthy,
   isUndefined
-} from "./chunk-CZNX6EUV.js";
+} from "./chunk-HBIFE4XN.js";
 export {
   isBigInt,
   isBoolean,
+  isFullfilled,
   isNotNullish,
   isNullish,
   isNumber,
   isObject,
+  isRejected,
   isString,
   isSymbol,
+  isTruthy,
   isUndefined
 };

package/dist/number.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,16 +17,55 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/number.ts
 var number_exports = {};
 __export(number_exports, {
+  formatUsdValue: () => formatUsdValue,
   hexEncodeNumber: () => hexEncodeNumber
 });
 module.exports = __toCommonJS(number_exports);
+var import_assert = __toESM(require("assert"), 1);
+var import_bignumber = __toESM(require("bignumber.js"), 1);
 var hexEncodeNumber = (num) => `0x${num.toString(16)}`;
+function formatUsdValue(value, precise = true) {
+  if (value == null) return value;
+  let usdAmount = new import_bignumber.default(value);
+  (0, import_assert.default)(usdAmount.gte(0), "negative amounts not supported");
+  if (!usdAmount.eq(0) && usdAmount.lt(0.01)) return `<$0.01`;
+  let suffix = "";
+  let decimals = 2;
+  if (!precise) {
+    if (usdAmount.gte(1e12)) {
+      usdAmount = usdAmount.shiftedBy(-12);
+      suffix = "T";
+    } else if (usdAmount.gte(1e9)) {
+      usdAmount = usdAmount.shiftedBy(-9);
+      suffix = "B";
+    } else if (usdAmount.gte(1e6)) {
+      usdAmount = usdAmount.shiftedBy(-6);
+      suffix = "M";
+    }
+    if (suffix === "" && usdAmount.gte(1e4)) {
+      decimals = 0;
+    } else if (suffix !== "") {
+      decimals = void 0;
+    }
+  }
+  usdAmount = usdAmount.decimalPlaces(2);
+  return `$${usdAmount.toFormat(decimals)}${suffix}`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  formatUsdValue,
   hexEncodeNumber
 });

package/dist/number.d.cts

@@ -1,5 +1,10 @@
+import BigNumber from 'bignumber.js';
 import { HexString } from './types.cjs';
 
 declare const hexEncodeNumber: (num: number | bigint) => HexString;
+declare function formatUsdValue(value: BigNumber.Value, precise?: boolean): string;
+declare function formatUsdValue(value: null, precise?: boolean): null;
+declare function formatUsdValue(value: undefined, precise?: boolean): undefined;
+declare function formatUsdValue(value: BigNumber.Value | null | undefined, precise?: boolean): string | null | undefined;
 
-export { hexEncodeNumber };
+export { formatUsdValue, hexEncodeNumber };

package/dist/number.d.ts

@@ -1,5 +1,10 @@
+import BigNumber from 'bignumber.js';
 import { HexString } from './types.js';
 
 declare const hexEncodeNumber: (num: number | bigint) => HexString;
+declare function formatUsdValue(value: BigNumber.Value, precise?: boolean): string;
+declare function formatUsdValue(value: null, precise?: boolean): null;
+declare function formatUsdValue(value: undefined, precise?: boolean): undefined;
+declare function formatUsdValue(value: BigNumber.Value | null | undefined, precise?: boolean): string | null | undefined;
 
-export { hexEncodeNumber };
+export { formatUsdValue, hexEncodeNumber };

package/dist/number.js

@@ -1,5 +1,35 @@
 // src/number.ts
+import assert from "assert";
+import BigNumber from "bignumber.js";
 var hexEncodeNumber = (num) => `0x${num.toString(16)}`;
+function formatUsdValue(value, precise = true) {
+  if (value == null) return value;
+  let usdAmount = new BigNumber(value);
+  assert(usdAmount.gte(0), "negative amounts not supported");
+  if (!usdAmount.eq(0) && usdAmount.lt(0.01)) return `<$0.01`;
+  let suffix = "";
+  let decimals = 2;
+  if (!precise) {
+    if (usdAmount.gte(1e12)) {
+      usdAmount = usdAmount.shiftedBy(-12);
+      suffix = "T";
+    } else if (usdAmount.gte(1e9)) {
+      usdAmount = usdAmount.shiftedBy(-9);
+      suffix = "B";
+    } else if (usdAmount.gte(1e6)) {
+      usdAmount = usdAmount.shiftedBy(-6);
+      suffix = "M";
+    }
+    if (suffix === "" && usdAmount.gte(1e4)) {
+      decimals = 0;
+    } else if (suffix !== "") {
+      decimals = void 0;
+    }
+  }
+  usdAmount = usdAmount.decimalPlaces(2);
+  return `$${usdAmount.toFormat(decimals)}${suffix}`;
+}
 export {
+  formatUsdValue,
   hexEncodeNumber
 };

package/dist/ss58.cjs

@@ -26,24 +26,7 @@ __export(ss58_exports, {
 });
 module.exports = __toCommonJS(ss58_exports);
 
-// src/guard.ts
-var createIsGuard = (type) => (value) => typeof value === type;
-var isString = createIsGuard("string");
-var isNumber = createIsGuard("number");
-var isBigInt = createIsGuard("bigint");
-var isBoolean = createIsGuard("boolean");
-var isSymbol = createIsGuard("symbol");
-var isObject = createIsGuard("object");
-var isUndefined = createIsGuard("undefined");
-
-// src/assertion.ts
-function assert(condition, message = "assertion failed", Constructor = Error) {
-  if (!condition) {
-    throw new Constructor(message);
-  }
-}
-
-// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_assert.js
+// ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
 function number(n) {
   if (!Number.isSafeInteger(n) || n < 0)
     throw new Error(`positive integer expected, not ${n}`);
@@ -71,7 +54,7 @@ function output(out, instance) {
   }
 }
 
-// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/utils.js
+// ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
 var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
 var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
@@ -108,7 +91,7 @@ function wrapConstructorWithOpts(hashCons) {
   return hashC;
 }
 
-// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_blake.js
+// ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_blake.js
 var SIGMA = /* @__PURE__ */ new Uint8Array([
   0,
   1,
@@ -397,7 +380,7 @@ var BLAKE = class extends Hash {
   }
 };
 
-// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_u64.js
+// ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
 var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 var _32n = /* @__PURE__ */ BigInt(32);
 function fromBig(n, le = false) {
@@ -463,7 +446,7 @@ var u64 = {
 };
 var u64_default = u64;
 
-// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/blake2b.js
+// ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/blake2b.js
 var B2B_IV = /* @__PURE__ */ new Uint32Array([
   4089235720,
   1779033703,
@@ -642,6 +625,23 @@ var BLAKE2b = class extends BLAKE {
 };
 var blake2b = /* @__PURE__ */ wrapConstructorWithOpts((opts) => new BLAKE2b(opts));
 
+// src/guard.ts
+var createIsGuard = (type) => (value) => typeof value === type;
+var isString = createIsGuard("string");
+var isNumber = createIsGuard("number");
+var isBigInt = createIsGuard("bigint");
+var isBoolean = createIsGuard("boolean");
+var isSymbol = createIsGuard("symbol");
+var isObject = createIsGuard("object");
+var isUndefined = createIsGuard("undefined");
+
+// src/assertion.ts
+function assert(condition, message = "assertion failed", Constructor = Error) {
+  if (!condition) {
+    throw new Constructor(message);
+  }
+}
+
 // src/bytes.ts
 var bytesToHex = (input) => {
   const bytes2 = new Uint8Array(input);
@@ -710,7 +710,7 @@ var decode2 = (input) => {
     ss58Format = (decodedBytes[0] & 63) << 2 | decodedBytes[1] >> 6 | (decodedBytes[1] & 63) << 8;
   } else {
     ss58FormatLen = 1;
-    ss58Format = decodedBytes[0];
+    [ss58Format] = decodedBytes;
   }
   assert(!RESERVED_PREFIXES.includes(ss58Format), `Reserved prefix: ${ss58Format}`);
   const checksumBytes = decodedBytes.slice(-CHECKSUM_BYTE_LENGTH);

package/dist/ss58.js

@@ -1,17 +1,17 @@
 import {
   decode,
   encode
-} from "./chunk-UPA7KLTI.js";
+} from "./chunk-CGMSQQDO.js";
 import {
   bytesToHex,
   hexToBytes
-} from "./chunk-D7RIA7SA.js";
+} from "./chunk-2KA626OL.js";
 import {
   assert
-} from "./chunk-MYP3UYWE.js";
-import "./chunk-CZNX6EUV.js";
+} from "./chunk-ZHIKNZLU.js";
+import "./chunk-HBIFE4XN.js";
 
-// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_assert.js
+// ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_assert.js
 function number(n) {
   if (!Number.isSafeInteger(n) || n < 0)
     throw new Error(`positive integer expected, not ${n}`);
@@ -39,7 +39,7 @@ function output(out, instance) {
   }
 }
 
-// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/utils.js
+// ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/utils.js
 var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
 var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
@@ -76,7 +76,7 @@ function wrapConstructorWithOpts(hashCons) {
   return hashC;
 }
 
-// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_blake.js
+// ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_blake.js
 var SIGMA = /* @__PURE__ */ new Uint8Array([
   0,
   1,
@@ -365,7 +365,7 @@ var BLAKE = class extends Hash {
   }
 };
 
-// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_u64.js
+// ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/_u64.js
 var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 var _32n = /* @__PURE__ */ BigInt(32);
 function fromBig(n, le = false) {
@@ -431,7 +431,7 @@ var u64 = {
 };
 var u64_default = u64;
 
-// ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/blake2b.js
+// ../../node_modules/.pnpm/@noble+hashes@1.5.0/node_modules/@noble/hashes/esm/blake2b.js
 var B2B_IV = /* @__PURE__ */ new Uint32Array([
   4089235720,
   1779033703,
@@ -630,7 +630,7 @@ var decode2 = (input) => {
     ss58Format = (decodedBytes[0] & 63) << 2 | decodedBytes[1] >> 6 | (decodedBytes[1] & 63) << 8;
   } else {
     ss58FormatLen = 1;
-    ss58Format = decodedBytes[0];
+    [ss58Format] = decodedBytes;
   }
   assert(!RESERVED_PREFIXES.includes(ss58Format), `Reserved prefix: ${ss58Format}`);
   const checksumBytes = decodedBytes.slice(-CHECKSUM_BYTE_LENGTH);

package/dist/string.cjs

@@ -20,26 +20,47 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/string.ts
 var string_exports = {};
 __export(string_exports, {
+  abbreviate: () => abbreviate,
   capitalize: () => capitalize,
   isHex: () => isHex,
+  isInteger: () => isInteger,
   split: () => split,
   toLowerCase: () => toLowerCase,
   toUpperCase: () => toUpperCase,
+  truncateString: () => truncateString,
   uncapitalize: () => uncapitalize
 });
 module.exports = __toCommonJS(string_exports);
 var toUpperCase = (str) => str.toUpperCase();
 var toLowerCase = (str) => str.toLowerCase();
+var isInteger = (string) => /^\d+$/.test(string);
 var split = (str, delimiter) => str.split(delimiter);
 var capitalize = (str) => `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
 var uncapitalize = (str) => `${str.charAt(0).toLowerCase()}${str.slice(1)}`;
 var isHex = (str) => /^0x[\da-f]+$/i.test(str);
+var abbreviate = (text, showLength = 4, space = false) => {
+  if (typeof text !== "string") return "";
+  const leftPart = text.slice(0, showLength);
+  const rightPart = text.slice(text.length - showLength);
+  return [leftPart, rightPart].join(space ? ". . ." : "\u2026");
+};
+var truncateString = (string, numCharacters = 20, ellipsis = true) => {
+  if (string.length < numCharacters) return string;
+  let slicedString = string.slice(0, numCharacters);
+  if (ellipsis) {
+    slicedString += "...";
+  }
+  return slicedString;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  abbreviate,
   capitalize,
   isHex,
+  isInteger,
   split,
   toLowerCase,
   toUpperCase,
+  truncateString,
   uncapitalize
 });

package/dist/string.d.cts

@@ -1,9 +1,14 @@
+import { HexString } from './types.cjs';
+
 declare const toUpperCase: <const T extends string>(str: T) => Uppercase<T>;
 declare const toLowerCase: <const T extends string>(str: T) => Lowercase<T>;
+declare const isInteger: (string: string) => boolean;
 type Split<T extends string, D extends string> = T extends `${infer L}${D}${infer R}` ? [L, ...Split<R, D>] : [T];
 declare const split: <const T extends string, D extends string>(str: T, delimiter: D) => Split<T, D>;
 declare const capitalize: <const T extends string>(str: T) => Capitalize<T>;
 declare const uncapitalize: <const T extends string>(str: T) => Uncapitalize<T>;
-declare const isHex: (str: string) => str is `0x${string}`;
+declare const isHex: (str: string) => str is HexString;
+declare const abbreviate: (text: string | undefined | null, showLength?: number, space?: boolean) => string;
+declare const truncateString: (string: string, numCharacters?: number, ellipsis?: boolean) => string;
 
-export { capitalize, isHex, split, toLowerCase, toUpperCase, uncapitalize };
+export { abbreviate, capitalize, isHex, isInteger, split, toLowerCase, toUpperCase, truncateString, uncapitalize };

package/dist/string.d.ts

@@ -1,9 +1,14 @@
+import { HexString } from './types.js';
+
 declare const toUpperCase: <const T extends string>(str: T) => Uppercase<T>;
 declare const toLowerCase: <const T extends string>(str: T) => Lowercase<T>;
+declare const isInteger: (string: string) => boolean;
 type Split<T extends string, D extends string> = T extends `${infer L}${D}${infer R}` ? [L, ...Split<R, D>] : [T];
 declare const split: <const T extends string, D extends string>(str: T, delimiter: D) => Split<T, D>;
 declare const capitalize: <const T extends string>(str: T) => Capitalize<T>;
 declare const uncapitalize: <const T extends string>(str: T) => Uncapitalize<T>;
-declare const isHex: (str: string) => str is `0x${string}`;
+declare const isHex: (str: string) => str is HexString;
+declare const abbreviate: (text: string | undefined | null, showLength?: number, space?: boolean) => string;
+declare const truncateString: (string: string, numCharacters?: number, ellipsis?: boolean) => string;
 
-export { capitalize, isHex, split, toLowerCase, toUpperCase, uncapitalize };
+export { abbreviate, capitalize, isHex, isInteger, split, toLowerCase, toUpperCase, truncateString, uncapitalize };

package/dist/string.js

@@ -1,15 +1,33 @@
 // src/string.ts
 var toUpperCase = (str) => str.toUpperCase();
 var toLowerCase = (str) => str.toLowerCase();
+var isInteger = (string) => /^\d+$/.test(string);
 var split = (str, delimiter) => str.split(delimiter);
 var capitalize = (str) => `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
 var uncapitalize = (str) => `${str.charAt(0).toLowerCase()}${str.slice(1)}`;
 var isHex = (str) => /^0x[\da-f]+$/i.test(str);
+var abbreviate = (text, showLength = 4, space = false) => {
+  if (typeof text !== "string") return "";
+  const leftPart = text.slice(0, showLength);
+  const rightPart = text.slice(text.length - showLength);
+  return [leftPart, rightPart].join(space ? ". . ." : "\u2026");
+};
+var truncateString = (string, numCharacters = 20, ellipsis = true) => {
+  if (string.length < numCharacters) return string;
+  let slicedString = string.slice(0, numCharacters);
+  if (ellipsis) {
+    slicedString += "...";
+  }
+  return slicedString;
+};
 export {
+  abbreviate,
   capitalize,
   isHex,
+  isInteger,
   split,
   toLowerCase,
   toUpperCase,
+  truncateString,
   uncapitalize
 };