@fleet-sdk/common 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @fleet-sdk/common
 
+## 0.2.3
+
+### Patch Changes
+
+- 1e0edd4: Fix missing `types` export in `package.json`
+
 ## 0.2.2
 
 ### Patch Changes

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@fleet-sdk/common",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Internal utility functions, constants and types shared across @fleet-sdk packages.",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.esm.js",
   "types": "./dist/index.d.ts",
   "exports": {
+    "types": "./dist/index.d.ts",
     "require": "./dist/index.cjs.js",
     "import": "./dist/index.esm.js"
   },
@@ -24,7 +25,6 @@
     "node": ">=14"
   },
   "files": [
-    "src",
     "dist",
     "!**/*.spec.*",
     "!**/*.json",

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from "./utils";
-export * from "./types";
-export * from "./models";

package/src/models/collection.ts

@@ -1,107 +0,0 @@
-import { OneOrMore } from "../types";
-import { isDefined } from "../utils";
-
-export type CollectionAddOptions = { index?: number };
-
-export abstract class Collection<InternalType, ExternalType> implements Iterable<InternalType> {
-  protected readonly _items: InternalType[];
-
-  constructor() {
-    this._items = [];
-  }
-
-  protected _isIndexOutOfBounds(index: number): boolean {
-    return index < 0 || index >= this._items.length;
-  }
-
-  [Symbol.iterator](): Iterator<InternalType> {
-    let counter = 0;
-
-    return {
-      next: () => {
-        return {
-          done: counter >= this.length,
-          value: this._items[counter++]
-        };
-      }
-    };
-  }
-
-  public get length(): number {
-    return this._items.length;
-  }
-
-  public get isEmpty(): boolean {
-    return this.length === 0;
-  }
-
-  public at(index: number): InternalType {
-    if (this._isIndexOutOfBounds(index)) {
-      throw new RangeError(`Index '${index}' is out of range.`);
-    }
-
-    return this._items[index];
-  }
-
-  public add(items: OneOrMore<ExternalType>, options?: CollectionAddOptions): number {
-    return this._addOneOrMore(items, options);
-  }
-
-  abstract remove(item: unknown): number;
-
-  protected abstract _map(item: ExternalType | InternalType): InternalType;
-
-  protected _addOne(item: InternalType | ExternalType, options?: CollectionAddOptions): number {
-    if (isDefined(options) && isDefined(options.index)) {
-      if (options.index === this.length) {
-        this._items.push(this._map(item));
-
-        return this.length;
-      }
-
-      if (this._isIndexOutOfBounds(options.index)) {
-        throw new RangeError(`Index '${options.index}' is out of range.`);
-      }
-
-      this._items.splice(options.index, 0, this._map(item));
-
-      return this.length;
-    }
-
-    this._items.push(this._map(item));
-
-    return this._items.length;
-  }
-
-  protected _addOneOrMore(items: OneOrMore<ExternalType>, options?: CollectionAddOptions): number {
-    if (Array.isArray(items)) {
-      if (isDefined(options) && isDefined(options.index)) {
-        items = items.reverse();
-      }
-
-      for (const item of items) {
-        this._addOne(item, options);
-      }
-    } else {
-      this._addOne(items, options);
-    }
-
-    return this.length;
-  }
-
-  public toArray(): InternalType[] {
-    return [...this._items];
-  }
-
-  public reduce<U>(
-    callbackFn: (
-      accumulator: U,
-      currentValue: InternalType,
-      currentIndex: number,
-      array: InternalType[]
-    ) => U,
-    initialValue: U
-  ): U {
-    return this._items.reduce(callbackFn, initialValue);
-  }
-}

package/src/models/index.ts

@@ -1 +0,0 @@
-export * from "./collection";

package/src/types/block.ts

@@ -1,44 +0,0 @@
-import { HexString } from "./common";
-import { SignedTransaction } from "./transactions";
-
-export type PoWSolution = {
-  pk: HexString;
-  w: HexString;
-  n: string;
-  d: number;
-};
-
-export type BlockHeaderId = string;
-
-export type BlockTransactions = {
-  headerId: BlockHeaderId;
-  transactions: SignedTransaction[];
-};
-
-export type BlockHeader = {
-  id: BlockHeaderId;
-  timestamp: number;
-  version: number;
-  adProofsRoot: HexString;
-  stateRoot: HexString;
-  transactionsRoot: HexString;
-  nBits: number;
-  extensionHash: HexString;
-  powSolutions: PoWSolution;
-  height: number;
-  difficulty: string;
-  parentId: BlockHeaderId;
-  votes: string;
-  size: number;
-  extensionId: HexString;
-  transactionsId: HexString;
-  adProofsId: HexString;
-};
-
-export type Block = {
-  header: BlockHeader;
-  blockTransactions: BlockTransactions;
-  adProofs: unknown; // TODO
-  extension: unknown; // TODO
-  size: number;
-};

package/src/types/boxes.ts

@@ -1,31 +0,0 @@
-import { ErgoTreeHex } from "./common";
-import { NonMandatoryRegisters } from "./registers";
-import { TokenAmount } from "./token";
-import { TransactionId } from "./transactions";
-
-export type BoxId = string;
-export type AmountType = string | bigint;
-
-type BoxBaseType<T extends AmountType, R extends NonMandatoryRegisters> = {
-  ergoTree: ErgoTreeHex;
-  creationHeight: number;
-  value: T;
-  assets: TokenAmount<T>[];
-  additionalRegisters: R;
-};
-
-export type BoxCandidate<
-  T extends AmountType,
-  R extends NonMandatoryRegisters = NonMandatoryRegisters
-> = BoxBaseType<T, R> & {
-  boxId?: BoxId;
-};
-
-export type Box<
-  T extends AmountType,
-  R extends NonMandatoryRegisters = NonMandatoryRegisters
-> = BoxBaseType<T, R> & {
-  boxId: BoxId;
-  transactionId: TransactionId;
-  index: number;
-};

package/src/types/common.ts

@@ -1,31 +0,0 @@
-export type HexString = string;
-export type ErgoTreeHex = string;
-export type Base58String = string;
-export type Amount = string | bigint;
-
-export type OneOrMore<T> = T | T[];
-
-export type SortingSelector<T> = (item: T) => string | number | bigint;
-export type SortingDirection = "asc" | "desc";
-
-export type FilterPredicate<T> = (item: T) => boolean;
-
-export type BuildOutputType = "default" | "EIP-12";
-
-export enum Network {
-  Mainnet = 0x00,
-  Testnet = 0x10
-}
-
-export enum AddressType {
-  P2PK = 1,
-  P2SH = 2,
-  P2S = 3
-}
-
-export const ergoTreeHeaderFlags = {
-  sizeInclusion: 0x08,
-  constantSegregation: 0x10
-} as const;
-
-export type ErgoTreeHeaderFlag = (typeof ergoTreeHeaderFlags)[keyof typeof ergoTreeHeaderFlags];

package/src/types/contextExtension.ts

@@ -1,3 +0,0 @@
-import { HexString } from "./common";
-
-export type ContextExtension = { [key: number]: HexString | undefined };

package/src/types/index.ts

@@ -1,9 +0,0 @@
-export * from "./boxes";
-export * from "./contextExtension";
-export * from "./inputs";
-export * from "./common";
-export * from "./proverResult";
-export * from "./registers";
-export * from "./token";
-export * from "./transactions";
-export * from "./block";

package/src/types/inputs.ts

@@ -1,42 +0,0 @@
-import { BoxId } from "./boxes";
-import { ErgoTreeHex } from "./common";
-import { ContextExtension } from "./contextExtension";
-import { ProverResult } from "./proverResult";
-import { NonMandatoryRegisters } from "./registers";
-import { TokenAmount } from "./token";
-import { TransactionId } from "./transactions";
-
-export type SignedInput = {
-  readonly boxId: BoxId;
-  readonly spendingProof: ProverResult;
-};
-
-export type UnsignedInput = {
-  boxId: BoxId;
-  extension: ContextExtension;
-};
-
-export type EIP12UnsignedInput = UnsignedInput & {
-  transactionId: TransactionId;
-  index: number;
-  ergoTree: ErgoTreeHex;
-  creationHeight: number;
-  value: string;
-  assets: TokenAmount<string>[];
-  additionalRegisters: NonMandatoryRegisters;
-};
-
-export type EIP12UnsignedDataInput = {
-  boxId: BoxId;
-  transactionId: TransactionId;
-  index: number;
-  ergoTree: ErgoTreeHex;
-  creationHeight: number;
-  value: string;
-  assets: TokenAmount<string>[];
-  additionalRegisters: NonMandatoryRegisters;
-};
-
-export type DataInput = {
-  boxId: BoxId;
-};

package/src/types/proverResult.ts

@@ -1,7 +0,0 @@
-import { HexString } from "./common";
-import { ContextExtension } from "./contextExtension";
-
-export type ProverResult = {
-  readonly proofBytes: HexString;
-  readonly extension: ContextExtension;
-};

package/src/types/registers.ts

@@ -1,10 +0,0 @@
-import { HexString } from "./common";
-
-export type NonMandatoryRegisters = {
-  R4?: HexString;
-  R5?: HexString;
-  R6?: HexString;
-  R7?: HexString;
-  R8?: HexString;
-  R9?: HexString;
-};

package/src/types/token.ts

@@ -1,21 +0,0 @@
-export type TokenId = string;
-
-type TokenBase<AmountType> = {
-  amount: AmountType;
-};
-
-export type TokenAmount<AmountType> = TokenBase<AmountType> & {
-  tokenId: TokenId;
-};
-
-export type NewToken<AmountType> = TokenBase<AmountType> & {
-  tokenId?: TokenId;
-  name?: string;
-  decimals?: number;
-  description?: string;
-};
-
-export type TokenTargetAmount<AmountType> = {
-  tokenId: TokenId;
-  amount?: AmountType;
-};

package/src/types/transactions.ts

@@ -1,32 +0,0 @@
-import { Box, BoxCandidate } from "./boxes";
-import { Amount } from "./common";
-import {
-  DataInput,
-  EIP12UnsignedDataInput,
-  EIP12UnsignedInput,
-  SignedInput,
-  UnsignedInput
-} from "./inputs";
-
-export type TransactionId = string;
-
-export type UnsignedTransaction = {
-  id?: TransactionId;
-  inputs: UnsignedInput[];
-  dataInputs: DataInput[];
-  outputs: BoxCandidate<Amount>[];
-};
-
-export type EIP12UnsignedTransaction = {
-  id?: TransactionId;
-  inputs: EIP12UnsignedInput[];
-  dataInputs: EIP12UnsignedDataInput[];
-  outputs: BoxCandidate<string>[];
-};
-
-export type SignedTransaction = {
-  readonly id: TransactionId;
-  readonly inputs: SignedInput[];
-  readonly dataInputs: DataInput[];
-  readonly outputs: Box<Amount>[];
-};

package/src/utils/array.ts

@@ -1,196 +0,0 @@
-import { SortingDirection, SortingSelector } from "../types";
-import { assert, isEmpty } from "./assertions";
-
-type ObjectSelector<T> = (item: T) => T[keyof T];
-
-export function first(array: undefined): undefined;
-export function first<T>(array: ArrayLike<T>): T;
-export function first<T>(array: ArrayLike<T> | undefined): T | number | undefined {
-  if (!array) return undefined;
-  assert(array.length > 0, "Empty array.");
-
-  return array[0];
-}
-
-export function last(array: undefined): undefined;
-export function last<T>(array: ArrayLike<T>): T;
-export function last<T>(array: ArrayLike<T> | undefined): T | undefined {
-  if (!array) return undefined;
-  assert(array.length > 0, "Empty array.");
-
-  return at(array, -1);
-}
-
-export function at(array: undefined, index: number): undefined;
-export function at<T>(array: ArrayLike<T>, index: number): T;
-export function at<T>(array: ArrayLike<T> | undefined, index: number): T | undefined {
-  const len = array?.length;
-  if (!len) return undefined;
-
-  if (index < 0) {
-    index += len;
-  }
-
-  return array[index];
-}
-
-/**
- * Check for duplicate elements using the equality operator
- */
-export function hasDuplicates<T>(array: T[]): boolean {
-  return array.some((item, index) => {
-    return array.indexOf(item) !== index;
-  });
-}
-
-/**
- * Check for duplicate keys in complex elements
- */
-export function hasDuplicatesBy<T>(array: T[], selector: ObjectSelector<T>): boolean {
-  return array.some((item, index) => {
-    return array.findIndex((x) => selector(x) === selector(item)) !== index;
-  });
-}
-
-export function chunk<T>(array: T[], size: number): T[][] {
-  if (array.length <= size) {
-    return [array];
-  }
-
-  const chunks: T[][] = [];
-  for (let i = 0; i < array.length; i += size) {
-    chunks.push(array.slice(i, i + size));
-  }
-
-  return chunks;
-}
-
-export function orderBy<T>(
-  array: T[],
-  iteratee: SortingSelector<T>,
-  order: SortingDirection = "asc"
-): T[] {
-  return [...array].sort((a: T, b: T) => {
-    if (iteratee(a) > iteratee(b)) {
-      return order === "asc" ? 1 : -1;
-    } else if (iteratee(a) < iteratee(b)) {
-      return order === "asc" ? -1 : 1;
-    } else {
-      return 0;
-    }
-  });
-}
-
-export function areEqual<T>(array1: ArrayLike<T>, array2: ArrayLike<T>): boolean {
-  if (array1 === array2) {
-    return true;
-  }
-
-  if (array1.length != array2.length) {
-    return false;
-  }
-
-  for (let i = 0; i < array1.length; i++) {
-    if (array1[i] !== array2[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function areEqualBy<T>(
-  array1: ArrayLike<T>,
-  array2: ArrayLike<T>,
-  selector: ObjectSelector<T>
-): boolean {
-  if (array1 === array2) {
-    return true;
-  }
-
-  if (array1.length != array2.length) {
-    return false;
-  }
-
-  for (let i = 0; i < array1.length; i++) {
-    if (selector(array1[i]) !== selector(array2[i])) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function startsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean {
-  if (array === target) {
-    return true;
-  }
-
-  if (target.length > array.length) {
-    return false;
-  }
-
-  for (let i = 0; i < target.length; i++) {
-    if (target[i] !== array[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function endsWith<T>(array: ArrayLike<T>, target: ArrayLike<T>): boolean {
-  if (array === target) {
-    return true;
-  }
-
-  if (target.length > array.length) {
-    return false;
-  }
-
-  const offset = array.length - target.length;
-
-  for (let i = target.length - 1; i >= 0; i--) {
-    if (target[i] !== array[i + offset]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function uniq<T>(array: Array<T>): Array<T> {
-  if (isEmpty(array)) {
-    return array;
-  }
-
-  return Array.from(new Set(array));
-}
-
-export function uniqBy<T>(
-  array: Array<T>,
-  selector: ObjectSelector<T>,
-  selection: "keep-first" | "keep-last" = "keep-first"
-): Array<T> {
-  if (isEmpty(array)) {
-    return array;
-  }
-
-  return Array.from(
-    array
-      .reduce((map, e) => {
-        const key = selector(e);
-
-        if (selection === "keep-first" && map.has(key)) {
-          return map;
-        }
-
-        return map.set(key, e);
-      }, new Map())
-      .values()
-  );
-}
-
-export function depthOf(array: unknown | unknown[]): number {
-  return Array.isArray(array) ? 1 + Math.max(0, ...array.map(depthOf)) : 0;
-}

package/src/utils/assertions.ts

@@ -1,90 +0,0 @@
-export type AssertErrorMessageInput = string | Error | (() => string);
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-type Constructable = Function;
-
-type JSPrimitiveTypes =
-  | "string"
-  | "number"
-  | "bigint"
-  | "boolean"
-  | "symbol"
-  | "undefined"
-  | "object"
-  | "function";
-
-export function assert(condition: boolean, error: AssertErrorMessageInput): asserts condition {
-  if (condition) return;
-
-  let err: Error | undefined = undefined;
-  switch (typeof error) {
-    case "string":
-      err = new Error(error);
-      break;
-    case "function":
-      err = new Error(error());
-      break;
-    default:
-      err = error;
-  }
-
-  throw err;
-}
-
-export function assertTypeOf<T>(obj: T, expected: JSPrimitiveTypes): asserts obj {
-  const type = typeof obj;
-
-  if (type !== expected) {
-    throw new Error(`Expected an object of type '${expected}', got '${type}'.`);
-  }
-}
-
-const toString = (value: unknown) => Object.prototype.toString.call(value);
-function getTypeName(value: unknown): string {
-  if (value === null) return "null";
-  const type = typeof value;
-
-  return type === "object" || type === "function" ? toString(value).slice(8, -1) : type;
-}
-
-export function assertInstanceOf<T>(obj: T, expected: Constructable): asserts obj {
-  const condition = obj instanceof expected;
-
-  if (!condition) {
-    throw new Error(`Expected an instance of '${expected.name}', got '${getTypeName(obj)}'.`);
-  }
-}
-
-export function isEmpty<T extends object>(obj?: T): obj is undefined;
-export function isEmpty<T>(array?: T[]): array is undefined;
-export function isEmpty<T>(obj?: T[] | object): obj is undefined {
-  if (!obj) return true;
-
-  return Array.isArray(obj) ? obj.length === 0 : Object.keys(obj).length === 0;
-}
-
-export function some<T extends object>(obj?: T): obj is T;
-export function some<T>(array?: T[]): array is T[];
-export function some<T>(obj?: T[] | object): boolean {
-  return !isEmpty(obj);
-}
-
-export function isTruthy<T>(value?: T): value is NonNullable<T> {
-  return !!value;
-}
-
-export function isFalsy<T>(value?: T): value is undefined {
-  return !value;
-}
-
-export function isUndefined(v: unknown): v is undefined {
-  return v === undefined || v === null || Number.isNaN(v);
-}
-
-export function isDefined<T>(v: T | undefined): v is T {
-  return !isUndefined(v);
-}
-
-export function hasKey(o: unknown, key: PropertyKey): boolean {
-  return Object.prototype.hasOwnProperty.call(o, key);
-}

package/src/utils/bigInt.ts

@@ -1,186 +0,0 @@
-import { Amount } from "../types";
-import { first } from "./array";
-import { isEmpty, isUndefined } from "./assertions";
-
-type NumberLike = string | number | bigint | boolean;
-
-export const _0n = BigInt(0);
-export const _1n = BigInt(1);
-export const _7n = BigInt(7);
-export const _10n = BigInt(10);
-export const _63n = BigInt(63);
-export const _127n = BigInt(127);
-export const _128n = BigInt(128);
-
-export function ensureBigInt(number: NumberLike): bigint {
-  return typeof number === "bigint" ? number : BigInt(number);
-}
-
-type ParsingOptions = {
-  /**
-   * Number of decimals.
-   */
-  decimals?: number;
-
-  /**
-   * Thousand mark char.
-   * Default: `.`
-   */
-  decimalMark?: string;
-};
-
-export function undecimalize(decimalStr: string, options?: ParsingOptions | number): bigint {
-  if (!decimalStr) {
-    return _0n;
-  }
-
-  options = typeof options == "number" ? { decimals: options } : options;
-  if (isUndefined(options)) {
-    options = {};
-  }
-
-  options.decimals = options.decimals || 0;
-  options.decimalMark = options.decimalMark || ".";
-
-  const fragments = decimalStr.split(options.decimalMark);
-  if (fragments.length > 2) {
-    throw new Error("Invalid numeric string.");
-  }
-
-  let [integer, decimal] = fragments;
-  integer = _removeLeadingZeros(integer);
-  const negative = integer.startsWith("-") ? "-" : "";
-
-  if (!decimal) {
-    decimal = "0".repeat(options.decimals);
-  } else if (decimal.length < options.decimals) {
-    decimal = decimal.padEnd(options.decimals, "0");
-  }
-
-  return BigInt(negative + _stripNonDigits(integer + decimal));
-}
-
-function _stripNonDigits(value: string): string {
-  return value.replace(/\D/g, "");
-}
-
-type FormattingOptions = {
-  /**
-   * Number of decimals.
-   */
-  decimals: number;
-
-  /**
-   * Thousand mark char.
-   */
-  thousandMark?: string;
-
-  /**
-   * Decimal mark char.
-   * Default: `.`
-   */
-  decimalMark?: string;
-};
-
-export function decimalize(value: Amount, options?: FormattingOptions | number): string {
-  value = ensureBigInt(value);
-  if (!options) {
-    return value.toString();
-  }
-
-  options = typeof options == "number" ? { decimals: options } : options;
-  options.decimals = options.decimals || 0;
-  options.decimalMark = options.decimalMark || ".";
-
-  const pow = _10n ** BigInt(options.decimals);
-  const integer = value / pow;
-  const decimal = value - integer * pow;
-
-  return _buildFormattedDecimal(integer.toString(10), decimal.toString(10), options);
-}
-
-export function percent(value: bigint, percentage: bigint, precision = 2n) {
-  return (value * percentage) / 10n ** precision;
-}
-
-function _buildFormattedDecimal(
-  integer: string,
-  decimal: string,
-  options: FormattingOptions
-): string {
-  const integerPart = _addThousandMarks(integer, options.thousandMark);
-  const decimalPart = _stripTrailingZeros(decimal.padStart(options.decimals, "0"));
-
-  if (decimalPart) {
-    return `${integerPart}${options.decimalMark}${decimalPart}`;
-  } else {
-    return integerPart;
-  }
-}
-
-function _addThousandMarks(value: string, mark?: string): string {
-  if (!mark) {
-    return value;
-  }
-
-  return value.replace(/\B(?=(\d{3})+(?!\d))/g, mark);
-}
-
-function _stripTrailingZeros(value: string): string {
-  if (!value.endsWith("0")) {
-    return value;
-  }
-
-  return value.replace(/\.?0+$/, "");
-}
-
-function _removeLeadingZeros(value: string): string {
-  if (!value.startsWith("0")) {
-    return value;
-  }
-
-  return value.replace(/^0+\.?/, "");
-}
-
-export function sumBy<T>(
-  collection: readonly T[],
-  iteratee: (value: T) => bigint,
-  condition?: (value: T) => boolean
-): bigint {
-  let acc = _0n;
-  if (isEmpty(collection)) {
-    return acc;
-  }
-
-  for (const item of collection) {
-    if (isUndefined(condition) || condition(item)) {
-      acc += iteratee(item);
-    }
-  }
-
-  return acc;
-}
-
-export function min<T extends bigint | number>(...numbers: T[]): T {
-  let min = first(numbers);
-
-  for (const num of numbers) {
-    if (num < min) {
-      min = num;
-    }
-  }
-
-  return min;
-}
-
-export function max<T extends bigint | number>(...numbers: T[]): T {
-  let max = first(numbers);
-
-  for (const num of numbers) {
-    if (num > max) {
-      max = num;
-    }
-  }
-
-  return max;
-}

package/src/utils/bytes.bench.ts

@@ -1,43 +0,0 @@
-import { bench, describe } from "vitest";
-import { isHex } from "./bytes";
-
-const HEX_PATTERN = /^[0-9A-Fa-f]+$/s;
-export function isHexRegex(value?: string) {
-  if (!value || value.length % 2) return false;
-
-  return HEX_PATTERN.test(value);
-}
-
-const HEX_CHARSET = new Set("0123456789abcdefABCDEF");
-function isHexChar(value: string) {
-  if (!value || value.length % 2) return false;
-
-  const valueSet = new Set(Array.from(value));
-  for (const c of valueSet) {
-    if (!HEX_CHARSET.has(c)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-describe("Hex string checking", () => {
-  const validHex = "0008cd026dc059d64a50d0dbf07755c2c4a4e557e3df8afa7141868b3ab200643d437ee7";
-  const invalidHex = "0008cd026dc059d64a50d0dbf07755c2c4a4e557e3df8afa7141868b3ab200643d437ee7tt";
-
-  bench("Using charset", () => {
-    isHexChar(validHex);
-    isHexChar(invalidHex);
-  });
-
-  bench("Using regex", () => {
-    isHexRegex(validHex);
-    isHexRegex(invalidHex);
-  });
-
-  bench("Using number constructor", () => {
-    isHex(validHex);
-    isHex(invalidHex);
-  });
-});

package/src/utils/bytes.ts

@@ -1,34 +0,0 @@
-import { assertInstanceOf } from ".";
-
-export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
-  const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-
-  let pad = 0;
-  for (const bytes of arrays) {
-    assertInstanceOf(bytes, Uint8Array);
-
-    r.set(bytes, pad);
-    pad += bytes.length;
-  }
-
-  return r;
-}
-
-export function isHex(value?: string) {
-  if (!value || value.length % 2) return false;
-
-  if (!value.startsWith("0x")) {
-    value = "0x" + value;
-  }
-
-  return !isNaN(Number(value));
-}
-
-/**
- * Get hex string size in bytes
- * @param hex
- * @returns the byte size if the hex string
- */
-export function byteSizeOf(hex: string): number {
-  return hex.length / 2;
-}

package/src/utils/index.ts

@@ -1,6 +0,0 @@
-export * from "./array";
-export * from "./bigInt";
-export * from "./utxo";
-export * from "./object";
-export * from "./assertions";
-export * from "./bytes";

package/src/utils/object.ts

@@ -1,28 +0,0 @@
-import { isEmpty, isUndefined } from "./assertions";
-
-export function clearUndefined(value: Record<string, unknown>) {
-  const result: Record<string, unknown> = {};
-  for (const key in value) {
-    const val = value[key];
-    if (!isUndefined(val)) {
-      result[key] = val;
-    }
-  }
-
-  return result;
-}
-
-export function ensureDefaults<T extends Partial<R>, R extends object = Required<T>>(
-  options: T | undefined,
-  defaults: R
-): R & T {
-  if (isEmpty(options)) return defaults as R & T;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const newObj: any = { ...defaults, ...options };
-  for (const key in newObj) {
-    newObj[key as keyof object] = options[key as keyof R] ?? defaults[key as keyof R];
-  }
-
-  return newObj;
-}

package/src/utils/utxo.ts

@@ -1,183 +0,0 @@
-import {
-  Amount,
-  AmountType,
-  Box,
-  BoxCandidate,
-  NonMandatoryRegisters,
-  TokenAmount,
-  TokenId
-} from "../types";
-import { isDefined, isEmpty, isUndefined } from "./assertions";
-import { ensureBigInt } from "./bigInt";
-import { _0n } from "./bigInt";
-
-const NANOERGS_TOKEN_ID = "nanoErgs";
-
-export function utxoSum(boxes: MinimalBoxAmounts): BoxSummary;
-export function utxoSum(boxes: MinimalBoxAmounts, tokenId: TokenId): bigint;
-export function utxoSum(boxes: MinimalBoxAmounts, tokenId?: TokenId): BoxSummary | bigint {
-  const balances: { [tokenId: string]: bigint } = {};
-
-  for (const box of boxes) {
-    if (isUndefined(tokenId) || tokenId === NANOERGS_TOKEN_ID) {
-      balances[NANOERGS_TOKEN_ID] = (balances[NANOERGS_TOKEN_ID] || _0n) + ensureBigInt(box.value);
-    }
-
-    if (tokenId !== NANOERGS_TOKEN_ID) {
-      for (const token of box.assets) {
-        if (isDefined(tokenId) && tokenId !== token.tokenId) {
-          continue;
-        }
-
-        balances[token.tokenId] = (balances[token.tokenId] || _0n) + ensureBigInt(token.amount);
-      }
-    }
-  }
-
-  if (isDefined(tokenId)) {
-    return balances[tokenId] || _0n;
-  }
-
-  return {
-    nanoErgs: balances[NANOERGS_TOKEN_ID] || _0n,
-    tokens: Object.keys(balances)
-      .filter((x) => x !== NANOERGS_TOKEN_ID)
-      .map((tokenId) => ({ tokenId, amount: balances[tokenId] }))
-  };
-}
-
-export function utxoDiff(
-  minuend: BoxSummary | Box<Amount>[],
-  subtrahend: BoxSummary | Box<Amount>[]
-): BoxSummary {
-  if (Array.isArray(minuend)) {
-    minuend = utxoSum(minuend);
-  }
-
-  if (Array.isArray(subtrahend)) {
-    subtrahend = utxoSum(subtrahend);
-  }
-
-  const tokens: TokenAmount<bigint>[] = [];
-  const nanoErgs = minuend.nanoErgs - subtrahend.nanoErgs;
-
-  for (const token of minuend.tokens) {
-    const balance =
-      token.amount - (subtrahend.tokens.find((t) => t.tokenId === token.tokenId)?.amount || _0n);
-
-    if (balance !== _0n) {
-      tokens.push({ tokenId: token.tokenId, amount: balance });
-    }
-  }
-
-  return { nanoErgs, tokens };
-}
-
-const MIN_NON_MANDATORY_REGISTER_INDEX = 4;
-const MAX_NON_MANDATORY_REGISTER_INDEX = 9;
-
-export function areRegistersDenselyPacked(registers: NonMandatoryRegisters): boolean {
-  let lastIndex = 0;
-  for (let i = MIN_NON_MANDATORY_REGISTER_INDEX; i <= MAX_NON_MANDATORY_REGISTER_INDEX; i++) {
-    const key = `R${i}` as keyof NonMandatoryRegisters;
-    if (registers[key]) {
-      if (i === MIN_NON_MANDATORY_REGISTER_INDEX) {
-        lastIndex = i;
-        continue;
-      }
-
-      if (i - lastIndex > 1) {
-        return false;
-      }
-
-      lastIndex = i;
-    }
-  }
-
-  return true;
-}
-
-export function utxoFilter<T extends AmountType>(
-  utxos: Box<T>[],
-  filterParams: UTxOFilterParams<T>
-) {
-  if (isEmpty(filterParams) || isEmpty(utxos)) {
-    return utxos;
-  }
-
-  const { by, max } = filterParams;
-  let filtered = utxos;
-
-  if (by) {
-    filtered = utxos.filter(by);
-    if (isEmpty(filtered)) {
-      return filtered;
-    }
-  }
-
-  if (!max) {
-    return filtered;
-  }
-
-  if (isDefined(max.aggregatedDistinctTokens)) {
-    const tokenIds = _getDistinctTokenIds(filtered, max.aggregatedDistinctTokens);
-    filtered = filtered.filter(
-      (utxo) => isEmpty(utxo.assets) || utxo.assets.every((token) => tokenIds.has(token.tokenId))
-    );
-  }
-
-  if (isDefined(max.count) && filtered.length > max.count) {
-    filtered = filtered.slice(0, max.count);
-  }
-
-  return filtered;
-}
-
-function _getDistinctTokenIds(utxos: Box<AmountType>[], max: number): Set<string> {
-  const tokenIds = new Set<string>();
-
-  for (let i = 0; i < utxos.length && tokenIds.size < max; i++) {
-    if (isEmpty(utxos[i].assets) || utxos[i].assets.length > max) {
-      continue;
-    }
-
-    for (const token of utxos[i].assets) {
-      tokenIds.add(token.tokenId);
-    }
-  }
-
-  return tokenIds;
-}
-
-export type UTxOFilterParams<T extends AmountType> = {
-  by?: (utxo: Box<T>) => boolean;
-  max?: {
-    count?: number;
-    aggregatedDistinctTokens?: number;
-  };
-};
-
-export type BoxSummary = {
-  nanoErgs: bigint;
-  tokens: TokenAmount<bigint>[];
-};
-
-export type MinimalBoxAmounts = readonly {
-  value: Amount;
-  assets: TokenAmount<Amount>[];
-}[];
-
-export function ensureUTxOBigInt(box: Box<Amount>): Box<bigint>;
-export function ensureUTxOBigInt(candidate: BoxCandidate<Amount>): BoxCandidate<bigint>;
-export function ensureUTxOBigInt(
-  box: Box<Amount> | BoxCandidate<Amount>
-): BoxCandidate<bigint> | Box<bigint> {
-  return {
-    ...box,
-    value: ensureBigInt(box.value),
-    assets: box.assets.map((token) => ({
-      tokenId: token.tokenId,
-      amount: ensureBigInt(token.amount)
-    }))
-  };
-}