querysub 0.405.0 → 0.407.0

package/bin/deploy-prefixes.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+// Always local, as we want to always use the local code? Might not be needed anymore?
+process.argv.push("--local");
+
+require("typenode");
+require("../src/4-deploy/deployPrefixes");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.405.0",
+  "version": "0.407.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -23,6 +23,7 @@
   },
   "bin": {
     "deploy": "./bin/deploy.js",
+    "deploy-prefixes": "./bin/deploy-prefixes.js",
     "server": "./bin/server.js",
     "server-public": "./bin/server-public.js",
     "function": "./bin/function.js",

package/src/-f-node-discovery/NodeDiscovery.ts

@@ -46,8 +46,6 @@ let DISK_AUDIT_RATE = timeInMinute * 15;
 //  probably is less than that). Which is around 2.5 cents on digital ocean IF we go over
 //  our 1TB/month allowance.
 let API_AUDIT_RATE = timeInSecond * 30;
-// BUT, for now, poll less often... because I think it is lagging our 2 core potato digital ocean server.
-API_AUDIT_RATE = timeInMinute * 5;
 let API_AUDIT_COUNT = 12;
 
 

package/src/0-path-value-core/AuthorityLookup.ts

@@ -5,7 +5,7 @@ import { archiveJSONT } from "../-a-archives/archivesJSONT";
 import { getDomain, isPublic } from "../config";
 import { cache, lazy } from "socket-function/src/caching";
 import { SocketFunction } from "socket-function/SocketFunction";
-import { runInSerial, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { delay, runInSerial, runInfinitePollCallAtStart } from "socket-function/src/batching";
 import { getAllNodeIds, getOwnNodeId, isOwnNodeId, onNodeBroadcasted, syncNodesNow, watchDeltaNodeIds, watchNodeIds } from "../-f-node-discovery/NodeDiscovery";
 import { IdentityController_getCurrentReconnectNodeIdAssert } from "../-c-identity/IdentityController";
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
@@ -15,6 +15,7 @@ import { timeoutToError } from "../errors";
 import { AuthoritySpec } from "./PathRouter";
 import { formatTime } from "socket-function/src/formatting/format";
 import { getAllAuthoritySpec, getEmptyAuthoritySpec } from "./PathRouterServerAuthoritySpec";
+import { getPrefixesForDeploy } from "../3-path-functions/syncSchema";
 
 
 let NETWORK_POLL_INTERVAL = timeInMinute * 5;
@@ -201,9 +202,13 @@ class AuthorityLookup {
         if (isClient()) {
             // Doesn't matter what the node ID is, we should really only be connecting to the browser node ID, Which will have all the data for the current domain. 
             //  - Get all node IDs should restrict our nodes to just the browser node ID. If we ever change this, then either it's redundant nodes and they all have all the same data, or we need to figure out what data they have, And as their proxies, it probably won't be their actual authority data. So that will require new API functions, etc. 
+            await new Promise(r => setImmediate(r));
+            await delay(1);
             this.updatePaths(nodeId, {
-                ...getAllAuthoritySpec(),
                 nodeId: nodeId,
+                prefixes: await getPrefixesForDeploy(),
+                routeStart: 0,
+                routeEnd: 1,
             }, true);
             return;
         }

package/src/0-path-value-core/PathRouter.ts

@@ -9,6 +9,7 @@ import { unique } from "../misc";
 import { measureFnc } from "socket-function/src/profiling/measure";
 import { getRoutingOverride, hasPrefixHash } from "./PathRouterRouteOverride";
 import { sha256 } from "js-sha256";
+import { removeRange } from "../rangeMath";
 
 
 // Cases
@@ -32,13 +33,29 @@ export type AuthoritySpec = {
     routeEnd: number;
     // If the path.startsWith(prefix), but prefix !== path, then we hash getPathIndex(path, hashIndex)
     //  - For now, let's just never add overlapping prefixes.
-    prefixes: {
-        prefix: string;
-        hashIndex: number;
-    }[];
+    prefixes: string[];
     excludeDefault?: boolean;
 };
 
+export function debugSpec(spec: AuthoritySpec) {
+    return {
+        info: `${spec.routeStart}-${spec.routeEnd} (${spec.prefixes.length} prefixes${spec.excludeDefault ? " excluding default" : ""})`,
+        spec: { do: { not: { expand: { spec } } } },
+    };
+}
+
+function getMatchingPrefix(spec: AuthoritySpec, path: string): string | undefined {
+    let longestPrefix: string | undefined;
+    for (let prefix of spec.prefixes) {
+        if (path.startsWith(prefix) && prefix !== path) {
+            if (!longestPrefix || longestPrefix.length < prefix.length) {
+                longestPrefix = prefix;
+            }
+        }
+    }
+    return longestPrefix;
+}
+
 
 export class PathRouter {
 
@@ -50,6 +67,10 @@ export class PathRouter {
      */
     @measureFnc
     public static getRouteChildKey(path: string): number {
+        let override = getRoutingOverride(path);
+        if (override) {
+            return override.route;
+        }
         let key = getLastPathPart(path);
         return this.getSingleKeyRoute(key);
     }
@@ -64,17 +85,16 @@ export class PathRouter {
         path = hack_stripPackedPath(path);
         let override = getRoutingOverride(path);
         if (override) {
-            if (!hasPrefixHash({ spec, prefixHash: override.prefixHash })) return -1;
+            if (spec.excludeDefault && !hasPrefixHash({ spec, prefixHash: override.prefixHash })) return -1;
+            if (override.route < spec.routeStart || override.route >= spec.routeEnd) return -1;
             return override.route;
         }
 
-        let prefix = spec.prefixes.find(x => path.startsWith(x.prefix) && x.prefix !== path);
+        let prefix = getMatchingPrefix(spec, path);
         if (prefix) {
-            let key = getPathIndex(path, prefix.hashIndex);
+            let key = getPathIndex(path, getPathDepth(prefix));
             if (key === undefined) {
-                require("debugbreak")(2);
-                debugger;
-                throw new Error(`Impossible, hash index ${prefix.hashIndex} is out of range for path ${path}, but it matched the prefix ${prefix.prefix}`);
+                throw new Error(`Impossible, hash index ${getPathDepth(prefix)} is out of range for path ${path}, but it matched the prefix ${prefix}`);
             }
             return this.getSingleKeyRoute(key);
         }
@@ -84,6 +104,17 @@ export class PathRouter {
         return hash;
     }
 
+    // Mostly for debugging
+    @measureFnc
+    public static getAllRoutes(path: string): number[] {
+        let routes: number[] = [];
+        for (let authority of authorityLookup.getTopologySync()) {
+            let route = this.getRouteFull({ path, spec: authority.authoritySpec });
+            routes.push(route);
+        }
+        return routes;
+    }
+
     private static lastKeyRoute = {
         key: "",
         route: -1,
@@ -91,6 +122,12 @@ export class PathRouter {
     // Takes a key which is a part of a path. Mostly used PathRouterRouteOverride, or other PathRouter helpers.
     public static getSingleKeyRoute(key: string): number {
         if (key && this.lastKeyRoute.key === key) return this.lastKeyRoute.route;
+        let override = getRoutingOverride(key);
+        if (override) {
+            this.lastKeyRoute.key = key;
+            this.lastKeyRoute.route = override.route;
+            return override.route;
+        }
         let hash = fastHash(key);
         let route = hash % (1000 * 1000 * 1000) / (1000 * 1000 * 1000);
         this.lastKeyRoute.key = key;
@@ -112,7 +149,15 @@ export class PathRouter {
     private static encodeIdentifier(config: { prefixes: string[]; rangeStart: number; rangeEnd: number } | "remaining"): string {
         if (config === "remaining") return "P!REMAINING";
         let { prefixes, rangeStart, rangeEnd } = config;
-        return ["P", rangeStart.toString(), rangeEnd.toString(), ...prefixes.map(x => this.getPrefixHash(x)), ""].join("!");
+        return [
+            "P",
+            rangeStart.toString(),
+            rangeEnd.toString(),
+            ...prefixes.map(x => this.getPrefixHash(x)),
+            // Add some prefixes. They'll be interpreted as hashes, but it's fine because it's highly unlikely they'll collide with a real hash. AND... It's very useful for debugging what's in which file. 
+            ...prefixes.slice(0, 5).map(x => getLastPathPart(x).replaceAll(/[^a-zA-Z0-9]/g, "").slice(0, 20)),
+            ""
+        ].join("!");
 
     }
     private static decodeIdentifier(identifier: string): { prefixHashes: string[]; rangeStart: number; rangeEnd: number } | "remaining" {
@@ -141,19 +186,12 @@ export class PathRouter {
         }
 
         let prefixes = ourSpec.prefixes.slice();
-        sort(prefixes, x => x.prefix.length);
-        function getPrefix(path: string): string | undefined {
-            for (let prefix of prefixes) {
-                if (path.startsWith(prefix.prefix) && prefix.prefix !== path) return prefix.prefix;
-            }
-            return undefined;
-        }
-
+        sort(prefixes, x => x.length);
 
         // NOTE: If there are few enough path values for a prefix, we don't even need to calculate the routing hash. 
         let byPrefix = new Map<string | undefined, PathValue[]>();
         for (let value of values) {
-            let prefix = getPrefix(value.path);
+            let prefix = getMatchingPrefix(ourSpec, value.path);
             let values = byPrefix.get(prefix);
             if (!values) {
                 values = [];
@@ -168,9 +206,6 @@ export class PathRouter {
         }));
         sort(prefixGroups, x => -x.values.length);
 
-        require("debugbreak")(2);
-        debugger;
-
         let groups: {
             prefixes: string[];
             values: PathValue[][];
@@ -261,7 +296,7 @@ export class PathRouter {
         // Match all remaining, as we don't store enough information to know what prefixes they excluded
         if (decodeObj === "remaining") return true;
 
-        let ourHashes = authority.prefixes.map(x => this.getPrefixHash(x.prefix));
+        let ourHashes = authority.prefixes.map(x => this.getPrefixHash(x));
         // If it pulled off some values as prefixes, but we did full path hashes, then the hashes are going to be totally different. And so there could easily be overlap.
         if (decodeObj.prefixHashes.some(x => !ourHashes.includes(x))) return true;
         // However, if we hash everything the same, then the overlap is purely a case of if the route ranges overlap. 
@@ -283,11 +318,12 @@ export class PathRouter {
 
 
     // NOTE: This might return overlapping specs. Presently, this is only used when we're loading our initial data, so it's fine. However, if we use this for another purpose in the future, it might cause problems. So we might need to implement a different function for that theoretical future purpose.
+    // NOTE: Only takes remote nodes as presently this is just used during startup.
     @measureFnc
     public static getAuthoritySources(config: {
         target: AuthoritySpec;
         preferredNodeIds?: string[];
-    }): (AuthoritySpec & { useFullPathHash?: boolean })[] {
+    }): AuthoritySpec[] {
         let { target } = config;
         let allSources = authorityLookup.getTopologySync();
         allSources = allSources.filter(x => !isOwnNodeId(x.nodeId));
@@ -305,12 +341,12 @@ export class PathRouter {
 
         let groupByPrefixHash = new Map<string, AuthoritySpec[]>();
         for (let source of allSources) {
-            let usedPrefixes = source.authoritySpec.prefixes.map(x => x.prefix);
+            let usedPrefixes = source.authoritySpec.prefixes;
 
             if (target.excludeDefault) {
                 // This relaxes the restrictions, as with no default hashes, it means if a value isn't in one of our prefixes, even if it's inconsistent in the sources, it's fine. 
                 // (And... Otherwise, we can't filter these at all because otherwise the default/remaining group will be different, even if it's a superset/subset relationship)
-                let targetUsedPrefixes = new Set(target.prefixes.map(x => x.prefix));
+                let targetUsedPrefixes = new Set(target.prefixes);
                 usedPrefixes = usedPrefixes.filter(x => targetUsedPrefixes.has(x));
             }
             let prefixHash = sha256(JSON.stringify(usedPrefixes.sort()));
@@ -329,17 +365,17 @@ export class PathRouter {
         }
 
         function hashesSameAsTarget(spec: AuthoritySpec): boolean {
-            let targetUsedPrefixes = new Set(target.prefixes.map(x => x.prefix));
+            let targetUsedPrefixes = new Set(target.prefixes);
             if (target.excludeDefault) {
                 // If target is excluding default, then it doesn't matter if the spec is including it. We're only looking for matching values in target.
-                return spec.prefixes.every(x => targetUsedPrefixes.has(x.prefix));
+                return spec.prefixes.every(x => targetUsedPrefixes.has(x));
             }
             // if !targetExcludeDefault, then !spec.excludeDefault, because we filtered out other cases earlier (so we don't need to handle spec.
 
             if (spec.prefixes.length !== target.prefixes.length) return false;
             // Otherwise, All of the prefixes have to be identical
             for (let prefix of spec.prefixes) {
-                if (!targetUsedPrefixes.has(prefix.prefix)) return false;
+                if (!targetUsedPrefixes.has(prefix)) return false;
             }
             return true;
         }
@@ -368,41 +404,21 @@ export class PathRouter {
             for (let source of group) {
                 let s = source.routeStart;
                 let e = source.routeEnd;
-                // Find if it overlaps any missing range, and if so, cut out that part of the missing change, and add the nodeId to usedNodeIds
-                for (let i = missingRanges.length - 1; i >= 0; i--) {
-                    let missingRange = missingRanges[i];
-                    if (s >= missingRange.end || e <= missingRange.start) continue;
-                    let startTaken = Math.max(missingRange.start, s);
-                    let endTaken = Math.min(missingRange.end, e);
-                    // NOTE: It's not ideal that we might have to fragment one node ID between multiple requests. However, in practice, there shouldn't be much fragmentation here. The ranges that our nodes are breaking down by should be consistent, so there's actually no overlap or subsets.
+                let { removedRanges } = removeRange(missingRanges, { start: s, end: e });
+                for (let removedRange of removedRanges) {
                     usedParts.push({
                         nodeId: source.nodeId,
-                        routeStart: startTaken,
-                        routeEnd: endTaken,
+                        routeStart: removedRange.start,
+                        routeEnd: removedRange.end,
                         prefixes: target.prefixes,
                         excludeDefault: target.excludeDefault,
-                        useFullPathHash,
                     });
-                    missingRanges.splice(i, 1);
-                    // Add back the parts we didn't overlap
-                    if (missingRange.start < s) {
-                        missingRanges.push({
-                            start: missingRange.start,
-                            end: s,
-                        });
-                    }
-                    if (missingRange.end > e) {
-                        missingRanges.push({
-                            start: e,
-                            end: missingRange.end,
-                        });
-                    }
                 }
                 if (missingRanges.length === 0) break;
             }
             if (missingRanges.length === 0) {
                 if (!hashesSameAsTarget(group[0])) {
-                    console.warn(`Found a cohesive group that doesn't hash the same way we do. Expanding our range to be the full range of the group. This will be slower than it needs to.`);
+                    console.warn(`Could only match a cohesive group that doesn't hash the same way we do. Expanding our range to be the full range of the group. This will be slower than it needs to, and might cause issues that result in only partial synchronization. This should be fixable with a deploy.`, config.target);
                 }
                 return usedParts;
             }
@@ -418,9 +434,6 @@ export class PathRouter {
     public static getChildReadNodes(path: string, config?: {
         preferredNodeIds?: string[];
     }): {
-        // By default we hash the key directly under the path. However, If that is not how our nodes were sharded, as in they didn't use it as a prefix, then they will be sharded by hashing the full path, and so when we receive the data, we need to keep this in mind and filter the data based on the full path hash.
-        useFullPathHash?: boolean;
-
         // NOTE: If at all possible, we will cover all ranges. Node of the returned nodes will be redundant.
         //  - Sorted by range.start
         nodes: {
@@ -433,20 +446,66 @@ export class PathRouter {
         if (this.isSelfAuthority(path)) {
             return { nodes: [{ nodeId: getOwnNodeId(), range: { start: 0, end: 1 } }] };
         }
+        let preferredNodeIds = new Set(config?.preferredNodeIds ?? []);
 
         // If a prefix is a parent of path, then it is the same as matching just the path directly
         // (If our prefix directly equals one of the other matches, then it's more complicated, As then, the child keys of path are what is hashed, and so all the children will have different routes, so we might match multiple nodes. The same thing if we're matching the remaining case, in which case it's a full path hash, so the child key matters, and again, different routes).
         //      - The different route case is how the FuntionRunner works, and without it large databases couldn't run functions. However, most applications won't directly use it.
         let allSources = authorityLookup.getTopologySync();
-        allSources = allSources.filter(x => !isOwnNodeId(x.nodeId));
-        let nestedMatches = allSources.filter(x =>
-            x.authoritySpec.prefixes.some(y => path.startsWith(y.prefix) && y.prefix !== path)
-            && this.matchesAuthoritySpec(x.authoritySpec, path)
-        );
+        // Prefer our own node
+        sort(allSources, x => isOwnNodeId(x.nodeId) ? -1 : 1);
+
+
+        // Direct prefixes always take priority, as almost everything is under a prefix anyways...
+
+
+        // Direct prefix. This happens for things like calls and functions, it requires more advanced routing as it means we're going to route between multiple servers, but... it is important
+        let hasPrefix = allSources.filter(x => x.authoritySpec.prefixes.some(y => y === path)).map(x => x.authoritySpec);
+        if (hasPrefix.length > 0) {
+            shuffle(hasPrefix, Math.random());
+            sort(hasPrefix, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+
+            let missingRanges: { start: number; end: number }[] = [{
+                start: 0,
+                end: 1,
+            }];
+            let usedParts: {
+                nodeId: string;
+                range: { start: number; end: number };
+            }[] = [];
+            for (let source of hasPrefix) {
+                let s = source.routeStart;
+                let e = source.routeEnd;
+                let { removedRanges } = removeRange(missingRanges, { start: s, end: e });
+                // NOTE: It's not ideal that we might have to fragment one node ID between multiple requests. However, in practice, there shouldn't be much fragmentation here. The ranges that our nodes are breaking down by should be consistent, so there's actually no overlap or subsets.
+                for (let removedRange of removedRanges) {
+                    usedParts.push({
+                        nodeId: source.nodeId,
+                        range: removedRange,
+                    });
+                }
+                if (missingRanges.length === 0) break;
+            }
+            if (missingRanges.length === 0) {
+                return { nodes: usedParts };
+            }
+        }
+
+        let nestedMatches = allSources.filter(x => {
+            // There's nested prefixes, so if we match any prefix explicitly, we can't just take one of the previous prefixes because that isn't how the hashing will work. 
+            // - This happens if it's a direct match, but one of the shards is down, in which case we can't get a full match.
+            if (x.authoritySpec.prefixes.some(y => y === path)) return false;
+
+            // If our path, which we're going to read the children of, is the child of another path, then it means in that other path, the child key will be known to us constant, and so we're going to match exactly one authority. 
+            return (
+                x.authoritySpec.prefixes.some(y => path.startsWith(y) && y !== path)
+                && this.matchesAuthoritySpec(x.authoritySpec, path)
+            );
+        });
         if (nestedMatches.length > 0) {
             shuffle(nestedMatches, Math.random());
-            let preferredNodeIds = new Set(config?.preferredNodeIds ?? []);
             sort(nestedMatches, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+            sort(allSources, x => isOwnNodeId(x.nodeId) ? -1 : 1);
             return {
                 nodes: nestedMatches.map(x => ({
                     nodeId: x.nodeId,
@@ -456,28 +515,53 @@ export class PathRouter {
             };
         }
 
-        let fullSources = this.getAuthoritySources({
-            target: {
-                nodeId: "",
-                prefixes: [{
-                    prefix: path,
-                    hashIndex: getPathDepth(path),
-                }],
-                routeStart: 0,
-                routeEnd: 1,
-                excludeDefault: true,
-            },
-            preferredNodeIds: config?.preferredNodeIds,
+        // If we are not under any prefixes of it, then it will be a full path hash
+        let fullPathMatches = allSources.filter(x => {
+            return !x.authoritySpec.prefixes.some(y => path.startsWith(y) && y !== path);
         });
-        if (fullSources.length === 0) return { nodes: [] };
+        // Same as prefix matches. Not preferred, and not preferred over being under a prefix, but required for some root data, or data with no prefixes.
+        if (fullPathMatches.length > 0) {
+            shuffle(fullPathMatches, Math.random());
+            sort(fullPathMatches, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+            sort(allSources, x => isOwnNodeId(x.nodeId) ? -1 : 1);
+            let missingRanges: { start: number; end: number }[] = [{
+                start: 0,
+                end: 1,
+            }];
+            let usedParts: {
+                nodeId: string;
+                range: { start: number; end: number };
+            }[] = [];
+            for (let source of fullPathMatches) {
+                let s = source.authoritySpec.routeStart;
+                let e = source.authoritySpec.routeEnd;
+                let { removedRanges } = removeRange(missingRanges, { start: s, end: e });
+                // NOTE: It's not ideal that we might have to fragment one node ID between multiple requests. However, in practice, there shouldn't be much fragmentation here. The ranges that our nodes are breaking down by should be consistent, so there's actually no overlap or subsets.
+                for (let removedRange of removedRanges) {
+                    usedParts.push({
+                        nodeId: source.nodeId,
+                        range: removedRange,
+                    });
+                }
+                if (missingRanges.length === 0) break;
+            }
+            if (missingRanges.length === 0) {
+                return { nodes: usedParts };
+            }
+        }
 
-        return {
-            useFullPathHash: fullSources.some(x => x.useFullPathHash),
-            nodes: fullSources.map(x => ({
-                nodeId: x.nodeId,
-                range: { start: x.routeStart, end: x.routeEnd },
-            })),
-        };
+
+
+        // TODO: We could maybe match a partial match. However, even that is suspect. The site being partially broken is almost worse than it being completely broken. We should just get ALL the shards running again...
+
+
+        require("debugbreak")(2);
+        debugger;
+
+
+        // NOTE: We *could* actually synchronize it even if it doesn't have a prefix shard as we can fall back to just the full path sharding. However, it becomes very complicated if we want a specific range, and then it becomes complicated if it then switches to prefix hashing (With the nodes that were using the full path hashing slowly going away). AND... key synchronization IS slow, so it's good to discourage it in general. 
+        console.error(`Want to sync a prefix which is not under an existing prefix, nor equal to a prefix. 1) The servers are down. 2) Don't access the .keys() 3) call addRoutingPrefixForDeploy to add a route/parent route explicitly (as is done in PathFunctionRunner.ts). Path: ${JSON.stringify(path)}`, { path, allSources });
+        return { nodes: [] };
     }
 
 
@@ -541,3 +625,5 @@ export class PathRouter {
 
 }
 
+
+(globalThis as any).PathRouter = PathRouter;

package/src/0-path-value-core/PathRouterRouteOverride.ts

@@ -22,7 +22,7 @@ let keySpecialIdentifier = (
 export function createRoutingOverrideKey(config: {
     originalKey: string;
     routeKey: string;
-    // This is not the prefix that it has to match. This is the prefix we remap it to. And so anything which matches this remap prefix will match this routing key. 
+    // This is the prefix it has the equivalent of. We need this, so if something excludes default, it doesn't automatically get every routing overridden value.
     remappedPrefix: string;
 }) {
     let { originalKey, routeKey, remappedPrefix } = config;
@@ -62,7 +62,7 @@ export const hasPrefixHash = cacheLimited(1000 * 10,
     (config: { spec: AuthoritySpec, prefixHash: string }) => {
         let { spec, prefixHash } = config;
         for (let prefix of spec.prefixes) {
-            if (getPrefixHash(prefix.prefix) === prefixHash) {
+            if (getPrefixHash(prefix) === prefixHash) {
                 return true;
             }
         }

package/src/0-path-value-core/PathRouterServerAuthoritySpec.tsx

@@ -20,10 +20,7 @@ export async function getOurAuthoritySpec(defaultToAll?: boolean): Promise<Autho
                 nodeId: "",
                 routeStart: 0,
                 routeEnd: 1,
-                prefixes: prefixes.map(prefix => ({
-                    prefix,
-                    hashIndex: getPathDepth(prefix),
-                })),
+                prefixes: prefixes,
             };
         }
         return undefined;
@@ -46,10 +43,7 @@ export async function getOurAuthoritySpec(defaultToAll?: boolean): Promise<Autho
         nodeId: "",
         routeStart: rangeStart,
         routeEnd: rangeEnd,
-        prefixes: usePrefixes.map(prefix => ({
-            prefix,
-            hashIndex: getPathDepth(prefix),
-        })),
+        prefixes: usePrefixes,
         excludeDefault: excludeDefault || undefined,
     };
 }