Refactor the order validation machinery to avoid generating permutation of tuples

src/data/stages.derived.ts

@@ -2,18 +2,18 @@
 // It contains mainly the support types and values that are derived from
 // the manually entered values.
 
+import defineOrderFor from "../types/defineOrder";
 import { NeverForEmpty } from "../types/NeverForEmpty";
-import { TuplifyUnionAnyOrder } from "../types/unionToTuple";
 import { bridgedChains, stages } from "./stages";
 
 export type Stages = typeof stages;
 
 export type StageId = keyof Stages;
 
-export type StageIdsOrder = TuplifyUnionAnyOrder<StageId>;
+export const defineStageIdsOrder = defineOrderFor<StageId>();
 
 export type BridgedChains = typeof bridgedChains;
 
 export type BridgedChainId = NeverForEmpty<keyof BridgedChains>;
 
-export type BridgedChainIdsOrder = TuplifyUnionAnyOrder<BridgedChainId>;
+export const defineBridgedChainIdsOrder = defineOrderFor<BridgedChainId>();

src/data/stages.ts

@@ -1,4 +1,8 @@
-import { BridgedChainIdsOrder, StageId, StageIdsOrder } from "./stages.derived";
+import {
+  StageId,
+  defineStageIdsOrder,
+  defineBridgedChainIdsOrder,
+} from "./stages.derived";
 import { BridgedChainsShape, StagesShape } from "./stages.internal";
 
 // Wait for announcements!
@@ -149,12 +153,9 @@ export const stages = {
 
 export const mainStageId = "mainnet" as const satisfies StageId;
 
-export const stagesDisplayOrder = [
-  "mainnet",
-  "testnet5",
-] as const satisfies StageIdsOrder;
+export const stagesDisplayOrder = defineStageIdsOrder(["mainnet", "testnet5"]);
 
-export const bridgedChainsDisplayOrder = [
+export const bridgedChainsDisplayOrder = defineBridgedChainIdsOrder([
   "avalanche",
   "base",
   "filecoin",
@@ -163,4 +164,4 @@ export const bridgedChainsDisplayOrder = [
   "hyperliquid",
   "story",
   "janction",
-] as const satisfies BridgedChainIdsOrder;
+]);

src/types/IsExactPermutation.ts

@@ -0,0 +1,23 @@
+// Checks whether a tuple T contains only unique items.
+type IsUnique<T extends readonly any[]> = T extends readonly [
+  infer F,
+  ...infer R,
+]
+  ? F extends R[number]
+    ? false
+    : IsUnique<R>
+  : true;
+
+// Checks that T is an exact permutation of U (i.e. it contains each element of U exactly once).
+type IsExactPermutation<T extends readonly any[], U> =
+  // First check that the union of T’s elements equals U.
+  [T[number]] extends [U]
+    ? [U] extends [T[number]]
+      ? // Then check that T has no duplicates.
+        IsUnique<T> extends true
+        ? T
+        : never
+      : never
+    : never;
+
+export default IsExactPermutation;

src/types/defineOrder.ts

@@ -0,0 +1,7 @@
+import IsExactPermutation from "./IsExactPermutation";
+
+function defineOrderFor<U extends string>() {
+  return <const T extends U[]>(order: IsExactPermutation<T, U>) => order;
+}
+
+export default defineOrderFor;