@chainflip/utils 0.1.1 → 0.1.3

package/dist/assertion.cjs

@@ -49,25 +49,39 @@ function assert(condition, message = "assertion failed", Constructor = Error) {
   }
 }
 function assertString(value, message) {
-  assert(isString(value), message ?? `expected a "string", got "${typeof value}"`);
+  if (!isString(value)) {
+    throw new TypeError(message ?? `expected a "string", got "${typeof value}"`);
+  }
 }
 function assertNumber(value, message) {
-  assert(isNumber(value), message ?? `expected a "number", got "${typeof value}"`);
+  if (!isNumber(value)) {
+    throw new TypeError(message ?? `expected a "number", got "${typeof value}"`);
+  }
 }
 function assertBigInt(value, message) {
-  assert(isBigInt(value), message ?? `expected a "bigint", got "${typeof value}"`);
+  if (!isBigInt(value)) {
+    throw new TypeError(message ?? `expected a "bigint", got "${typeof value}"`);
+  }
 }
 function assertBoolean(value, message) {
-  assert(isBoolean(value), message ?? `expected a "boolean", got "${typeof value}"`);
+  if (!isBoolean(value)) {
+    throw new TypeError(message ?? `expected a "boolean", got "${typeof value}"`);
+  }
 }
 function assertSymbol(value, message) {
-  assert(isSymbol(value), message ?? `expected a "symbol", got "${typeof value}"`);
+  if (!isSymbol(value)) {
+    throw new TypeError(message ?? `expected a "symbol", got "${typeof value}"`);
+  }
 }
 function assertObject(value, message) {
-  assert(isObject(value), message ?? `expected an "object", got "${typeof value}"`);
+  if (!isObject(value)) {
+    throw new TypeError(message ?? `expected an "object", got "${typeof value}"`);
+  }
 }
 function assertUndefined(value, message) {
-  assert(isUndefined(value), message ?? `expected "undefined", got "${typeof value}"`);
+  if (!isUndefined(value)) {
+    throw new TypeError(message ?? `expected "undefined", got "${typeof value}"`);
+  }
 }
 var unreachable = (x, message = "unreachable") => {
   throw new Error(message);

package/dist/assertion.js

@@ -8,7 +8,7 @@ import {
   assertSymbol,
   assertUndefined,
   unreachable
-} from "./chunk-NYJKCZRI.js";
+} from "./chunk-MYP3UYWE.js";
 import "./chunk-CZNX6EUV.js";
 export {
   assert,

package/dist/async.cjs

@@ -23,6 +23,7 @@ __export(async_exports, {
   Queue: () => Queue,
   RateLimiter: () => RateLimiter,
   deferredPromise: () => deferredPromise,
+  once: () => once,
   sleep: () => sleep
 });
 module.exports = __toCommonJS(async_exports);
@@ -80,10 +81,43 @@ var RateLimiter = class {
     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.signal;
+    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;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Queue,
   RateLimiter,
   deferredPromise,
+  once,
   sleep
 });

package/dist/async.d.cts

@@ -25,5 +25,9 @@ declare class RateLimiter<T, Args extends unknown[]> {
     });
     request(...args: Args): Promise<T>;
 }
+declare const once: <T extends EventTarget, K extends string>(target: T, event: K, opts?: {
+    signal?: AbortSignal;
+    timeout?: number;
+}) => Promise<void>;
 
-export { type DeferredPromise, Queue, RateLimiter, deferredPromise, sleep };
+export { type DeferredPromise, Queue, RateLimiter, deferredPromise, once, sleep };

package/dist/async.d.ts

@@ -25,5 +25,9 @@ declare class RateLimiter<T, Args extends unknown[]> {
     });
     request(...args: Args): Promise<T>;
 }
+declare const once: <T extends EventTarget, K extends string>(target: T, event: K, opts?: {
+    signal?: AbortSignal;
+    timeout?: number;
+}) => Promise<void>;
 
-export { type DeferredPromise, Queue, RateLimiter, deferredPromise, sleep };
+export { type DeferredPromise, Queue, RateLimiter, deferredPromise, once, sleep };

package/dist/async.js

@@ -53,9 +53,42 @@ var RateLimiter = class {
     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.signal;
+    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
 };

package/dist/base58.cjs

@@ -35,6 +35,13 @@ 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 convertBase = (bytes, fromBase, toBase) => {
   const result = [];
@@ -59,9 +66,10 @@ var convertBase = (bytes, fromBase, toBase) => {
 };
 var encodeBytesWithCharset = (bytes, charset2) => convertBase(bytes, 256, charset2.length).map((charCode) => charset2.charAt(charCode)).join("");
 var decodeBytesWithCharset = (input, charset2) => {
+  assert(new RegExp(`^[${charset2}]*$`).test(input), "Invalid input");
   const charMap = Object.fromEntries([...charset2].map((char, index) => [char, index]));
   const bytes = input.split("").map((char) => charMap[char]);
-  return convertBase(bytes, charset2.length, 256);
+  return new Uint8Array(convertBase(bytes, charset2.length, 256));
 };
 
 // src/base58.ts

package/dist/base58.d.cts

@@ -1,4 +1,4 @@
 declare const encode: (bytes: Uint8Array | number[]) => string;
-declare const decode: (input: string) => number[];
+declare const decode: (input: string) => Uint8Array;
 
 export { decode, encode };

package/dist/base58.d.ts

@@ -1,4 +1,4 @@
 declare const encode: (bytes: Uint8Array | number[]) => string;
-declare const decode: (input: string) => number[];
+declare const decode: (input: string) => Uint8Array;
 
 export { decode, encode };

package/dist/base58.js

@@ -1,9 +1,9 @@
 import {
   decode,
   encode
-} from "./chunk-MORKFLN4.js";
-import "./chunk-DGVZ5UDU.js";
-import "./chunk-NYJKCZRI.js";
+} from "./chunk-O4WBUIAN.js";
+import "./chunk-4RHM5374.js";
+import "./chunk-MYP3UYWE.js";
 import "./chunk-CZNX6EUV.js";
 export {
   decode,

package/dist/bytes.cjs

@@ -81,9 +81,10 @@ var convertBase = (bytes, fromBase, toBase) => {
 };
 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 convertBase(bytes, charset.length, 256);
+  return new Uint8Array(convertBase(bytes, charset.length, 256));
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/bytes.d.cts

@@ -3,6 +3,6 @@ import { HexString } from './types.cjs';
 declare const bytesToHex: (input: Uint8Array | number[]) => `0x${string}`;
 declare const hexToBytes: (input: HexString) => Uint8Array;
 declare const encodeBytesWithCharset: (bytes: Uint8Array | number[], charset: string) => string;
-declare const decodeBytesWithCharset: (input: string, charset: string) => number[];
+declare const decodeBytesWithCharset: (input: string, charset: string) => Uint8Array;
 
 export { bytesToHex, decodeBytesWithCharset, encodeBytesWithCharset, hexToBytes };

package/dist/bytes.d.ts

@@ -3,6 +3,6 @@ import { HexString } from './types.js';
 declare const bytesToHex: (input: Uint8Array | number[]) => `0x${string}`;
 declare const hexToBytes: (input: HexString) => Uint8Array;
 declare const encodeBytesWithCharset: (bytes: Uint8Array | number[], charset: string) => string;
-declare const decodeBytesWithCharset: (input: string, charset: string) => number[];
+declare const decodeBytesWithCharset: (input: string, charset: string) => Uint8Array;
 
 export { bytesToHex, decodeBytesWithCharset, encodeBytesWithCharset, hexToBytes };

package/dist/bytes.js

@@ -3,8 +3,8 @@ import {
   decodeBytesWithCharset,
   encodeBytesWithCharset,
   hexToBytes
-} from "./chunk-DGVZ5UDU.js";
-import "./chunk-NYJKCZRI.js";
+} from "./chunk-4RHM5374.js";
+import "./chunk-MYP3UYWE.js";
 import "./chunk-CZNX6EUV.js";
 export {
   bytesToHex,

package/dist/{chunk-DGVZ5UDU.js → chunk-4RHM5374.js}

@@ -1,6 +1,6 @@
 import {
   assert
-} from "./chunk-NYJKCZRI.js";
+} from "./chunk-MYP3UYWE.js";
 
 // src/bytes.ts
 var bytesToHex = (input) => {
@@ -39,9 +39,10 @@ var convertBase = (bytes, fromBase, toBase) => {
 };
 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 convertBase(bytes, charset.length, 256);
+  return new Uint8Array(convertBase(bytes, charset.length, 256));
 };
 
 export {

package/dist/{chunk-NYJKCZRI.js → chunk-MYP3UYWE.js}

@@ -15,25 +15,39 @@ function assert(condition, message = "assertion failed", Constructor = Error) {
   }
 }
 function assertString(value, message) {
-  assert(isString(value), message ?? `expected a "string", got "${typeof value}"`);
+  if (!isString(value)) {
+    throw new TypeError(message ?? `expected a "string", got "${typeof value}"`);
+  }
 }
 function assertNumber(value, message) {
-  assert(isNumber(value), message ?? `expected a "number", got "${typeof value}"`);
+  if (!isNumber(value)) {
+    throw new TypeError(message ?? `expected a "number", got "${typeof value}"`);
+  }
 }
 function assertBigInt(value, message) {
-  assert(isBigInt(value), message ?? `expected a "bigint", got "${typeof value}"`);
+  if (!isBigInt(value)) {
+    throw new TypeError(message ?? `expected a "bigint", got "${typeof value}"`);
+  }
 }
 function assertBoolean(value, message) {
-  assert(isBoolean(value), message ?? `expected a "boolean", got "${typeof value}"`);
+  if (!isBoolean(value)) {
+    throw new TypeError(message ?? `expected a "boolean", got "${typeof value}"`);
+  }
 }
 function assertSymbol(value, message) {
-  assert(isSymbol(value), message ?? `expected a "symbol", got "${typeof value}"`);
+  if (!isSymbol(value)) {
+    throw new TypeError(message ?? `expected a "symbol", got "${typeof value}"`);
+  }
 }
 function assertObject(value, message) {
-  assert(isObject(value), message ?? `expected an "object", got "${typeof value}"`);
+  if (!isObject(value)) {
+    throw new TypeError(message ?? `expected an "object", got "${typeof value}"`);
+  }
 }
 function assertUndefined(value, message) {
-  assert(isUndefined(value), message ?? `expected "undefined", got "${typeof value}"`);
+  if (!isUndefined(value)) {
+    throw new TypeError(message ?? `expected "undefined", got "${typeof value}"`);
+  }
 }
 var unreachable = (x, message = "unreachable") => {
   throw new Error(message);

package/dist/{chunk-MORKFLN4.js → chunk-O4WBUIAN.js}

@@ -1,7 +1,7 @@
 import {
   decodeBytesWithCharset,
   encodeBytesWithCharset
-} from "./chunk-DGVZ5UDU.js";
+} from "./chunk-4RHM5374.js";
 
 // src/base58.ts
 var charset = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

package/dist/ss58.cjs

@@ -674,9 +674,10 @@ var convertBase = (bytes2, fromBase, toBase) => {
 };
 var encodeBytesWithCharset = (bytes2, charset2) => convertBase(bytes2, 256, charset2.length).map((charCode) => charset2.charAt(charCode)).join("");
 var decodeBytesWithCharset = (input, charset2) => {
+  assert(new RegExp(`^[${charset2}]*$`).test(input), "Invalid input");
   const charMap = Object.fromEntries([...charset2].map((char, index) => [char, index]));
   const bytes2 = input.split("").map((char) => charMap[char]);
-  return convertBase(bytes2, charset2.length, 256);
+  return new Uint8Array(convertBase(bytes2, charset2.length, 256));
 };
 
 // src/base58.ts
@@ -707,10 +708,10 @@ var decode2 = (input) => {
     ss58Format = decodedBytes[0];
   }
   assert(!RESERVED_PREFIXES.includes(ss58Format), `Reserved prefix: ${ss58Format}`);
-  const checksumBytes = decodedBytes.splice(-CHECKSUM_BYTE_LENGTH);
-  const data = decodedBytes.slice(ss58FormatLen);
+  const checksumBytes = decodedBytes.slice(-CHECKSUM_BYTE_LENGTH);
+  const data = decodedBytes.slice(ss58FormatLen, -CHECKSUM_BYTE_LENGTH);
   assert(data.length === DATA_LENGTH, `Invalid data length: ${data.length}`);
-  const checksum = computeChecksum(decodedBytes);
+  const checksum = computeChecksum(decodedBytes.slice(0, -CHECKSUM_BYTE_LENGTH));
   assert(
     checksumBytes[0] === checksum[0],
     `Invalid checksum: ${checksumBytes[0]} !== ${checksum[0]}`

package/dist/ss58.js

@@ -1,13 +1,13 @@
 import {
   decode,
   encode
-} from "./chunk-MORKFLN4.js";
+} from "./chunk-O4WBUIAN.js";
 import {
   hexToBytes
-} from "./chunk-DGVZ5UDU.js";
+} from "./chunk-4RHM5374.js";
 import {
   assert
-} from "./chunk-NYJKCZRI.js";
+} from "./chunk-MYP3UYWE.js";
 import "./chunk-CZNX6EUV.js";
 
 // ../../node_modules/.pnpm/@noble+hashes@1.4.0/node_modules/@noble/hashes/esm/_assert.js
@@ -632,10 +632,10 @@ var decode2 = (input) => {
     ss58Format = decodedBytes[0];
   }
   assert(!RESERVED_PREFIXES.includes(ss58Format), `Reserved prefix: ${ss58Format}`);
-  const checksumBytes = decodedBytes.splice(-CHECKSUM_BYTE_LENGTH);
-  const data = decodedBytes.slice(ss58FormatLen);
+  const checksumBytes = decodedBytes.slice(-CHECKSUM_BYTE_LENGTH);
+  const data = decodedBytes.slice(ss58FormatLen, -CHECKSUM_BYTE_LENGTH);
   assert(data.length === DATA_LENGTH, `Invalid data length: ${data.length}`);
-  const checksum = computeChecksum(decodedBytes);
+  const checksum = computeChecksum(decodedBytes.slice(0, -CHECKSUM_BYTE_LENGTH));
   assert(
     checksumBytes[0] === checksum[0],
     `Invalid checksum: ${checksumBytes[0]} !== ${checksum[0]}`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainflip/utils",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "files": [
     "dist",