@roster-lock/match-agent 0.1.0

package/src/handle-room/version-1/room-handler-bridge/server.pseudo.ts

@@ -0,0 +1,85 @@
+import { MessageBridge } from "../../../utils/MessageBridge";
+import { isDeepStrictEqual } from "node:util";
+
+type UserPublicKey = string;
+
+export async function runRooms(users: Array<{ bridge: MessageBridge, publicKey: UserPublicKey }>){
+  const pingAbortController = new AbortController();
+
+  try {
+    await Promise.race([
+      runRoom(users),
+      Promise.race(users.map(user=>keepPing(user.bridge, pingAbortController.signal))),
+      Promise.race(users.map(user=>waitForError(user.bridge))),
+    ])
+  }catch(e){
+    for(const user of users){
+      user.bridge.sendEvent("error", (e as Error).message);
+    }
+    throw e;
+  }finally{
+    pingAbortController.abort();
+  }
+}
+
+async function waitForError(user: MessageBridge){
+  return new Promise((resolve, reject)=>{
+    user.onEvent("error", (error)=>{
+      reject(new Error(error.toString()));
+    });
+  });
+}
+
+
+async function keepPing(user: MessageBridge, abortSignal: AbortSignal){
+  while(!abortSignal.aborted){
+    const result = await user.sendRequest("ping", {});
+    if(result !== "pong") throw new Error("Invalid Response");
+    await delay(1000);
+  }
+}
+
+function delay(ms: number){
+  return new Promise(resolve=>setTimeout(resolve, ms));
+}
+
+const UNSET_FINAL = Symbol("unset-final");
+const INVALID_FINAL = Symbol("invalid-final");
+async function runRoom(users: Array<{ bridge: MessageBridge, publicKey: UserPublicKey }>){
+  const userCommits: Record<UserPublicKey, any> = {};
+  await Promise.all(users.map(async (user)=>{
+    const commit = await user.bridge.sendRequest("user-selection", {});
+    userCommits[user.publicKey] = commit;
+  }));
+  const userReveals: Record<UserPublicKey, any> = {};
+  await Promise.all(users.map(async (user)=>{
+    const reveal = await user.bridge.sendRequest("all-selection-for-user-decryption", userCommits);
+    userReveals[user.publicKey] = reveal;
+  }));
+  let userFinals: typeof UNSET_FINAL | typeof INVALID_FINAL | Record<string, any>  = UNSET_FINAL;
+  await Promise.all(users.map(async (user)=>{
+    const final = await user.bridge.sendRequest("all-decryption-for-user-final", userReveals);
+    if(userFinals === INVALID_FINAL) return;
+    if(userFinals === UNSET_FINAL){
+      userFinals = final;
+      return;
+    }
+    if(!isDeepStrictEqual(userFinals, final)){
+      userFinals = INVALID_FINAL;
+      throw new Error("Final Selection Mismatch");
+    }
+  }));
+  for(const user of users){
+    user.bridge.onEvent("download-progress", (data)=>{
+      for(const otherUser of users){
+        otherUser.bridge.sendEvent("download-progress", { ...data, user: user.publicKey });
+      }
+    })
+  }
+  await Promise.all(users.map(async (user)=>{
+    await user.bridge.sendRequest("user-download", {});
+  }));
+  for(const user of users){
+    user.bridge.sendEvent("all-download", {});
+  }
+}

package/src/handle-room/version-1/room-handler-bridge/steps.ts

@@ -0,0 +1,255 @@
+
+import { MessageBridge } from "@roster-lock/utils";
+import {
+  FinalSelection, RosterLockV1Config, SelectedPiece, UserSelection, PlayerId,
+  RosterLockV1SyncDLResult
+} from "@roster-lock/types";
+import { runSelection } from "@roster-lock/shared";
+import { encryptJSON, decryptJSON } from "../handleRoomSelections/encryption";
+import { createRandomSeed } from "../handleRoomSelections/random";
+import { z, ZodType } from "zod";
+import { UserSelectionSchema } from "../schema/selected";
+import { PluginManager } from "@roster-lock/plugin-runtime";
+import { handleDownloads } from "../handleDownloads";
+import { IFolderDB } from "../globals/FolderDB";
+import { RosterLockDownloadUpdate } from "@roster-lock/types";
+
+type MachinePublicKey = string;
+
+type EncryptedValue = Awaited<ReturnType<typeof encryptJSON>>;
+
+type RoomState = (
+  | { state: "user-selection" }
+  | { state: "all-selection-for-user-decryption" }
+  | { state: "all-decryption-for-user-final", encrypted: Record<MachinePublicKey, EncryptedValue["encryptedValue"]> }
+  | { state: "user-download", finalSelection: FinalSelection }
+  | { state: "all-download", finalSelection: FinalSelection, downloadResults: Awaited<ReturnType<typeof handleDownloads>> }
+  | { state: "ended" }
+)
+
+type RoomArgs = {
+  bridge: MessageBridge,
+  fileDB: IFolderDB,
+  pluginRuntime: PluginManager,
+  machines: Array<{ publicKey: MachinePublicKey, playerCount: number }>,
+  ownMachinePublicKey: MachinePublicKey,
+  // This machine's local players' selections, keyed by local player index
+  // (0-based). A machine with multiple controllers plugged in submits one
+  // entry per local player over its single relay connection.
+  ownSelections: Record<number, UserSelection>,
+  lockConfig: RosterLockV1Config,
+  gameControlledSelections: Record<string, Array<SelectedPiece> | Record<PlayerId, Array<SelectedPiece>>>,
+}
+
+export type ProgressListeners = Partial<{
+  onState: (state: string)=>void,
+  onDownloadProgress: (update: RosterLockDownloadUpdate)=>void,
+}>
+
+type UserInput = {
+  userSelection: UserSelection,
+  randomSeed: string,
+}
+
+// What one machine actually sends over the wire: all of its local players'
+// selections plus the one random seed it contributes to the room.
+type MachinePayload = {
+  selections: Record<number, UserSelection>,
+  randomSeed: string,
+}
+
+export function bindStepsToBridge(
+  {
+    bridge,
+    fileDB,
+    pluginRuntime,
+    machines,
+    ownMachinePublicKey,
+    ownSelections,
+    lockConfig,
+    gameControlledSelections,
+  }: RoomArgs,
+  progressListeners: ProgressListeners = {}
+): Promise<RosterLockV1SyncDLResult>{
+  const { resolve, reject, promise } = Promise.withResolvers<RosterLockV1SyncDLResult>();
+  const downloadAbort = new AbortController();
+  const heartbeat = trackHeartbeat(30_000);
+  const stateTracker = new StateTracker({ state: "user-selection" }, progressListeners);
+
+  const rngSeed = createRandomSeed();
+  const ownEncrypted = encryptJSON({ selections: ownSelections, randomSeed: rngSeed });
+  // Filled in by "all-decryption-for-user-final" below, read back by the
+  // handleFullSelection hook once the whole room promise settles.
+  let decryptedSelections: Record<PlayerId, UserInput> = {};
+
+  bridge.onRequest("ping", ()=>{
+    heartbeat.heartBeat();
+    return "pong";
+  });
+
+  // Return Encrypted Selections
+  bridge.onRequest("user-selection", async ()=>{
+    heartbeat.heartBeat();
+    const state = stateTracker.get();
+    if(state.state !== "user-selection") throw new Error("Invalid State");
+    const { encryptedValue } = await ownEncrypted;
+    stateTracker.set({ state: "all-selection-for-user-decryption" });
+    return encryptedValue;
+  });
+  // Handle All Selections
+  // Return Decryption Key
+  bridge.onRequest("all-selection-for-user-decryption", async (data)=>{
+    heartbeat.heartBeat();
+    const state = stateTracker.get();
+    if(state.state !== "all-selection-for-user-decryption") throw new Error("Invalid State");
+    const casted = EncryptedSelectionSchema.safeParse(data);
+    if(!casted.success) throw new Error("Invalid Selections");
+    if(Object.keys(casted.data).length !== machines.length) throw new Error("Invalid Machine Count");
+    for(const machine of machines){
+      if(!casted.data[machine.publicKey]) throw new Error("Missing Machine Selections");
+    }
+    const { key } = await ownEncrypted;
+    stateTracker.set({ state: "all-decryption-for-user-final", encrypted: casted.data });
+    return key;
+  })
+  // Handle All Decryption Keys
+  // Return Final Selections
+  bridge.onRequest("all-decryption-for-user-final", async (data)=>{
+    heartbeat.heartBeat();
+    const state = stateTracker.get();
+    if(state.state !== "all-decryption-for-user-final") throw new Error("Invalid State");
+    const allEncrypted = state.encrypted;
+    const casted = DecryptionKeySchema.safeParse(data);
+    if(!casted.success) throw new Error("Invalid Decryption Keys");
+    if(Object.keys(casted.data).length !== machines.length) throw new Error("Invalid Machine Count");
+    const keys = casted.data;
+    await Promise.all(machines.map(async (machine)=>{
+      const encrypted = allEncrypted[machine.publicKey];
+      if(!encrypted) throw new Error("Missing Encrypted Selections");
+      const key = keys[machine.publicKey];
+      if(!key) throw new Error("Missing Decryption Key");
+      const decrypted = await decryptJSON(key, encrypted);
+      const casted = MachinePayloadSchema.safeParse(decrypted);
+      if(!casted.success) throw new Error("Invalid Selections");
+      const { selections, randomSeed } = casted.data;
+      // A machine can't submit more or fewer player selections than it
+      // declared to the matchmaker when the room was created.
+      if(Object.keys(selections).length !== machine.playerCount){
+        throw new Error("Player Count Mismatch");
+      }
+      for(const [index, userSelection] of Object.entries(selections)){
+        decryptedSelections[`${machine.publicKey}:${index}`] = { userSelection, randomSeed };
+      }
+    }))
+    const finalSelection = await runSelection(
+      lockConfig, gameControlledSelections, decryptedSelections, (script)=>(pluginRuntime.runUntrustedScript(script))
+    );
+    stateTracker.set({ state: "user-download", finalSelection: finalSelection });
+
+    return finalSelection;
+  })
+
+  bridge.onRequest("user-download", async ()=>{
+    heartbeat.heartBeat();
+    const state = stateTracker.get();
+    if(state.state !== "user-download") throw new Error("Invalid State");
+    const downloadResults = await handleDownloads(
+      fileDB, lockConfig, state.finalSelection, {
+        onProgress: (event)=>{bridge.sendEvent("download-progress", event)},
+        abortSignal: downloadAbort.signal,
+      }
+    );
+    stateTracker.set({ state: "all-download", finalSelection: state.finalSelection, downloadResults });
+    return "ok"
+  })
+
+  bridge.onEvent("download-progress", (data: RosterLockDownloadUpdate)=>{
+    heartbeat.heartBeat();
+    progressListeners.onDownloadProgress?.(data);
+  })
+
+  bridge.onEvent("all-download", (data)=>{
+    heartbeat.heartBeat();
+    const state = stateTracker.get();
+    if(state.state !== "all-download") throw new Error("Invalid State");
+    resolve({
+      finalSelection: state.finalSelection,
+      downloadResults: state.downloadResults,
+    });
+  })
+
+  bridge.onEvent("error", (error)=>{
+    console.error("room error", error);
+    downloadAbort.abort();
+    reject(error);
+  })
+
+  // .finally()'s returned promise mirrors promise's rejection - it has to
+  // be observed here too, or a failed room leaves an unhandled rejection.
+  promise.finally(()=>{
+    heartbeat.stop();
+    stateTracker.set({ state: "ended" });
+  }).catch(()=>{});
+
+  // Only fires once the whole room succeeds (selection + downloads) - doesn't
+  // block "all-decryption-for-user-final"'s response, and a broken/misbehaving
+  // indexing plugin can't stop the room, so failures here are only logged.
+  promise.then(()=>{
+    const userSelections = Object.fromEntries(
+      Object.entries(decryptedSelections).map(([playerId, input])=>[playerId, input.userSelection])
+    );
+    const localPlayers = Object.keys(ownSelections).map((index)=>`${ownMachinePublicKey}:${index}`);
+    return pluginRuntime.pieceSort.handleFullSelection({ lockConfig, localUsers: localPlayers, userSelections });
+  }).catch((e)=>{
+    console.error("piece-selection-sort handleFullSelection failed", e);
+  });
+
+  return Promise.race([
+    promise,
+    heartbeat.promise.then(()=>{
+      bridge.sendEvent("error", "Heartbeat Timeout");
+      downloadAbort.abort();
+      throw new Error("Heartbeat Timeout")
+    })
+  ]);
+}
+
+const EncryptedSelectionSchema: ZodType<Record<MachinePublicKey, EncryptedValue["encryptedValue"]>> = z.record(z.string(), z.string());
+
+const DecryptionKeySchema: ZodType<Record<MachinePublicKey, string>> = z.record(z.string(), z.string());
+
+const MachinePayloadSchema: ZodType<MachinePayload> = z.object({
+  selections: z.record(z.string(), UserSelectionSchema),
+  randomSeed: z.string(),
+});
+
+
+function trackHeartbeat(maxTimeout: number){
+  const { resolve, promise } = Promise.withResolvers<void>();
+  let to = setTimeout(resolve, maxTimeout);
+
+  return {
+    promise,
+    heartBeat: ()=>{
+      clearTimeout(to);
+      to = setTimeout(resolve, maxTimeout);
+    },
+    stop: ()=>{
+      clearTimeout(to);
+    }
+  }
+}
+
+class StateTracker {
+  constructor(
+    private state: RoomState,
+    private listeners: ProgressListeners,
+  ){}
+  set(newState: RoomState){
+    this.state = newState;
+    this.listeners.onState?.(newState.state);
+  }
+  get(){
+    return this.state;
+  }
+}

package/src/handle-room/version-1/room-handler-bridge/ws-handler.ts

@@ -0,0 +1,30 @@
+
+
+import { MessageBridge } from "@roster-lock/utils";
+import { WebSocketHandlerCallback } from "../../../utils/websocket-router";
+import { castRoomRequest, exchangeAndDownloadSelections } from "./exchange-and-download-selections";
+import { V1Env } from "../globals/types";
+
+export const wsHandler: WebSocketHandlerCallback = async function(
+  this: V1Env, { ws: gameWebSocket }, params, next
+){
+  const { fileDB, pluginRuntime } = this;
+  try {
+    const gameBridge = new MessageBridge((message)=>gameWebSocket.send(JSON.stringify(message)));
+    gameWebSocket.on("message", (message)=>{
+      gameBridge.handleMessage(JSON.parse(message.toString()));
+    });
+    gameBridge.onRequest("connect-to-relay", async (roomInfo)=>{
+      const roomRequest = castRoomRequest(roomInfo);
+      return await exchangeAndDownloadSelections(fileDB, pluginRuntime, roomRequest, {
+        onState: (state)=>{gameBridge.sendEvent("room-state", state)},
+        onDownloadProgress: (event)=>{gameBridge.sendEvent("download-progress", event)},
+      });
+    });
+    gameBridge.sendEvent("ready", {});
+  }catch(e){
+    gameWebSocket.terminate();
+    next(e)
+  }
+}
+

package/src/handle-room/version-1/room-handler-state/RoomState.ts

@@ -0,0 +1,132 @@
+import {
+  JSON_Unknown,
+} from "@roster-lock/utils";
+import {
+  RosterLockV1Config,
+  FinalSelection,
+  UserInput,
+} from "@roster-lock/types";
+import { MATCHLOCK_SELECTION_STATE, UserMessegeError } from "../constants";
+import { IRoom } from "../globals/Room";
+import { deepEqual } from "node:assert";
+import { validateUnknown } from "../validateUnknown";
+
+import { decryptJSON, encryptJSON, encryptedSchema } from "../handleRoomSelections/encryption";
+import { userInputSchema, finalizeSelection, finalSelectionSchema } from "./user-selection";
+import { PluginHandler } from "@roster-lock/plugin-runtime";
+
+const STATE_ORDER = [
+  MATCHLOCK_SELECTION_STATE.hello,
+  MATCHLOCK_SELECTION_STATE.lockConfig,
+  MATCHLOCK_SELECTION_STATE.selectionEncrypt,
+  MATCHLOCK_SELECTION_STATE.selectionDecrypt,
+  MATCHLOCK_SELECTION_STATE.selectionFinal,
+  MATCHLOCK_SELECTION_STATE.goodbye,
+];
+
+export class RoomState {
+  private state: MATCHLOCK_SELECTION_STATE = MATCHLOCK_SELECTION_STATE.hello;
+  private recievedMessages = new Map<MATCHLOCK_SELECTION_STATE, Set<string>>();
+
+  encryptedData = new Map<string, string>();
+  userSelections = new Map<string, UserInput>();
+  agreedSelection: FinalSelection | null = null;
+
+  constructor(
+    public room: IRoom,
+    public lockConfig: RosterLockV1Config,
+    public ownEncrypted: Awaited<ReturnType<typeof encryptJSON>>,
+    public pluginRuntime: PluginHandler
+  ){}
+
+  validateMessageState(
+    userId: string,
+    messageState: MATCHLOCK_SELECTION_STATE
+  ){
+    if(this.state !== messageState){
+      const currentIndex = STATE_ORDER.indexOf(this.state);
+      const messageIndex = STATE_ORDER.indexOf(messageState);
+      if(messageIndex === currentIndex + 1){
+        console.warn(`User Sent ${messageState} Early`, userId);
+        console.warn("We'll still process it as other messages may just be late");
+      } else {
+        throw new UserMessegeError(userId, `Expected ${this.state} message`);
+      }
+    }
+    if(!this.recievedMessages.has(messageState)){
+      this.recievedMessages.set(messageState, new Set());
+    }
+    if(this.recievedMessages.get(messageState)!.has(userId)){
+      throw new UserMessegeError(userId, "User Sent Message Twice");
+    }
+    this.recievedMessages.get(messageState)!.add(userId);
+    return this.recievedMessages.get(messageState)!.size;
+  }
+
+  updateStep(){
+    const currentIndex = STATE_ORDER.indexOf(this.state);
+    const nextIndex = currentIndex + 1;
+    if (nextIndex >= STATE_ORDER.length) {
+      throw new Error("No next phase after " + this.state);
+    }
+    this.state = STATE_ORDER[nextIndex];
+  }
+
+  stateHandlers: Record<string, {
+    message?(userId: string, data: JSON_Unknown):any,
+    finished():any
+  }> = {
+    [MATCHLOCK_SELECTION_STATE.hello]: {
+      finished: ()=>(
+        this.room.broadcast(MATCHLOCK_SELECTION_STATE.lockConfig, this.lockConfig)
+      ),
+    },
+    [MATCHLOCK_SELECTION_STATE.lockConfig]: {
+      message: (userId, data)=>{
+        deepEqual(data, this.lockConfig, "Restriction Mismatch")
+      },
+      finished: ()=>(
+        this.room.broadcast(MATCHLOCK_SELECTION_STATE.selectionEncrypt, this.ownEncrypted.encryptedValue)
+      )
+    },
+    [MATCHLOCK_SELECTION_STATE.selectionEncrypt]: {
+      message: (userId, data)=>{
+        const casted = validateUnknown(encryptedSchema, data);
+        this.encryptedData.set(userId, casted);
+      },
+      finished: ()=>(
+        this.room.broadcast(MATCHLOCK_SELECTION_STATE.selectionDecrypt, this.ownEncrypted.key)
+      )
+    },
+    [MATCHLOCK_SELECTION_STATE.selectionDecrypt]: {
+      message: async (userId, data)=>{
+        if(typeof data !== "string") throw new Error("Invalid Decryption Key");
+        const encrypted = this.encryptedData.get(userId);
+        if(!encrypted) throw new Error("Missing Encrypted Data");
+        const decrypted = await decryptJSON(data, encrypted);
+        const casted = await validateUnknown(userInputSchema, decrypted);
+        this.userSelections.set(userId, casted);
+      },
+      finished: async ()=>{
+        const ownFinalSelection = await finalizeSelection(
+          this.lockConfig, {}, Object.fromEntries(this.userSelections), this.pluginRuntime
+        );
+        this.agreedSelection = ownFinalSelection;
+        this.room.broadcast(MATCHLOCK_SELECTION_STATE.selectionFinal, ownFinalSelection)
+      }
+    },
+    [MATCHLOCK_SELECTION_STATE.selectionFinal]: {
+      message: (userId, data)=>{
+        const casted: FinalSelection = validateUnknown(finalSelectionSchema, data);
+        deepEqual(this.agreedSelection, casted, "Final Selection Mismatch");
+      },
+      finished: ()=>(
+        this.room.broadcast(MATCHLOCK_SELECTION_STATE.goodbye, "goodbye")
+      )
+    },
+    [MATCHLOCK_SELECTION_STATE.goodbye]: {
+      finished: ()=>{},
+    }
+  }
+}
+

package/src/handle-room/version-1/room-handler-state/bind-to-websocket.ts

@@ -0,0 +1,93 @@
+import { UserInput } from "@roster-lock/types";
+import { ROSTERLOCK_V1_CASTER_JSONSCHEMA } from "@roster-lock/shared";
+import { z, ZodType } from "zod";
+import { getSQLite3FolderDB } from "../globals/FolderDB";
+import { WebsocketRoom } from "../globals/Room";
+import { MessageBridge } from "@roster-lock/utils";
+import { WebSocket } from "ws";
+import { tryToHandleRoomVersion1 } from "./handleRoomWithErrors";
+import { UserSelectionSchema } from "../schema/selected";
+
+/*
+Flow
+- user interacts with matchmaker
+- matchmaker creates room in relay server
+- matchmaker provides room id to user
+- user connects to room
+  - How does the relay room know it's the user
+  - Signed GET parameter?
+- User needs to know all the other users public keys
+- User needs to know their own private key
+*/
+
+
+type RoomRequest = {
+  folder: string,
+  relay: {
+    url: string,
+    roomId: string,
+  },
+  user: {
+    timestamp: number,
+    publicKey: string,
+    signature: string,
+  },
+  rosterConfig: any,
+  userSelection: UserInput["userSelection"],
+}
+
+
+
+const RequestCaster: ZodType<RoomRequest> = z.object({
+  folder: z.string(),
+  relay: z.object({
+    url: z.string(),
+    roomId: z.string(),
+  }),
+  user: z.object({
+    timestamp: z.number(),
+    publicKey: z.string(),
+    signature: z.string(),
+  }),
+  rosterConfig: z.any(),
+  userSelection: UserSelectionSchema,
+}).strict();
+
+
+export const bindRawStateToWebsocket = async (gameWebSocket: WebSocket)=>{
+  const messageBridge = new MessageBridge((message)=>gameWebSocket.send(JSON.stringify(message)));
+  gameWebSocket.on("message", (message)=>{
+    messageBridge.handleMessage(JSON.parse(message.toString()));
+  });
+  try {
+    const roomInfo = await messageBridge.sendRequest("roomInfo", {});
+
+    const parsed = RequestCaster.safeParse(roomInfo);
+    if(!parsed.success) throw new Error("Invalid request");
+    const roomRequest = parsed.data;
+    const config = ROSTERLOCK_V1_CASTER_JSONSCHEMA.cast(roomRequest.rosterConfig, true);
+    const db = getSQLite3FolderDB(roomRequest.folder);
+
+    const room = new WebsocketRoom(roomRequest.relay, roomRequest.user);
+    await room.readyPromise;
+
+    const results = await tryToHandleRoomVersion1(db, room, config, roomRequest.userSelection);
+
+    await messageBridge.sendRequest("roomComplete", results);
+    room.disconnect();
+  }catch(e){
+    console.error(e);
+    await messageBridge.sendRequest("roomFailed", (e as Error).message);
+  }finally{
+    gameWebSocket.close();
+  }
+}
+
+class WebsocketMessageBridge extends MessageBridge {
+  constructor(private websocket: WebSocket){
+    super((message)=>websocket.send(JSON.stringify(message)));
+    this.websocket.on("message", (message)=>{
+      this.handleMessage(JSON.parse(message.toString()));
+    });
+  }
+}

package/src/handle-room/version-1/room-handler-state/handleRoomSelections.ts

@@ -0,0 +1,71 @@
+import { MATCHLOCK_SELECTION_STATE } from "../constants";
+import {
+  encryptJSON, decryptJSON,
+} from "../handleRoomSelections/encryption";
+import { createRandomSeed } from "../handleRoomSelections/random";
+import { RosterLockV1Config, UserInput, FinalSelection } from "@roster-lock/types";
+import { IRoom } from "../globals/Room/room";
+import { RoomState } from "./RoomState";
+
+export async function handleRoomSelections(
+  room: IRoom,
+  abortSignal: AbortSignal,
+  restriction: RosterLockV1Config,
+  selection: UserInput["userSelection"],
+){
+
+  const rngSeed = createRandomSeed();
+  const ownEncrypted = await encryptJSON({ selection, rngSeed })
+
+  if(abortSignal.aborted){
+    return Promise.reject(new Error("Aborted"));
+  }
+
+  const roomState = new RoomState(
+    room, restriction, ownEncrypted
+  );
+
+  const { promise, resolve, reject } = Promise.withResolvers<FinalSelection>();
+
+  // Send our "hello" after we start listening
+  Promise.resolve().then(async ()=>{
+    room.broadcast(MATCHLOCK_SELECTION_STATE.hello, "hello");
+  });
+  const stopListeningToRoom = room.listen(async (userId, event, data)=>{
+    try {
+      if(!(event in roomState.stateHandlers )){
+        return;
+      }
+      // ensure the message wasn't sent twice and event is in order
+      const count = roomState.validateMessageState(userId, event as MATCHLOCK_SELECTION_STATE);
+      const { message, finished } = roomState.stateHandlers[event];
+      // If there is a message handler, run it
+      await message?.(userId, data);
+      // If we haven't heard from everyone, exit
+      if(count < room.numberOfUsers) return;
+      // Update the room step
+      roomState.updateStep();
+      // Run the finished handler which includes broadcasting the next step
+      await finished();
+
+      // If we're in the goodbye state, we're done
+      if(event !== MATCHLOCK_SELECTION_STATE.goodbye) return;
+      if(!roomState.agreedSelection) throw new Error("Missing Agreed FInal Selection");
+      resolve(roomState.agreedSelection!);
+    }catch(e){
+      reject(e);
+    }
+  });
+
+  promise.finally(()=>{
+    stopListeningToRoom();
+  });
+
+  abortSignal.addEventListener("abort", ()=>(
+    reject(new Error("Aborted"))
+  ));
+
+  return promise;
+
+}
+