@chainflip/utils 0.11.3 → 2.1.0-beta.0

package/dist/async.js

@@ -1,94 +1,99 @@
-// src/async.ts
-var deferredPromise = () => {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
+//#region src/async.ts
+const deferredPromise = () => {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
 };
-var sleep = (ms, { signal } = {}) => {
-  const deferred = deferredPromise();
-  const timeout = setTimeout(deferred.resolve, ms);
-  if (signal) {
-    const abort = () => {
-      clearTimeout(timeout);
-      deferred.resolve();
-    };
-    signal.addEventListener("abort", abort);
-    deferred.promise = deferred.promise.finally(() => {
-      signal.removeEventListener("abort", abort);
-    });
-  }
-  return deferred.promise;
+const sleep = (ms, { signal } = {}) => {
+	const deferred = deferredPromise();
+	const timeout = setTimeout(deferred.resolve, ms);
+	if (signal) {
+		const abort = () => {
+			clearTimeout(timeout);
+			deferred.resolve();
+		};
+		signal.addEventListener("abort", abort);
+		deferred.promise = deferred.promise.finally(() => {
+			signal.removeEventListener("abort", abort);
+		});
+	}
+	return deferred.promise;
 };
 var Queue = class {
-  constructor(debounce) {
-    this.debounce = debounce;
-  }
-  promise = Promise.resolve();
-  enqueue(fn, ...args) {
-    return new Promise((resolve, reject) => {
-      this.promise = this.promise.then(async () => {
-        const sleepPromise = this.debounce ? sleep(this.debounce) : Promise.resolve();
-        await Promise.all([fn(...args).then(resolve, reject), sleepPromise]);
-      });
-    });
-  }
+	promise = Promise.resolve();
+	constructor(debounce) {
+		this.debounce = debounce;
+	}
+	enqueue(fn, ...args) {
+		return new Promise((resolve, reject) => {
+			this.promise = this.promise.then(async () => {
+				const sleepPromise = this.debounce ? sleep(this.debounce) : Promise.resolve();
+				await Promise.all([fn(...args).then(resolve, reject), sleepPromise]);
+			});
+		});
+	}
 };
 var RateLimiter = class {
-  fn;
-  debounce;
-  queues;
-  index = 0;
-  constructor(opts) {
-    this.fn = opts.fn;
-    this.debounce = opts.debounce;
-    this.queues = Array.from({ length: opts.maxConcurrency }, () => new Queue(this.debounce));
-  }
-  request(...args) {
-    const nextIndex = this.index;
-    this.index = (this.index + 1) % this.queues.length;
-    return this.queues[nextIndex].enqueue(this.fn, ...args);
-  }
+	fn;
+	debounce;
+	queues;
+	index = 0;
+	constructor(opts) {
+		this.fn = opts.fn;
+		this.debounce = opts.debounce;
+		this.queues = Array.from({ length: opts.maxConcurrency }, () => new Queue(this.debounce));
+	}
+	request(...args) {
+		const nextIndex = this.index;
+		this.index = (this.index + 1) % this.queues.length;
+		return this.queues[nextIndex].enqueue(this.fn, ...args);
+	}
 };
-var once = async (target, event, opts) => {
-  const deferred = deferredPromise();
-  const onSuccess = () => {
-    target.removeEventListener("error", onError);
-    deferred.resolve();
-  };
-  const onError = () => {
-    target.removeEventListener(event, onSuccess);
-    deferred.reject(new Error("error"));
-  };
-  target.addEventListener(event, onSuccess, { once: true, signal: opts?.signal });
-  target.addEventListener("error", onError, { once: true, signal: opts?.signal });
-  if (opts?.signal) {
-    const { signal } = opts;
-    const abort = () => {
-      deferred.reject(new Error("aborted"));
-    };
-    signal.addEventListener("abort", abort);
-    deferred.promise = deferred.promise.finally(() => {
-      signal.removeEventListener("abort", abort);
-    });
-  }
-  if (opts?.timeout) {
-    const timer = setTimeout(() => {
-      deferred.reject(new Error("timeout"));
-    }, opts.timeout);
-    deferred.promise = deferred.promise.finally(() => {
-      clearTimeout(timer);
-    });
-  }
-  await deferred.promise;
-};
-export {
-  Queue,
-  RateLimiter,
-  deferredPromise,
-  once,
-  sleep
+const once = async (target, event, opts) => {
+	const deferred = deferredPromise();
+	const onSuccess = () => {
+		target.removeEventListener("error", onError);
+		deferred.resolve();
+	};
+	const onError = () => {
+		target.removeEventListener(event, onSuccess);
+		deferred.reject(/* @__PURE__ */ new Error("error"));
+	};
+	target.addEventListener(event, onSuccess, {
+		once: true,
+		signal: opts?.signal
+	});
+	target.addEventListener("error", onError, {
+		once: true,
+		signal: opts?.signal
+	});
+	if (opts?.signal) {
+		const { signal } = opts;
+		const abort = () => {
+			deferred.reject(/* @__PURE__ */ new Error("aborted"));
+		};
+		signal.addEventListener("abort", abort);
+		deferred.promise = deferred.promise.finally(() => {
+			signal.removeEventListener("abort", abort);
+		});
+	}
+	if (opts?.timeout) {
+		const timer = setTimeout(() => {
+			deferred.reject(/* @__PURE__ */ new Error("timeout"));
+		}, opts.timeout);
+		deferred.promise = deferred.promise.finally(() => {
+			clearTimeout(timer);
+		});
+	}
+	await deferred.promise;
 };
+
+//#endregion
+export { Queue, RateLimiter, deferredPromise, once, sleep };

package/dist/base58.cjs

@@ -1,95 +1,11 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+const require_bytes = require('./bytes.cjs');
 
-// src/base58.ts
-var base58_exports = {};
-__export(base58_exports, {
-  CHARSET: () => CHARSET,
-  decode: () => decode,
-  encode: () => encode
-});
-module.exports = __toCommonJS(base58_exports);
+//#region src/base58.ts
+const CHARSET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const encode = (bytes) => require_bytes.encodeBytesWithCharset(bytes, CHARSET);
+const decode = (input) => require_bytes.decodeBytesWithCharset(input, CHARSET);
 
-// 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 hexToBytes = (input) => {
-  assert(/^0x[\da-f]*$/i.test(input) && input.length % 2 === 0, "Invalid hex string");
-  const hex = input.slice(2);
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = Number.parseInt(hex.slice(i, i + 2), 16);
-  }
-  return bytes;
-};
-var convertBase = (inputBytes, fromBase, toBase) => {
-  const bytes = typeof inputBytes === "string" ? hexToBytes(inputBytes) : new Uint8Array(inputBytes);
-  const result = [];
-  for (const byte of bytes) {
-    let carry = byte;
-    for (let i = 0; i < result.length; i += 1) {
-      carry += result[i] * fromBase;
-      result[i] = carry % toBase;
-      carry = Math.floor(carry / toBase);
-    }
-    while (carry !== 0) {
-      result.push(carry % toBase);
-      carry = Math.floor(carry / toBase);
-    }
-  }
-  let leadingZeros = 0;
-  while (bytes[leadingZeros] === 0) {
-    leadingZeros += 1;
-    result.push(0);
-  }
-  return result.reverse();
-};
-var encodeBytesWithCharset = (bytes, charset) => convertBase(bytes, 256, charset.length).map((charCode) => charset.charAt(charCode)).join("");
-var decodeBytesWithCharset = (input, charset) => {
-  assert(new RegExp(`^[${charset}]*$`).test(input), "Invalid input");
-  const charMap = Object.fromEntries([...charset].map((char, index) => [char, index]));
-  const bytes = input.split("").map((char) => charMap[char]);
-  return new Uint8Array(convertBase(bytes, charset.length, 256));
-};
-
-// src/base58.ts
-var CHARSET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-var encode = (bytes) => encodeBytesWithCharset(bytes, CHARSET);
-var decode = (input) => decodeBytesWithCharset(input, CHARSET);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CHARSET,
-  decode,
-  encode
-});
+//#endregion
+exports.CHARSET = CHARSET;
+exports.decode = decode;
+exports.encode = encode;

package/dist/base58.d.ts

@@ -1,8 +1,8 @@
-import { Bytelike } from './types.js';
-import './chainflip.js';
+import { Bytelike } from "./types.js";
 
+//#region src/base58.d.ts
 declare const CHARSET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 declare const encode: (bytes: Bytelike) => string;
 declare const decode: (input: string) => Uint8Array;
-
-export { CHARSET, decode, encode };
+//#endregion
+export { CHARSET, decode, encode };

package/dist/base58.js

@@ -1,13 +1,9 @@
-import {
-  CHARSET,
-  decode,
-  encode
-} from "./chunk-3P6TXYEI.js";
-import "./chunk-XGNPN5CY.js";
-import "./chunk-ZHIKNZLU.js";
-import "./chunk-HBIFE4XN.js";
-export {
-  CHARSET,
-  decode,
-  encode
-};
+import { decodeBytesWithCharset, encodeBytesWithCharset } from "./bytes.js";
+
+//#region src/base58.ts
+const CHARSET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const encode = (bytes) => encodeBytesWithCharset(bytes, CHARSET);
+const decode = (input) => decodeBytesWithCharset(input, CHARSET);
+
+//#endregion
+export { CHARSET, decode, encode };

package/dist/bytes.cjs

@@ -1,104 +1,56 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/bytes.ts
-var bytes_exports = {};
-__export(bytes_exports, {
-  bytesToHex: () => bytesToHex,
-  decodeBytesWithCharset: () => decodeBytesWithCharset,
-  encodeBytesWithCharset: () => encodeBytesWithCharset,
-  hexToBytes: () => hexToBytes,
-  reverseBytes: () => reverseBytes
-});
-module.exports = __toCommonJS(bytes_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");
+const require_assertion = require('./assertion.cjs');
 
-// src/assertion.ts
-function assert(condition, message = "assertion failed", Constructor = Error) {
-  if (!condition) {
-    throw new Constructor(message);
-  }
-}
-
-// src/bytes.ts
-var bytesToHex = (input) => {
-  const bytes = new Uint8Array(input);
-  return `0x${Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+//#region src/bytes.ts
+const bytesToHex = (input) => {
+	const bytes = new Uint8Array(input);
+	return `0x${Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 };
-var hexToBytes = (input) => {
-  assert(/^0x[\da-f]*$/i.test(input) && input.length % 2 === 0, "Invalid hex string");
-  const hex = input.slice(2);
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = Number.parseInt(hex.slice(i, i + 2), 16);
-  }
-  return bytes;
+const hexToBytes = (input) => {
+	require_assertion.assert(/^0x[\da-f]*$/i.test(input) && input.length % 2 === 0, "Invalid hex string");
+	const hex = input.slice(2);
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < hex.length; i += 2) bytes[i / 2] = Number.parseInt(hex.slice(i, i + 2), 16);
+	return bytes;
 };
-var convertBase = (inputBytes, fromBase, toBase) => {
-  const bytes = typeof inputBytes === "string" ? hexToBytes(inputBytes) : new Uint8Array(inputBytes);
-  const result = [];
-  for (const byte of bytes) {
-    let carry = byte;
-    for (let i = 0; i < result.length; i += 1) {
-      carry += result[i] * fromBase;
-      result[i] = carry % toBase;
-      carry = Math.floor(carry / toBase);
-    }
-    while (carry !== 0) {
-      result.push(carry % toBase);
-      carry = Math.floor(carry / toBase);
-    }
-  }
-  let leadingZeros = 0;
-  while (bytes[leadingZeros] === 0) {
-    leadingZeros += 1;
-    result.push(0);
-  }
-  return result.reverse();
+const convertBase = (inputBytes, fromBase, toBase) => {
+	const bytes = typeof inputBytes === "string" ? hexToBytes(inputBytes) : new Uint8Array(inputBytes);
+	const result = [];
+	for (const byte of bytes) {
+		let carry = byte;
+		for (let i = 0; i < result.length; i += 1) {
+			carry += result[i] * fromBase;
+			result[i] = carry % toBase;
+			carry = Math.floor(carry / toBase);
+		}
+		while (carry !== 0) {
+			result.push(carry % toBase);
+			carry = Math.floor(carry / toBase);
+		}
+	}
+	let leadingZeros = 0;
+	while (bytes[leadingZeros] === 0) {
+		leadingZeros += 1;
+		result.push(0);
+	}
+	return result.reverse();
 };
-var encodeBytesWithCharset = (bytes, charset) => convertBase(bytes, 256, charset.length).map((charCode) => charset.charAt(charCode)).join("");
-var decodeBytesWithCharset = (input, charset) => {
-  assert(new RegExp(`^[${charset}]*$`).test(input), "Invalid input");
-  const charMap = Object.fromEntries([...charset].map((char, index) => [char, index]));
-  const bytes = input.split("").map((char) => charMap[char]);
-  return new Uint8Array(convertBase(bytes, charset.length, 256));
+const encodeBytesWithCharset = (bytes, charset) => convertBase(bytes, 256, charset.length).map((charCode) => charset.charAt(charCode)).join("");
+const decodeBytesWithCharset = (input, charset) => {
+	require_assertion.assert(new RegExp(`^[${charset}]*$`).test(input), "Invalid input");
+	const charMap = Object.fromEntries([...charset].map((char, index) => [char, index]));
+	const bytes = input.split("").map((char) => charMap[char]);
+	return new Uint8Array(convertBase(bytes, charset.length, 256));
 };
 function reverseBytes(input) {
-  const bytes = /^(?:0x)?([\da-f]+)$/gi.exec(input)?.[1];
-  assert(bytes && bytes.length % 2 === 0 && bytes.length > 0, "Invalid hex string");
-  const reversed = bytes.match(/.{2}/g).reverse().join("");
-  return input.startsWith("0x") ? `0x${reversed}` : reversed;
+	const bytes = /^(?:0x)?([\da-f]+)$/gi.exec(input)?.[1];
+	require_assertion.assert(bytes && bytes.length % 2 === 0 && bytes.length > 0, "Invalid hex string");
+	const reversed = bytes.match(/.{2}/g).reverse().join("");
+	return input.startsWith("0x") ? `0x${reversed}` : reversed;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  bytesToHex,
-  decodeBytesWithCharset,
-  encodeBytesWithCharset,
-  hexToBytes,
-  reverseBytes
-});
+
+//#endregion
+exports.bytesToHex = bytesToHex;
+exports.decodeBytesWithCharset = decodeBytesWithCharset;
+exports.encodeBytesWithCharset = encodeBytesWithCharset;
+exports.hexToBytes = hexToBytes;
+exports.reverseBytes = reverseBytes;

package/dist/bytes.d.ts

@@ -1,11 +1,11 @@
-import { HexString, Bytelike } from './types.js';
-import './chainflip.js';
+import { Bytelike, HexString } from "./types.js";
 
+//#region src/bytes.d.ts
 declare const bytesToHex: (input: Uint8Array | number[]) => `0x${string}`;
 declare const hexToBytes: (input: HexString) => Uint8Array;
 declare const encodeBytesWithCharset: (bytes: Bytelike, charset: string) => string;
 declare const decodeBytesWithCharset: (input: string, charset: string) => Uint8Array;
 declare function reverseBytes(input: HexString): HexString;
 declare function reverseBytes(input: string): string;
-
-export { bytesToHex, decodeBytesWithCharset, encodeBytesWithCharset, hexToBytes, reverseBytes };
+//#endregion
+export { bytesToHex, decodeBytesWithCharset, encodeBytesWithCharset, hexToBytes, reverseBytes };

package/dist/bytes.js

@@ -1,16 +1,52 @@
-import {
-  bytesToHex,
-  decodeBytesWithCharset,
-  encodeBytesWithCharset,
-  hexToBytes,
-  reverseBytes
-} from "./chunk-XGNPN5CY.js";
-import "./chunk-ZHIKNZLU.js";
-import "./chunk-HBIFE4XN.js";
-export {
-  bytesToHex,
-  decodeBytesWithCharset,
-  encodeBytesWithCharset,
-  hexToBytes,
-  reverseBytes
+import { assert } from "./assertion.js";
+
+//#region src/bytes.ts
+const bytesToHex = (input) => {
+	const bytes = new Uint8Array(input);
+	return `0x${Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 };
+const hexToBytes = (input) => {
+	assert(/^0x[\da-f]*$/i.test(input) && input.length % 2 === 0, "Invalid hex string");
+	const hex = input.slice(2);
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < hex.length; i += 2) bytes[i / 2] = Number.parseInt(hex.slice(i, i + 2), 16);
+	return bytes;
+};
+const convertBase = (inputBytes, fromBase, toBase) => {
+	const bytes = typeof inputBytes === "string" ? hexToBytes(inputBytes) : new Uint8Array(inputBytes);
+	const result = [];
+	for (const byte of bytes) {
+		let carry = byte;
+		for (let i = 0; i < result.length; i += 1) {
+			carry += result[i] * fromBase;
+			result[i] = carry % toBase;
+			carry = Math.floor(carry / toBase);
+		}
+		while (carry !== 0) {
+			result.push(carry % toBase);
+			carry = Math.floor(carry / toBase);
+		}
+	}
+	let leadingZeros = 0;
+	while (bytes[leadingZeros] === 0) {
+		leadingZeros += 1;
+		result.push(0);
+	}
+	return result.reverse();
+};
+const encodeBytesWithCharset = (bytes, charset) => convertBase(bytes, 256, charset.length).map((charCode) => charset.charAt(charCode)).join("");
+const decodeBytesWithCharset = (input, charset) => {
+	assert(new RegExp(`^[${charset}]*$`).test(input), "Invalid input");
+	const charMap = Object.fromEntries([...charset].map((char, index) => [char, index]));
+	const bytes = input.split("").map((char) => charMap[char]);
+	return new Uint8Array(convertBase(bytes, charset.length, 256));
+};
+function reverseBytes(input) {
+	const bytes = /^(?:0x)?([\da-f]+)$/gi.exec(input)?.[1];
+	assert(bytes && bytes.length % 2 === 0 && bytes.length > 0, "Invalid hex string");
+	const reversed = bytes.match(/.{2}/g).reverse().join("");
+	return input.startsWith("0x") ? `0x${reversed}` : reversed;
+}
+
+//#endregion
+export { bytesToHex, decodeBytesWithCharset, encodeBytesWithCharset, hexToBytes, reverseBytes };