@session-foundation/swarm-routing 0.0.1

package/.dependency-cruiser.cjs

@@ -0,0 +1,6 @@
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-require-imports */
+const {
+  extendShared,
+} = require('@session-foundation/dep-cruiser-config-shared');
+module.exports = extendShared();

package/.turbo/turbo-build.log

@@ -0,0 +1,20 @@
+
+
+> @session-foundation/swarm-routing@0.0.1 build /home/audric/pro/contribs/session-pkgs/packages/swarm-routing
+> tsup src/index.ts --format cjs,esm --dts --tsconfig tsconfig.build.json
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.build.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/audric/pro/contribs/session-pkgs/packages/swarm-routing/tsup.config.ts
+CLI Target: esnext
+CJS Build start
+ESM Build start
+ESM dist/index.mjs 4.05 KB
+ESM ⚡️ Build success in 47ms
+CJS dist/index.cjs 5.08 KB
+CJS ⚡️ Build success in 50ms
+DTS Build start
+DTS ⚡️ Build success in 834ms
+DTS dist/index.d.ts  1.55 KB
+DTS dist/index.d.mts 1.55 KB

package/.turbo/turbo-lint.log

@@ -0,0 +1,8 @@
+
+
+> @session-foundation/swarm-routing@0.0.1 lint /home/audric/pro/contribs/session-pkgs/packages/swarm-routing
+> eslint . --max-warnings 0 && dependency-cruiser --config .dependency-cruiser.cjs .
+
+
+✔ no dependency violations found (21 modules, 21 dependencies cruised)
+

package/dist/index.cjs

@@ -0,0 +1,139 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Swarm: () => Swarm
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/swarm_routing.ts
+var import_basic_types = require("@session-foundation/basic-types");
+var Swarm = class _Swarm {
+  hi;
+  // upper 32 bits, unsigned
+  lo;
+  // lower 32 bits, unsigned
+  constructor(hi, lo) {
+    this.hi = hi >>> 0;
+    this.lo = lo >>> 0;
+  }
+  /** Build from 8 big-endian bytes (output of the XOR reduction step). */
+  static fromBytes(bytes) {
+    const hi = (bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3]) >>> 0;
+    const lo = (bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7]) >>> 0;
+    return new _Swarm(hi, lo);
+  }
+  /** Parse a hex string (with or without 0x prefix, any length up to 16 chars). */
+  static fromHex(hex) {
+    const clean = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+    const padded = clean.padStart(16, "0");
+    const hi = parseInt(padded.slice(0, 8), 16);
+    const lo = parseInt(padded.slice(8), 16);
+    return new _Swarm(hi, lo);
+  }
+  // ── Comparisons ────────────────────────────────────────────────────────────
+  /** -1 if this < other, 0 if equal, 1 if this > other (unsigned 64-bit). */
+  compareTo(other) {
+    if (this.hi !== other.hi) return this.hi < other.hi ? -1 : 1;
+    if (this.lo !== other.lo) return this.lo < other.lo ? -1 : 1;
+    return 0;
+  }
+  isLessThan(other) {
+    return this.compareTo(other) < 0;
+  }
+  equals(other) {
+    return this.hi === other.hi && this.lo === other.lo;
+  }
+  // ── Arithmetic ─────────────────────────────────────────────────────────────
+  /** Unsigned 64-bit subtraction with wraparound (mod 2^64). */
+  subtract(other) {
+    const lo = this.lo - other.lo >>> 0;
+    const borrow = this.lo < other.lo ? 1 : 0;
+    const hi = this.hi - other.hi - borrow >>> 0;
+    return new _Swarm(hi, lo);
+  }
+  // ── Serialisation ──────────────────────────────────────────────────────────
+  /** 16-character zero-padded lowercase hex string. */
+  toString() {
+    return this.hi.toString(16).padStart(8, "0") + this.lo.toString(16).padStart(8, "0");
+  }
+  toJSON() {
+    return this.toString();
+  }
+  // ── Routing ────────────────────────────────────────────────────────────────
+  /**
+   * XOR the four 8-byte chunks of a 32-byte x25519 pubkey, then interpret
+   * the result as a big-endian uint64.  Equivalent of C++ pubkey_to_swarm_space.
+   */
+  static pubkeyToSwarmSpace(pk) {
+    const xored = new Uint8Array(8);
+    for (let i = 0; i < 4; i++)
+      for (let j = 0; j < 8; j++) xored[j] ^= pk[i * 8 + j];
+    return _Swarm.fromBytes(xored);
+  }
+  /**
+   * Group nodes by swarm and return them sorted by swarm ID ascending.
+   * Equivalent of C++ generate_swarms.
+   */
+  static generateSwarms(nodes) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      const bucket = grouped.get(node.swarm) ?? [];
+      bucket.push(node);
+      grouped.set(node.swarm, bucket);
+    }
+    const result = [];
+    for (const [swarmHex, members] of grouped)
+      result.push([_Swarm.fromHex(swarmHex), members]);
+    result.sort((a, b) => a[0].compareTo(b[0]));
+    return result;
+  }
+  /**
+   * Find the swarm closest to the given x25519 pubkey using circular uint64
+   * distance. Equivalent of C++ get_swarm.
+   */
+  static getFor(swarmPubkeyHex, allSwarms) {
+    if (allSwarms.length === 0) {
+      throw new Error("No swarms found: allSwarms.length === 0");
+    }
+    if (allSwarms.length === 1) {
+      return allSwarms[0];
+    }
+    const pkNoPrefix = swarmPubkeyHex.length === 66 ? swarmPubkeyHex.slice(2) : swarmPubkeyHex;
+    const pk = (0, import_basic_types.fromHex)((0, import_basic_types.createHexString)(pkNoPrefix));
+    const swarmId = _Swarm.pubkeyToSwarmSpace(pk);
+    let lo = 0, hi = allSwarms.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (allSwarms[mid][0].isLessThan(swarmId)) lo = mid + 1;
+      else hi = mid;
+    }
+    const rightIdx = lo === allSwarms.length ? 0 : lo;
+    const leftIdx = rightIdx === 0 ? allSwarms.length - 1 : rightIdx - 1;
+    const dright = allSwarms[rightIdx][0].subtract(swarmId);
+    const dleft = swarmId.subtract(allSwarms[leftIdx][0]);
+    return dright.isLessThan(dleft) ? allSwarms[rightIdx] : allSwarms[leftIdx];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Swarm
+});

package/dist/index.d.mts

@@ -0,0 +1,40 @@
+import { WithSwarmStr } from '@session-foundation/basic-types';
+
+type WithSwarm = {
+    swarm: Swarm;
+};
+declare class Swarm {
+    private readonly hi;
+    private readonly lo;
+    private constructor();
+    /** Build from 8 big-endian bytes (output of the XOR reduction step). */
+    static fromBytes(bytes: Uint8Array): Swarm;
+    /** Parse a hex string (with or without 0x prefix, any length up to 16 chars). */
+    static fromHex(hex: string): Swarm;
+    /** -1 if this < other, 0 if equal, 1 if this > other (unsigned 64-bit). */
+    compareTo(other: Swarm): number;
+    isLessThan(other: Swarm): boolean;
+    equals(other: Swarm): boolean;
+    /** Unsigned 64-bit subtraction with wraparound (mod 2^64). */
+    subtract(other: Swarm): Swarm;
+    /** 16-character zero-padded lowercase hex string. */
+    toString(): string;
+    toJSON(): string;
+    /**
+     * XOR the four 8-byte chunks of a 32-byte x25519 pubkey, then interpret
+     * the result as a big-endian uint64.  Equivalent of C++ pubkey_to_swarm_space.
+     */
+    static pubkeyToSwarmSpace(pk: Uint8Array): Swarm;
+    /**
+     * Group nodes by swarm and return them sorted by swarm ID ascending.
+     * Equivalent of C++ generate_swarms.
+     */
+    static generateSwarms<T extends WithSwarmStr>(nodes: T[]): Array<[Swarm, T[]]>;
+    /**
+     * Find the swarm closest to the given x25519 pubkey using circular uint64
+     * distance. Equivalent of C++ get_swarm.
+     */
+    static getFor<T extends WithSwarmStr>(swarmPubkeyHex: string, allSwarms: Array<[Swarm, T[]]>): [Swarm, T[]];
+}
+
+export { Swarm, type WithSwarm };

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import { WithSwarmStr } from '@session-foundation/basic-types';
+
+type WithSwarm = {
+    swarm: Swarm;
+};
+declare class Swarm {
+    private readonly hi;
+    private readonly lo;
+    private constructor();
+    /** Build from 8 big-endian bytes (output of the XOR reduction step). */
+    static fromBytes(bytes: Uint8Array): Swarm;
+    /** Parse a hex string (with or without 0x prefix, any length up to 16 chars). */
+    static fromHex(hex: string): Swarm;
+    /** -1 if this < other, 0 if equal, 1 if this > other (unsigned 64-bit). */
+    compareTo(other: Swarm): number;
+    isLessThan(other: Swarm): boolean;
+    equals(other: Swarm): boolean;
+    /** Unsigned 64-bit subtraction with wraparound (mod 2^64). */
+    subtract(other: Swarm): Swarm;
+    /** 16-character zero-padded lowercase hex string. */
+    toString(): string;
+    toJSON(): string;
+    /**
+     * XOR the four 8-byte chunks of a 32-byte x25519 pubkey, then interpret
+     * the result as a big-endian uint64.  Equivalent of C++ pubkey_to_swarm_space.
+     */
+    static pubkeyToSwarmSpace(pk: Uint8Array): Swarm;
+    /**
+     * Group nodes by swarm and return them sorted by swarm ID ascending.
+     * Equivalent of C++ generate_swarms.
+     */
+    static generateSwarms<T extends WithSwarmStr>(nodes: T[]): Array<[Swarm, T[]]>;
+    /**
+     * Find the swarm closest to the given x25519 pubkey using circular uint64
+     * distance. Equivalent of C++ get_swarm.
+     */
+    static getFor<T extends WithSwarmStr>(swarmPubkeyHex: string, allSwarms: Array<[Swarm, T[]]>): [Swarm, T[]];
+}
+
+export { Swarm, type WithSwarm };

package/dist/index.mjs

@@ -0,0 +1,112 @@
+// src/swarm_routing.ts
+import { createHexString, fromHex } from "@session-foundation/basic-types";
+var Swarm = class _Swarm {
+  hi;
+  // upper 32 bits, unsigned
+  lo;
+  // lower 32 bits, unsigned
+  constructor(hi, lo) {
+    this.hi = hi >>> 0;
+    this.lo = lo >>> 0;
+  }
+  /** Build from 8 big-endian bytes (output of the XOR reduction step). */
+  static fromBytes(bytes) {
+    const hi = (bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3]) >>> 0;
+    const lo = (bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7]) >>> 0;
+    return new _Swarm(hi, lo);
+  }
+  /** Parse a hex string (with or without 0x prefix, any length up to 16 chars). */
+  static fromHex(hex) {
+    const clean = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+    const padded = clean.padStart(16, "0");
+    const hi = parseInt(padded.slice(0, 8), 16);
+    const lo = parseInt(padded.slice(8), 16);
+    return new _Swarm(hi, lo);
+  }
+  // ── Comparisons ────────────────────────────────────────────────────────────
+  /** -1 if this < other, 0 if equal, 1 if this > other (unsigned 64-bit). */
+  compareTo(other) {
+    if (this.hi !== other.hi) return this.hi < other.hi ? -1 : 1;
+    if (this.lo !== other.lo) return this.lo < other.lo ? -1 : 1;
+    return 0;
+  }
+  isLessThan(other) {
+    return this.compareTo(other) < 0;
+  }
+  equals(other) {
+    return this.hi === other.hi && this.lo === other.lo;
+  }
+  // ── Arithmetic ─────────────────────────────────────────────────────────────
+  /** Unsigned 64-bit subtraction with wraparound (mod 2^64). */
+  subtract(other) {
+    const lo = this.lo - other.lo >>> 0;
+    const borrow = this.lo < other.lo ? 1 : 0;
+    const hi = this.hi - other.hi - borrow >>> 0;
+    return new _Swarm(hi, lo);
+  }
+  // ── Serialisation ──────────────────────────────────────────────────────────
+  /** 16-character zero-padded lowercase hex string. */
+  toString() {
+    return this.hi.toString(16).padStart(8, "0") + this.lo.toString(16).padStart(8, "0");
+  }
+  toJSON() {
+    return this.toString();
+  }
+  // ── Routing ────────────────────────────────────────────────────────────────
+  /**
+   * XOR the four 8-byte chunks of a 32-byte x25519 pubkey, then interpret
+   * the result as a big-endian uint64.  Equivalent of C++ pubkey_to_swarm_space.
+   */
+  static pubkeyToSwarmSpace(pk) {
+    const xored = new Uint8Array(8);
+    for (let i = 0; i < 4; i++)
+      for (let j = 0; j < 8; j++) xored[j] ^= pk[i * 8 + j];
+    return _Swarm.fromBytes(xored);
+  }
+  /**
+   * Group nodes by swarm and return them sorted by swarm ID ascending.
+   * Equivalent of C++ generate_swarms.
+   */
+  static generateSwarms(nodes) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      const bucket = grouped.get(node.swarm) ?? [];
+      bucket.push(node);
+      grouped.set(node.swarm, bucket);
+    }
+    const result = [];
+    for (const [swarmHex, members] of grouped)
+      result.push([_Swarm.fromHex(swarmHex), members]);
+    result.sort((a, b) => a[0].compareTo(b[0]));
+    return result;
+  }
+  /**
+   * Find the swarm closest to the given x25519 pubkey using circular uint64
+   * distance. Equivalent of C++ get_swarm.
+   */
+  static getFor(swarmPubkeyHex, allSwarms) {
+    if (allSwarms.length === 0) {
+      throw new Error("No swarms found: allSwarms.length === 0");
+    }
+    if (allSwarms.length === 1) {
+      return allSwarms[0];
+    }
+    const pkNoPrefix = swarmPubkeyHex.length === 66 ? swarmPubkeyHex.slice(2) : swarmPubkeyHex;
+    const pk = fromHex(createHexString(pkNoPrefix));
+    const swarmId = _Swarm.pubkeyToSwarmSpace(pk);
+    let lo = 0, hi = allSwarms.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (allSwarms[mid][0].isLessThan(swarmId)) lo = mid + 1;
+      else hi = mid;
+    }
+    const rightIdx = lo === allSwarms.length ? 0 : lo;
+    const leftIdx = rightIdx === 0 ? allSwarms.length - 1 : rightIdx - 1;
+    const dright = allSwarms[rightIdx][0].subtract(swarmId);
+    const dleft = swarmId.subtract(allSwarms[leftIdx][0]);
+    return dright.isLessThan(dleft) ? allSwarms[rightIdx] : allSwarms[leftIdx];
+  }
+};
+export {
+  Swarm
+};

package/eslint.config.mjs

@@ -0,0 +1,4 @@
+import { config } from "@repo/eslint-config/base";
+
+/** @type {import("eslint").Linter.Config} */
+export default config;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@session-foundation/swarm-routing",
+  "version": "0.0.1",
+  "description": "Routes requests across storage nodes by pubkey XOR distance",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "@session-foundation/network-requests": "^0.0.6",
+    "@session-foundation/basic-types": "^0.0.7"
+  },
+  "devDependencies": {
+    "@turbo/gen": "^2.4.4",
+    "@types/chai": "^5.2.2",
+    "@types/lodash": "^4.17.16",
+    "@types/mocha": "^10.0.10",
+    "chai": "^5.2.0",
+    "dependency-cruiser": "^16.3.3",
+    "eslint": "^9.23.0",
+    "mocha": "^11.7.1",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.4.0",
+    "tsx": "^4.21.0",
+    "typescript": "5.8.2",
+    "@repo/tsup-config": "^0.0.0",
+    "@repo/typescript-config": "^0.0.0",
+    "@repo/eslint-config": "^0.0.0",
+    "@session-foundation/dep-cruiser-config-shared": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "lint": "eslint . --max-warnings 0 && dependency-cruiser --config .dependency-cruiser.cjs .",
+    "check-types": "tsc --noEmit",
+    "build": "tsup src/index.ts --format cjs,esm --dts --tsconfig tsconfig.build.json",
+    "dev": "pnpm build --watch",
+    "pretest": "tsc --project tsconfig.test.json",
+    "test": "mocha"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './swarm_routing';

package/src/swarm_routing.ts

@@ -0,0 +1,153 @@
+import type { WithSwarmStr } from '@session-foundation/basic-types';
+import { createHexString, fromHex } from '@session-foundation/basic-types';
+
+export type WithSwarm = { swarm: Swarm };
+
+export class Swarm {
+  private readonly hi: number; // upper 32 bits, unsigned
+  private readonly lo: number; // lower 32 bits, unsigned
+
+  private constructor(hi: number, lo: number) {
+    this.hi = hi >>> 0;
+    this.lo = lo >>> 0;
+  }
+
+  /** Build from 8 big-endian bytes (output of the XOR reduction step). */
+  static fromBytes(bytes: Uint8Array): Swarm {
+    const hi =
+      ((bytes[0]! << 24) | (bytes[1]! << 16) | (bytes[2]! << 8) | bytes[3]!) >>>
+      0;
+    const lo =
+      ((bytes[4]! << 24) | (bytes[5]! << 16) | (bytes[6]! << 8) | bytes[7]!) >>>
+      0;
+    return new Swarm(hi, lo);
+  }
+
+  /** Parse a hex string (with or without 0x prefix, any length up to 16 chars). */
+  static fromHex(hex: string): Swarm {
+    const clean =
+      hex.startsWith('0x') || hex.startsWith('0X') ? hex.slice(2) : hex;
+    const padded = clean.padStart(16, '0');
+    const hi = parseInt(padded.slice(0, 8), 16);
+    const lo = parseInt(padded.slice(8), 16);
+    return new Swarm(hi, lo);
+  }
+
+  // ── Comparisons ────────────────────────────────────────────────────────────
+
+  /** -1 if this < other, 0 if equal, 1 if this > other (unsigned 64-bit). */
+  compareTo(other: Swarm): number {
+    if (this.hi !== other.hi) return this.hi < other.hi ? -1 : 1;
+    if (this.lo !== other.lo) return this.lo < other.lo ? -1 : 1;
+    return 0;
+  }
+
+  isLessThan(other: Swarm): boolean {
+    return this.compareTo(other) < 0;
+  }
+
+  equals(other: Swarm): boolean {
+    return this.hi === other.hi && this.lo === other.lo;
+  }
+
+  // ── Arithmetic ─────────────────────────────────────────────────────────────
+
+  /** Unsigned 64-bit subtraction with wraparound (mod 2^64). */
+  subtract(other: Swarm): Swarm {
+    const lo = (this.lo - other.lo) >>> 0;
+    const borrow = this.lo < other.lo ? 1 : 0;
+    const hi = (this.hi - other.hi - borrow) >>> 0;
+    return new Swarm(hi, lo);
+  }
+
+  // ── Serialisation ──────────────────────────────────────────────────────────
+
+  /** 16-character zero-padded lowercase hex string. */
+  toString(): string {
+    return (
+      this.hi.toString(16).padStart(8, '0') +
+      this.lo.toString(16).padStart(8, '0')
+    );
+  }
+
+  toJSON(): string {
+    return this.toString();
+  }
+
+  // ── Routing ────────────────────────────────────────────────────────────────
+
+  /**
+   * XOR the four 8-byte chunks of a 32-byte x25519 pubkey, then interpret
+   * the result as a big-endian uint64.  Equivalent of C++ pubkey_to_swarm_space.
+   */
+  static pubkeyToSwarmSpace(pk: Uint8Array): Swarm {
+    const xored = new Uint8Array(8);
+    for (let i = 0; i < 4; i++)
+      for (let j = 0; j < 8; j++) xored[j]! ^= pk[i * 8 + j]!;
+    return Swarm.fromBytes(xored);
+  }
+
+  /**
+   * Group nodes by swarm and return them sorted by swarm ID ascending.
+   * Equivalent of C++ generate_swarms.
+   */
+  static generateSwarms<T extends WithSwarmStr>(
+    nodes: T[],
+  ): Array<[Swarm, T[]]> {
+    const grouped = new Map<string, T[]>();
+    for (const node of nodes) {
+      const bucket = grouped.get(node.swarm) ?? [];
+      bucket.push(node);
+      grouped.set(node.swarm, bucket);
+    }
+
+    const result: Array<[Swarm, T[]]> = [];
+    for (const [swarmHex, members] of grouped)
+      result.push([Swarm.fromHex(swarmHex), members]);
+
+    result.sort((a, b) => a[0].compareTo(b[0]));
+    return result;
+  }
+
+  /**
+   * Find the swarm closest to the given x25519 pubkey using circular uint64
+   * distance. Equivalent of C++ get_swarm.
+   */
+  static getFor<T extends WithSwarmStr>(
+    swarmPubkeyHex: string,
+    allSwarms: Array<[Swarm, T[]]>,
+  ): [Swarm, T[]] {
+    if (allSwarms.length === 0) {
+      throw new Error('No swarms found: allSwarms.length === 0');
+    }
+
+    if (allSwarms.length === 1) {
+      return allSwarms[0]!;
+    }
+
+    const pkNoPrefix =
+      swarmPubkeyHex.length === 66 ? swarmPubkeyHex.slice(2) : swarmPubkeyHex;
+
+    const pk = fromHex(createHexString(pkNoPrefix));
+    const swarmId = Swarm.pubkeyToSwarmSpace(pk);
+
+    // lower_bound: first index where allSwarms[i][0] >= swarmId
+    let lo = 0,
+      hi = allSwarms.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >> 1;
+      if (allSwarms[mid]![0].isLessThan(swarmId)) lo = mid + 1;
+      else hi = mid;
+    }
+
+    const rightIdx = lo === allSwarms.length ? 0 : lo;
+    const leftIdx = rightIdx === 0 ? allSwarms.length - 1 : rightIdx - 1;
+
+    const dright = allSwarms[rightIdx]![0].subtract(swarmId);
+    const dleft = swarmId.subtract(allSwarms[leftIdx]![0]);
+
+    return dright.isLessThan(dleft)
+      ? allSwarms[rightIdx]!
+      : allSwarms[leftIdx]!;
+  }
+}

package/tests/swarm_routing.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swarm_routing.test.d.ts","sourceRoot":"","sources":["swarm_routing.test.ts"],"names":[],"mappings":""}