@xyo-network/chain-sdk 4.0.4 → 4.0.5

package/dist/neutral/utils.mjs

@@ -0,0 +1,991 @@
+// src/modules/utils/archivist/findFirstMatching.ts
+import { isDefined } from "@ariestools/sdk";
+var DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS = {
+  limit: 100,
+  open: false,
+  order: "desc"
+};
+var findFirstMatching = async (archivist, predicate = () => true, nextOptions = DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS) => {
+  let cursor = isDefined(nextOptions.cursor) ? nextOptions.cursor : void 0;
+  let batch;
+  do {
+    batch = await archivist.next({ ...nextOptions, cursor });
+    if (batch.length === 0) break;
+    const found = batch.find((p) => predicate(p));
+    if (found) return found;
+    const updatedCursor = batch.at(-1)?._sequence;
+    if (isDefined(updatedCursor)) cursor = updatedCursor;
+  } while (batch.length > 0);
+  return void 0;
+};
+
+// src/modules/utils/archivist/payloadsToArchivist.ts
+import { Account, MemoryArchivist } from "@xyo-network/sdk";
+var payloadsToArchivist = async (payloads) => {
+  const archivist = await MemoryArchivist.create({ account: await Account.random() });
+  await archivist.insert(payloads);
+  return archivist;
+};
+
+// src/modules/utils/archivist/synchronizeArchivists.ts
+import { isDefined as isDefined2 } from "@ariestools/sdk";
+var synchronizeArchivists = async (source, destination, sourceCursor, predicate = () => true, filter = () => true) => {
+  const destLast = await findFirstMatching(destination, predicate);
+  const sourceLast = await findFirstMatching(source, predicate);
+  if (!sourceLast) return;
+  if (destLast) {
+    const sourcePayloadResult = await source.get([destLast._hash]);
+    const sourcePayload = sourcePayloadResult.at(0);
+    if (sourcePayload) {
+      sourceCursor = sourcePayload._sequence;
+    } else {
+      throw new Error("Local DB is out of sync with source");
+    }
+  } else {
+    const sourceFirstResult = await source.next({
+      open: false,
+      limit: 1,
+      order: "asc"
+    });
+    const sourceFirst = sourceFirstResult.at(0);
+    if (sourceFirst) {
+      await destination.insert([sourceFirst].filter(filter));
+      sourceCursor = sourceFirst._sequence;
+    } else {
+      return;
+    }
+  }
+  let batch;
+  do {
+    batch = await source.next({
+      open: true,
+      limit: 500,
+      order: "asc",
+      cursor: sourceCursor
+    });
+    if (batch.length === 0) break;
+    const updatedCursor = batch.at(-1)?._sequence;
+    if (isDefined2(updatedCursor)) sourceCursor = updatedCursor;
+    await destination.insert(batch.filter(filter));
+    console.log("syncing batch", sourceCursor, batch.length);
+    console.log("batch sequences", batch.map((b) => b._sequence));
+  } while (batch.length > 0);
+  return sourceCursor;
+};
+
+// src/modules/utils/conversion/units.ts
+import { XL1 } from "@xyo-network/xl1-sdk";
+
+// src/modules/utils/formatters/string/removeTrailingZeros.ts
+var removeTrailingZeros = (value) => {
+  let i = value.length - 1;
+  while (i >= 0 && value[i] === "0") {
+    i--;
+  }
+  return value.slice(0, i + 1);
+};
+
+// src/modules/utils/formatters/string/bigIntToFixedPointString.ts
+var bigIntToFixedPointString = (value, decimalPlaces = 18) => {
+  const stringValue = value.toString(10);
+  const splitAtIndex = (value2, index) => {
+    const part1 = value2.slice(0, index);
+    const part2 = value2.slice(index);
+    return [part1, part2];
+  };
+  const floatable = stringValue.length > decimalPlaces;
+  if (floatable) {
+    const [whole, fraction] = splitAtIndex(stringValue, stringValue.length - decimalPlaces);
+    const cleanedFraction2 = removeTrailingZeros(fraction);
+    return cleanedFraction2.length > 0 ? `${whole}.${cleanedFraction2}` : whole;
+  }
+  if (stringValue === "0") return stringValue;
+  const cleanedFraction = removeTrailingZeros(stringValue);
+  return `0.${"0".repeat(decimalPlaces - stringValue.length)}${cleanedFraction}`;
+};
+
+// src/modules/utils/formatters/string/formatNumber.ts
+var isUnsafeInteger = (value) => {
+  try {
+    const parsedNumber = BigInt(value);
+    return parsedNumber > BigInt(Number.MAX_SAFE_INTEGER);
+  } catch (error) {
+    console.error("Failed to parse number:", error);
+    return true;
+  }
+};
+var safeReturnInteger = (value) => {
+  return isUnsafeInteger(value) ? {
+    unsafeInteger: true,
+    value
+  } : { value };
+};
+function formatNumberForDisplay(value, significantFigures = 5, bigIntShift = 18) {
+  const resolvedValue = typeof value === "bigint" ? bigIntToFixedPointString(value, bigIntShift) : value;
+  const isFloat = resolvedValue.includes(".");
+  if (!isFloat) {
+    return safeReturnInteger(resolvedValue);
+  }
+  const [whole, fraction] = resolvedValue.split(".");
+  if (whole.length >= significantFigures) {
+    return isUnsafeInteger(whole) ? {
+      unsafeInteger: true,
+      value: whole
+    } : { value: whole };
+  }
+  const cleanedFraction = fraction.at(-1) === "0" ? removeTrailingZeros(fraction) : fraction;
+  const safeWholeNumber = whole.length <= significantFigures;
+  const safeFraction = cleanedFraction.length <= significantFigures;
+  if (safeWholeNumber) {
+    if (safeFraction) {
+      const show = significantFigures - whole.length;
+      return { value: `${whole}.${cleanedFraction.slice(0, show)}` };
+    }
+    const leadingZeros = RegExp(/^0+/).exec(cleanedFraction)?.at(0)?.length ?? 0;
+    const significantPart = cleanedFraction.slice(leadingZeros, leadingZeros + significantFigures);
+    return {
+      value: `0.0...${significantPart}`,
+      truncatedFloat: true
+    };
+  }
+  return safeReturnInteger(whole);
+}
+
+// src/modules/utils/conversion/units.ts
+var parseBigIntDecimal = (value, decimal) => {
+  const valueString = typeof value === "number" || typeof value === "bigint" ? value.toString(10) : value;
+  const [intPart, fracPart = "0"] = valueString.split(".");
+  const fracPartLength = Math.min(fracPart.length, decimal);
+  const trimmedFracPart = fracPart.slice(0, fracPartLength);
+  const intPartBigInt = BigInt(Number.parseInt(intPart)) * 10n ** BigInt(decimal);
+  const fracPartBigInt = BigInt(Number.parseInt(trimmedFracPart)) * 10n ** BigInt(decimal - trimmedFracPart.length);
+  const valueBigInt = intPartBigInt + fracPartBigInt;
+  return XL1(valueBigInt);
+};
+var bigIntFormat = (value, decimal) => {
+  const intPart = value / 10n ** BigInt(decimal);
+  const fracPart = value - intPart * 10n ** BigInt(decimal);
+  const fracPartString = fracPart.toString().padStart(decimal, "0");
+  return removeTrailingZeros(`${intPart}.${fracPartString}`);
+};
+var formattedMXL1toXl1 = (value) => {
+  return bigIntFormat(parseBigIntDecimal(value, 12), 18);
+};
+
+// src/modules/utils/hex/hexToLastFourBytesInt.ts
+import { assertEx, isHex } from "@ariestools/sdk";
+function hexToLast4BytesInt(value) {
+  assertEx(isHex(value), () => "value must be a hex string");
+  const last4Bytes = value.slice(-8);
+  return Number.parseInt(last4Bytes, 16);
+}
+
+// src/modules/utils/interval/IntervalMap.ts
+var IntervalMap = class {
+  map;
+  constructor(data) {
+    this.map = /* @__PURE__ */ new Map();
+    if (data) {
+      for (const [key, intervals] of Object.entries(data)) {
+        for (const interval of intervals) {
+          this.insert(key, interval[0], interval[1]);
+        }
+      }
+    }
+  }
+  findAllContaining(point) {
+    const result = [];
+    for (const [address, intervals] of this.map) {
+      if (intervals.some(([start, end]) => start <= point && point <= end)) {
+        result.push(address);
+      }
+    }
+    return result;
+  }
+  get(key) {
+    const intervals = this.map.get(key);
+    return intervals ? Object.freeze(intervals.map((interval) => Object.freeze(interval))) : void 0;
+  }
+  insert(value, start, end) {
+    if (start > end) {
+      throw new Error("Invalid interval: start must be less than or equal to end");
+    }
+    const intervals = this.map.get(value) ?? [];
+    intervals.push([start, end]);
+    const merged = [];
+    for (const [s, e] of intervals) {
+      if (merged.length === 0 || merged[merged.length - 1][1] < s) {
+        merged.push([s, e]);
+      } else {
+        merged[merged.length - 1][1] = merged[merged.length - 1][1] > e ? merged[merged.length - 1][1] : e;
+      }
+    }
+    this.map.set(value, merged);
+  }
+  serialize() {
+    const obj = {};
+    for (const [key, intervals] of this.map) {
+      obj[key] = intervals.map(([start, end]) => [start, end]);
+    }
+    return obj;
+  }
+};
+
+// src/modules/utils/interval/IntervalTree.ts
+import isSame from "shallowequal";
+function max(a, b) {
+  return a > b ? a : b;
+}
+function height(node) {
+  return node === void 0 ? -1 : node.height;
+}
+var Node = class _Node {
+  intervalTree;
+  key;
+  max;
+  records = [];
+  parent;
+  height = 0;
+  left;
+  right;
+  constructor(intervalTree, record) {
+    this.intervalTree = intervalTree;
+    this.key = record.low;
+    this.max = record.high;
+    this.records.push(record);
+  }
+  // Gets the highest record.high value for this node
+  getNodeHigh() {
+    let high = this.records[0].high;
+    for (let i = 1; i < this.records.length; i++) {
+      if (this.records[i].high > high) {
+        high = this.records[i].high;
+      }
+    }
+    return high;
+  }
+  // Updates height value of the node. Called during insertion, rebalance, removal
+  updateHeight() {
+    this.height = max(height(this.left), height(this.right)) + 1;
+  }
+  // Updates the max value of all the parents after inserting into already existing node, as well as
+  // removing the node completely or removing the record of an already existing node. Starts with
+  // the parent of an affected node and bubbles up to root
+  updateMaxOfParents() {
+    if (this === void 0) {
+      return;
+    }
+    const thisHigh = this.getNodeHigh();
+    if (this.left !== void 0 && this.right !== void 0) {
+      this.max = max(max(this.left.max, this.right.max), thisHigh);
+    } else if (this.left !== void 0 && this.right === void 0) {
+      this.max = max(this.left.max, thisHigh);
+    } else if (this.left === void 0 && this.right !== void 0) {
+      this.max = max(this.right.max, thisHigh);
+    } else {
+      this.max = thisHigh;
+    }
+    if (this.parent) {
+      this.parent.updateMaxOfParents();
+    }
+  }
+  /*
+    Left-Left case:
+  
+           z                                      y
+          / \                                   /   \
+         y   T4      Right Rotate (z)          x     z
+        / \          - - - - - - - - ->       / \   / \
+       x   T3                                T1 T2 T3 T4
+      / \
+    T1   T2
+  
+    Left-Right case:
+  
+         z                               z                           x
+        / \                             / \                        /   \
+       y   T4  Left Rotate (y)         x  T4  Right Rotate(z)     y     z
+      / \      - - - - - - - - ->     / \      - - - - - - - ->  / \   / \
+    T1   x                           y  T3                      T1 T2 T3 T4
+        / \                         / \
+      T2   T3                      T1 T2
+    */
+  // Handles Left-Left case and Left-Right case after rebalancing AVL tree
+  _updateMaxAfterRightRotate() {
+    const parent = this.parent;
+    const left = parent.left;
+    const thisParentLeftHigh = left.getNodeHigh();
+    if (left.left === void 0 && left.right !== void 0) {
+      left.max = max(thisParentLeftHigh, left.right.max);
+    } else if (left.left !== void 0 && left.right === void 0) {
+      left.max = max(thisParentLeftHigh, left.left.max);
+    } else if (left.left === void 0 && left.right === void 0) {
+      left.max = thisParentLeftHigh;
+    } else {
+      left.max = max(max(left.left.max, left.right.max), thisParentLeftHigh);
+    }
+    const thisHigh = this.getNodeHigh();
+    if (this.left === void 0 && this.right !== void 0) {
+      this.max = max(thisHigh, this.right.max);
+    } else if (this.left !== void 0 && this.right === void 0) {
+      this.max = max(thisHigh, this.left.max);
+    } else if (this.left === void 0 && this.right === void 0) {
+      this.max = thisHigh;
+    } else {
+      this.max = max(max(this.left.max, this.right.max), thisHigh);
+    }
+    parent.max = max(max(parent.left.max, parent.right.max), parent.getNodeHigh());
+  }
+  /*
+    Right-Right case:
+  
+      z                               y
+     / \                            /   \
+    T1  y     Left Rotate(z)       z     x
+       / \   - - - - - - - ->     / \   / \
+      T2  x                      T1 T2 T3 T4
+         / \
+        T3 T4
+  
+    Right-Left case:
+  
+       z                            z                            x
+      / \                          / \                         /   \
+     T1  y   Right Rotate (y)     T1  x      Left Rotate(z)   z     y
+        / \  - - - - - - - - ->      / \   - - - - - - - ->  / \   / \
+       x  T4                        T2  y                   T1 T2 T3 T4
+      / \                              / \
+    T2   T3                           T3 T4
+    */
+  // Handles Right-Right case and Right-Left case in rebalancing AVL tree
+  _updateMaxAfterLeftRotate() {
+    const parent = this.parent;
+    const right = parent.right;
+    const thisParentRightHigh = right.getNodeHigh();
+    if (right.left === void 0 && right.right !== void 0) {
+      right.max = max(thisParentRightHigh, right.right.max);
+    } else if (right.left !== void 0 && right.right === void 0) {
+      right.max = max(thisParentRightHigh, right.left.max);
+    } else if (right.left === void 0 && right.right === void 0) {
+      right.max = thisParentRightHigh;
+    } else {
+      right.max = max(max(right.left.max, right.right.max), thisParentRightHigh);
+    }
+    const thisHigh = this.getNodeHigh();
+    if (this.left === void 0 && this.right !== void 0) {
+      this.max = max(thisHigh, this.right.max);
+    } else if (this.left !== void 0 && this.right === void 0) {
+      this.max = max(thisHigh, this.left.max);
+    } else if (this.left === void 0 && this.right === void 0) {
+      this.max = thisHigh;
+    } else {
+      this.max = max(max(this.left.max, this.right.max), thisHigh);
+    }
+    parent.max = max(max(parent.left.max, right.max), parent.getNodeHigh());
+  }
+  _leftRotate() {
+    const rightChild = this.right;
+    rightChild.parent = this.parent;
+    if (rightChild.parent === void 0) {
+      this.intervalTree.root = rightChild;
+    } else {
+      if (rightChild.parent.left === this) {
+        rightChild.parent.left = rightChild;
+      } else if (rightChild.parent.right === this) {
+        rightChild.parent.right = rightChild;
+      }
+    }
+    this.right = rightChild.left;
+    if (this.right !== void 0) {
+      this.right.parent = this;
+    }
+    rightChild.left = this;
+    this.parent = rightChild;
+    this.updateHeight();
+    rightChild.updateHeight();
+  }
+  _rightRotate() {
+    const leftChild = this.left;
+    leftChild.parent = this.parent;
+    if (leftChild.parent === void 0) {
+      this.intervalTree.root = leftChild;
+    } else {
+      if (leftChild.parent.left === this) {
+        leftChild.parent.left = leftChild;
+      } else if (leftChild.parent.right === this) {
+        leftChild.parent.right = leftChild;
+      }
+    }
+    this.left = leftChild.right;
+    if (this.left !== void 0) {
+      this.left.parent = this;
+    }
+    leftChild.right = this;
+    this.parent = leftChild;
+    this.updateHeight();
+    leftChild.updateHeight();
+  }
+  // Rebalances the tree if the height value between two nodes of the same parent is greater than
+  // two. There are 4 cases that can happen which are outlined in the graphics above
+  _rebalance() {
+    if (height(this.left) >= 2 + height(this.right)) {
+      const left = this.left;
+      if (height(left.left) >= height(left.right)) {
+        this._rightRotate();
+        this._updateMaxAfterRightRotate();
+      } else {
+        left._leftRotate();
+        this._rightRotate();
+        this._updateMaxAfterRightRotate();
+      }
+    } else if (height(this.right) >= 2 + height(this.left)) {
+      const right = this.right;
+      if (height(right.right) >= height(right.left)) {
+        this._leftRotate();
+        this._updateMaxAfterLeftRotate();
+      } else {
+        right._rightRotate();
+        this._leftRotate();
+        this._updateMaxAfterLeftRotate();
+      }
+    }
+  }
+  insert(record) {
+    if (record.low < this.key) {
+      if (this.left === void 0) {
+        this.left = new _Node(this.intervalTree, record);
+        this.left.parent = this;
+      } else {
+        this.left.insert(record);
+      }
+    } else {
+      if (this.right === void 0) {
+        this.right = new _Node(this.intervalTree, record);
+        this.right.parent = this;
+      } else {
+        this.right.insert(record);
+      }
+    }
+    if (this.max < record.high) {
+      this.max = record.high;
+    }
+    this.updateHeight();
+    this._rebalance();
+  }
+  _getOverlappingRecords(currentNode, low, high) {
+    if (currentNode.key <= high && low <= currentNode.getNodeHigh()) {
+      const tempResults = [];
+      for (const record of currentNode.records) {
+        if (record.high >= low) {
+          tempResults.push(record);
+        }
+      }
+      return tempResults;
+    }
+    return [];
+  }
+  search(low, high) {
+    if (this === void 0) {
+      return [];
+    }
+    if (low > this.max) {
+      return [];
+    }
+    let leftSearch = [];
+    let rightSearch = [];
+    if (this.left !== void 0 && this.left.max >= low) {
+      leftSearch = this.left.search(low, high);
+    }
+    const ownSearch = this._getOverlappingRecords(this, low, high);
+    if (high < this.key) {
+      return [...leftSearch, ...ownSearch];
+    }
+    if (this.right !== void 0) {
+      rightSearch = this.right.search(low, high);
+    }
+    return [...leftSearch, ...ownSearch, ...rightSearch];
+  }
+  // Searches for a node by a `key` value
+  searchExisting(low) {
+    if (this === void 0) {
+      return void 0;
+    }
+    if (this.key === low) {
+      return this;
+    }
+    if (low < this.key) {
+      if (this.left !== void 0) {
+        return this.left.searchExisting(low);
+      }
+    } else {
+      if (this.right !== void 0) {
+        return this.right.searchExisting(low);
+      }
+    }
+    return void 0;
+  }
+  // Returns the smallest node of the subtree
+  _minValue() {
+    return this.left === void 0 ? this : this.left._minValue();
+  }
+  remove(node) {
+    if (node.key < this.key) {
+      return this.left === void 0 ? void 0 : this.left.remove(node);
+    }
+    if (node.key > this.key) {
+      return this.right === void 0 ? void 0 : this.right.remove(node);
+    }
+    if (this.left !== void 0 && this.right !== void 0) {
+      const minValue = this.right._minValue();
+      this.key = minValue.key;
+      this.records = minValue.records;
+      return this.right.remove(this);
+    }
+    const parent = this.parent;
+    if (parent.left === this) {
+      if (this.right === void 0) {
+        parent.left = this.left;
+        if (this.left !== void 0) {
+          this.left.parent = parent;
+        }
+      } else {
+        parent.left = this.right;
+        this.right.parent = parent;
+      }
+      parent.updateMaxOfParents();
+      parent.updateHeight();
+      parent._rebalance();
+      return this;
+    }
+    if (parent.right === this) {
+      if (this.right === void 0) {
+        parent.right = this.left;
+        if (this.left !== void 0) {
+          this.left.parent = parent;
+        }
+      } else {
+        parent.right = this.right;
+        this.right.parent = parent;
+      }
+      parent.updateMaxOfParents();
+      parent.updateHeight();
+      parent._rebalance();
+      return this;
+    }
+    return void 0;
+  }
+};
+var IntervalTree = class {
+  root;
+  count = 0;
+  insert(record) {
+    if (record.low > record.high) {
+      throw new Error("`low` value must be lower or equal to `high` value");
+    }
+    if (this.root === void 0) {
+      this.root = new Node(this, record);
+      this.count++;
+      return true;
+    }
+    const node = this.root.searchExisting(record.low);
+    if (node === void 0) {
+      this.root.insert(record);
+      this.count++;
+      return true;
+    }
+    for (const existing of node.records) {
+      if (isSame(existing, record)) {
+        return false;
+      }
+    }
+    node.records.push(record);
+    if (record.high > node.max) {
+      node.max = record.high;
+      if (node.parent) {
+        node.parent.updateMaxOfParents();
+      }
+    }
+    this.count++;
+    return true;
+  }
+  search(low, high) {
+    return this.root === void 0 ? [] : this.root.search(low, high);
+  }
+  remove(record) {
+    if (this.root === void 0) {
+      return false;
+    }
+    const node = this.root.searchExisting(record.low);
+    if (node === void 0) {
+      return false;
+    }
+    if (node.records.length > 1) {
+      const removedIndex = node.records.findIndex((r) => isSame(r, record));
+      if (removedIndex === -1) {
+        return false;
+      }
+      node.records.splice(removedIndex, 1);
+      if (record.high === node.max) {
+        const nodeHigh = node.getNodeHigh();
+        if (node.left !== void 0 && node.right !== void 0) {
+          node.max = max(max(node.left.max, node.right.max), nodeHigh);
+        } else if (node.left !== void 0 && node.right === void 0) {
+          node.max = max(node.left.max, nodeHigh);
+        } else if (node.left === void 0 && node.right !== void 0) {
+          node.max = max(node.right.max, nodeHigh);
+        } else {
+          node.max = nodeHigh;
+        }
+        if (node.parent) {
+          node.parent.updateMaxOfParents();
+        }
+      }
+      this.count--;
+      return true;
+    }
+    if (node.records.length === 1) {
+      if (isSame(node.records[0], record)) {
+        if (this.root.key === node.key) {
+          const rootParent = new Node(this, { low: record.low, high: record.low });
+          rootParent.left = this.root;
+          this.root.parent = rootParent;
+          const removedNode2 = this.root.remove(node);
+          this.root = rootParent.left;
+          if (this.root !== void 0) {
+            this.root.parent = void 0;
+          }
+          if (removedNode2) {
+            this.count--;
+            return true;
+          }
+          return false;
+        }
+        const removedNode = this.root.remove(node);
+        if (removedNode) {
+          this.count--;
+          return true;
+        }
+        return false;
+      }
+      return false;
+    }
+    return false;
+  }
+  inOrder() {
+    return new InOrder(this.root);
+  }
+  reverseInOrder() {
+    return new ReverseInOrder(this.root);
+  }
+  preOrder() {
+    return new PreOrder(this.root);
+  }
+};
+var DataIntervalTree = class {
+  tree = new IntervalTree();
+  insert(low, high, data) {
+    return this.tree.insert({
+      low,
+      high,
+      data
+    });
+  }
+  remove(low, high, data) {
+    return this.tree.remove({
+      low,
+      high,
+      data
+    });
+  }
+  search(low, high) {
+    return this.tree.search(low, high).map((v) => v.data);
+  }
+  inOrder() {
+    return this.tree.inOrder();
+  }
+  reverseInOrder() {
+    return this.tree.reverseInOrder();
+  }
+  preOrder() {
+    return this.tree.preOrder();
+  }
+  get count() {
+    return this.tree.count;
+  }
+};
+var TreeOrderIterator = class {
+  stack = [];
+  currentNode;
+  i;
+  constructor(startNode) {
+    if (startNode !== void 0) {
+      this.initialize(startNode);
+    }
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+};
+var InOrder = class extends TreeOrderIterator {
+  initialize(node) {
+    this.push(node);
+  }
+  next() {
+    if (this.currentNode === void 0) {
+      return {
+        done: true,
+        value: void 0
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      };
+    }
+    if (this.i !== void 0 && this.i < this.currentNode.records.length) {
+      return {
+        done: false,
+        value: this.currentNode.records[this.i++]
+      };
+    }
+    if (this.currentNode.right === void 0) {
+      this.pop();
+    } else {
+      this.push(this.currentNode.right);
+    }
+    return this.next();
+  }
+  push(node) {
+    this.currentNode = node;
+    this.i = 0;
+    while (this.currentNode.left !== void 0) {
+      this.stack.push(this.currentNode);
+      this.currentNode = this.currentNode.left;
+    }
+  }
+  pop() {
+    this.currentNode = this.stack.pop();
+    this.i = 0;
+  }
+};
+var ReverseInOrder = class extends TreeOrderIterator {
+  initialize(node) {
+    this.push(node);
+  }
+  next() {
+    if (this.currentNode === void 0) {
+      return {
+        done: true,
+        value: void 0
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      };
+    }
+    if (this.currentNode.records.length > 0 && this.i !== void 0 && this.i >= 0) {
+      return {
+        done: false,
+        value: this.currentNode.records[this.i--]
+      };
+    }
+    if (this.currentNode.left === void 0) {
+      this.pop();
+    } else {
+      this.push(this.currentNode.left);
+    }
+    return this.next();
+  }
+  push(node) {
+    this.currentNode = node;
+    this.i = (this.currentNode?.records.length ?? 0) - 1;
+    while (this.currentNode.right !== void 0) {
+      this.stack.push(this.currentNode);
+      this.currentNode = this.currentNode.right;
+      this.i = (this.currentNode?.records.length ?? 0) - 1;
+    }
+  }
+  pop() {
+    this.currentNode = this.stack.pop();
+    this.i = (this.currentNode?.records.length ?? 0) - 1;
+  }
+};
+var PreOrder = class {
+  stack = [];
+  currentNode;
+  i = 0;
+  constructor(startNode) {
+    this.currentNode = startNode;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    if (this.currentNode === void 0) {
+      return {
+        done: true,
+        value: void 0
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      };
+    }
+    if (this.i < this.currentNode.records.length) {
+      return {
+        done: false,
+        value: this.currentNode.records[this.i++]
+      };
+    }
+    if (this.currentNode.right !== void 0) {
+      this.push(this.currentNode.right);
+    }
+    if (this.currentNode.left !== void 0) {
+      this.push(this.currentNode.left);
+    }
+    this.pop();
+    return this.next();
+  }
+  push(node) {
+    this.stack.push(node);
+  }
+  pop() {
+    this.currentNode = this.stack.pop();
+    this.i = 0;
+  }
+};
+
+// src/modules/utils/random/shuffleWithSeed.ts
+function seededRandom(seed) {
+  return function() {
+    const x = Math.sin(seed++) * 1e4;
+    return x - Math.floor(x);
+  };
+}
+function shuffleWithSeed(set, seed) {
+  const array = [...set].toSorted((a, b) => String(a).localeCompare(String(b)));
+  const random = seededRandom(seed);
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(random() * (i + 1));
+    const swap = array[i];
+    array[i] = array[j];
+    array[j] = swap;
+  }
+  return array;
+}
+
+// src/modules/utils/steps/calculator/window/stepWindowCalculatorFromBlock.ts
+import { asXL1BlockNumber, StepSizes } from "@xyo-network/xl1-sdk";
+var stepWindowCalculatorFromBlock = (blockNumber) => {
+  if (blockNumber < StepSizes[0]) {
+    return [0, StepSizes[0] - 1];
+  }
+  let lower = 0;
+  for (let i = 0; i < StepSizes.length; i++) {
+    const stepSize = StepSizes[i];
+    let nextStep = StepSizes[i + 1];
+    if (i > 0) lower = stepSize;
+    if (i === StepSizes.length - 1) {
+      nextStep = asXL1BlockNumber(stepSize * 2, { name: "stepWindowCalculatorFromBlock A" });
+      while (blockNumber >= nextStep) {
+        nextStep = asXL1BlockNumber(nextStep + stepSize, { name: "stepWindowCalculatorFromBlock B" });
+      }
+    }
+    if (blockNumber >= stepSize && blockNumber <= nextStep) {
+      for (let lowerBound = lower; lowerBound < nextStep; lowerBound += stepSize) {
+        const upperBound = lowerBound + stepSize - 1;
+        if (blockNumber >= lowerBound && blockNumber <= upperBound) {
+          return [lowerBound, upperBound];
+        }
+      }
+    }
+  }
+  throw new Error(`No valid window could be calculated for Block number ${blockNumber}.`);
+};
+
+// src/modules/utils/telemetry/startupSpanAsync.ts
+async function startupSpanAsync(name, fn, logger) {
+  const start = Date.now();
+  try {
+    logger?.log(`[${name}] Initializing`);
+    const result = await fn();
+    return result;
+  } finally {
+    const stop = Date.now();
+    const duration = stop - start;
+    logger?.log(`[${name}] Initialized (${duration}ms)`);
+  }
+}
+
+// src/modules/utils/telemetry/XyoConsoleSpanExporter.ts
+import { ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
+import chalk from "chalk";
+function spanDurationInMillis(span) {
+  return span.duration[0] * 1e3 + span.duration[1] / 1e6;
+}
+var XyoConsoleSpanExporter = class _XyoConsoleSpanExporter extends ConsoleSpanExporter {
+  static durationToLogLevel = [
+    0,
+    1,
+    10,
+    100,
+    1e3
+  ];
+  static logLevelToChalkColor = [
+    chalk.grey,
+    chalk.white,
+    chalk.green,
+    chalk.yellow,
+    chalk.red
+  ];
+  _logLevel;
+  constructor(logLevel = 0) {
+    super();
+    this._logLevel = logLevel;
+  }
+  get logLevel() {
+    return this._logLevel;
+  }
+  export(spans) {
+    for (const span of spans) {
+      const spanLevel = this.spanLevel(span);
+      if (spanLevel < this.logLevel) {
+        continue;
+      }
+      const duration = spanDurationInMillis(span);
+      console.log(chalk.grey([
+        `Span [${span.name}]`,
+        this.logColor(spanLevel)(`${duration}ms`),
+        `TraceId: ${span.spanContext().traceId}`
+      ].join(", ")));
+    }
+  }
+  logColor(level) {
+    return _XyoConsoleSpanExporter.logLevelToChalkColor[level] ?? chalk.magenta;
+  }
+  spanLevel(span) {
+    let logLevel = 0;
+    const duration = spanDurationInMillis(span);
+    for (let x = _XyoConsoleSpanExporter.durationToLogLevel.length - 1; x >= 0; x--) {
+      if (duration > _XyoConsoleSpanExporter.durationToLogLevel[x]) {
+        logLevel = x;
+        break;
+      }
+    }
+    return logLevel;
+  }
+};
+export {
+  DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS,
+  DataIntervalTree,
+  InOrder,
+  IntervalMap,
+  IntervalTree,
+  Node,
+  PreOrder,
+  ReverseInOrder,
+  XyoConsoleSpanExporter,
+  bigIntToFixedPointString,
+  findFirstMatching,
+  formatNumberForDisplay,
+  formattedMXL1toXl1,
+  hexToLast4BytesInt,
+  payloadsToArchivist,
+  removeTrailingZeros,
+  shuffleWithSeed,
+  spanDurationInMillis,
+  startupSpanAsync,
+  stepWindowCalculatorFromBlock,
+  synchronizeArchivists
+};
+//# sourceMappingURL=utils.mjs.map