Add MLS Queue service

packages/sdk/src/client.ts

@@ -152,7 +152,7 @@ import { SignerContext } from './signerContext'
 import { decryptAESGCM, deriveKeyAndIV, encryptAESGCM, uint8ArrayToBase64 } from './crypto_utils'
 import { makeTags, makeTipTags } from './tags'
 import { TipEventObject } from '@river-build/generated/dev/typings/ITipping'
-import { extractMlsExternalGroup } from './mls/utils/mlsutils'
+import { extractMlsExternalGroup, ExtractMlsExternalGroupResult } from './mls/utils/mlsutils'
 
 export type ClientEvents = StreamEvents & DecryptionEvents
 
@@ -2527,11 +2527,9 @@ export class Client
         })
     }
 
-    public async getMlsExternalGroupInfo(streamId: string): Promise<{
-        externalGroupSnapshot: Uint8Array
-        groupInfoMessage: Uint8Array
-        commits: { commit: Uint8Array; groupInfoMessage: Uint8Array }[]
-    }> {
+    public async getMlsExternalGroupInfo(
+        streamId: string,
+    ): Promise<ExtractMlsExternalGroupResult | undefined> {
         let streamView = this.stream(streamId)?.view
         if (!streamView || !streamView.isInitialized) {
             streamView = await this.getStream(streamId)

packages/sdk/src/mls/coordinator/awaiter.ts

@@ -0,0 +1,45 @@
+export interface IAwaiter {
+    promise: Promise<void>
+    resolve: () => void
+}
+
+export class NoopAwaiter implements IAwaiter {
+    public promise = Promise.resolve()
+    public resolve = () => {}
+}
+
+export class IndefiniteAwaiter implements IAwaiter {
+    public promise: Promise<void>
+    public resolve!: () => void
+
+    public constructor() {
+        this.promise = new Promise((resolve) => {
+            this.resolve = resolve
+        })
+    }
+}
+
+export class TimeoutAwaiter implements IAwaiter {
+    // top level promise
+    public promise: Promise<void>
+    // resolve handler to the inner promise
+    public resolve!: () => void
+    public constructor(timeoutMS: number, msg: string = 'Awaiter timed out') {
+        let timeout: NodeJS.Timeout
+        const timeoutPromise = new Promise<never>((_resolve, reject) => {
+            timeout = setTimeout(() => {
+                reject(new Error(msg))
+            }, timeoutMS)
+        })
+        const internalPromise: Promise<void> = new Promise(
+            (resolve: (value: void) => void, _reject) => {
+                this.resolve = () => {
+                    resolve()
+                }
+            },
+        ).finally(() => {
+            clearTimeout(timeout)
+        })
+        this.promise = Promise.race([internalPromise, timeoutPromise])
+    }
+}