zapo-js 0.1.2 → 0.3.0

package/dist/esm/signal/session/resolver.js

@@ -1,33 +1,44 @@
 import { toSerializedPubKey } from '../../crypto/core/keys.js';
-import { normalizeDeviceJid, parseSignalAddressFromJid } from '../../protocol/jid.js';
-import { uint8Equal } from '../../util/bytes.js';
+import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
+import { normalizeDeviceJid, parseSignalAddressFromJid, signalAddressKey } from '../../protocol/jid.js';
+import { bytesToHex, uint8Equal } from '../../util/bytes.js';
 import { toError } from '../../util/primitives.js';
 export function createSignalSessionResolver(options) {
-    const { signalProtocol, signalStore, signalIdentitySync, signalSessionSync, logger } = options;
-    const ensureSession = async (address, jid, expectedIdentity, reasonIdentity = false) => {
+    const { signalProtocol, sessionStore, identityStore, signalIdentitySync, signalSessionSync, logger } = options;
+    const dedup = new PromiseDedup();
+    const ensureSessionInternal = async (address, jid, expectedIdentity, reasonIdentity = false, prefetchedBundle) => {
         const expectedSerializedIdentity = expectedIdentity
             ? toSerializedPubKey(expectedIdentity)
             : null;
         if (reasonIdentity) {
             await signalIdentitySync.syncIdentityKeys([jid]);
         }
-        if (await signalProtocol.hasSession(address)) {
+        if (await sessionStore.hasSession(address)) {
             if (expectedSerializedIdentity) {
-                const storedIdentity = await signalStore.getRemoteIdentity(address);
+                const storedIdentity = await identityStore.getRemoteIdentity(address);
                 if (!storedIdentity || !uint8Equal(storedIdentity, expectedSerializedIdentity)) {
                     throw new Error('identity mismatch');
                 }
             }
-            return;
+            return null;
+        }
+        let fetched;
+        if (prefetchedBundle) {
+            fetched = {
+                jid,
+                bundle: prefetchedBundle
+            };
+        }
+        else {
+            logger.info('signal session missing, fetching remote key bundle', { jid });
+            fetched = await signalSessionSync.fetchKeyBundle({
+                jid,
+                reasonIdentity
+            });
         }
-        logger.info('signal session missing, fetching remote key bundle', { jid });
-        const fetched = await signalSessionSync.fetchKeyBundle({
-            jid,
-            reasonIdentity
-        });
         const remoteIdentity = toSerializedPubKey(fetched.bundle.identity);
         if (reasonIdentity) {
-            const storedIdentity = await signalStore.getRemoteIdentity(address);
+            const storedIdentity = await identityStore.getRemoteIdentity(address);
             if (storedIdentity && !uint8Equal(remoteIdentity, storedIdentity)) {
                 throw new Error('identity mismatch');
             }
@@ -35,35 +46,49 @@ export function createSignalSessionResolver(options) {
         if (expectedSerializedIdentity && !uint8Equal(remoteIdentity, expectedSerializedIdentity)) {
             throw new Error('identity mismatch');
         }
-        await signalProtocol.establishOutgoingSession(address, fetched.bundle);
+        const session = await signalProtocol.establishOutgoingSession(address, fetched.bundle, {
+            reuseExisting: true
+        });
         logger.info('signal session synchronized', {
             jid,
             regId: fetched.bundle.regId,
             hasOneTimeKey: fetched.bundle.oneTimeKey !== undefined
         });
+        return session;
+    };
+    const ensureSessionWithDedup = (address, jid, expectedIdentity, reasonIdentity = false, prefetchedBundle) => {
+        const expectedIdentityKey = expectedIdentity ? bytesToHex(expectedIdentity) : 'none';
+        const dedupKey = `signalSession:${signalAddressKey(address)}:${reasonIdentity ? '1' : '0'}:${expectedIdentityKey}`;
+        return dedup.run(dedupKey, () => ensureSessionInternal(address, jid, expectedIdentity, reasonIdentity, prefetchedBundle));
     };
+    const ensureSession = (address, jid, expectedIdentity, reasonIdentity = false) => ensureSessionWithDedup(address, jid, expectedIdentity, reasonIdentity).then(() => { });
     const ensureSessionsBatch = async (targetJids, expectedIdentityByJid) => {
         const seenTargetJids = new Set();
-        const normalizedTargetJids = [];
-        const normalizedTargetAddresses = [];
+        const normalizedTargetJids = new Array(targetJids.length);
+        const normalizedTargetAddresses = new Array(targetJids.length);
+        let normalizedTargetCount = 0;
         for (let index = 0; index < targetJids.length; index += 1) {
             const jid = normalizeDeviceJid(targetJids[index]);
             if (seenTargetJids.has(jid)) {
                 continue;
             }
             seenTargetJids.add(jid);
-            normalizedTargetJids.push(jid);
-            normalizedTargetAddresses.push(parseSignalAddressFromJid(jid));
+            normalizedTargetJids[normalizedTargetCount] = jid;
+            normalizedTargetAddresses[normalizedTargetCount] = parseSignalAddressFromJid(jid);
+            normalizedTargetCount += 1;
         }
-        if (normalizedTargetJids.length === 0) {
-            return;
+        if (normalizedTargetCount === 0) {
+            return [];
         }
+        normalizedTargetJids.length = normalizedTargetCount;
+        normalizedTargetAddresses.length = normalizedTargetCount;
         const normalizedExpectedIdentityByJid = expectedIdentityByJid && expectedIdentityByJid.size > 0
             ? new Map()
             : undefined;
         if (normalizedExpectedIdentityByJid && expectedIdentityByJid) {
             for (const [jid, identity] of expectedIdentityByJid.entries()) {
                 try {
+                    toSerializedPubKey(identity);
                     normalizedExpectedIdentityByJid.set(normalizeDeviceJid(jid), identity);
                 }
                 catch (error) {
@@ -71,113 +96,123 @@ export function createSignalSessionResolver(options) {
                 }
             }
         }
-        const hasSessions = await signalProtocol.hasSessions(normalizedTargetAddresses);
-        if (normalizedExpectedIdentityByJid) {
-            const identityAddresses = [];
-            const expectedSerializedIdentities = [];
+        const resolvedByIndex = (await sessionStore.getSessionsBatch(normalizedTargetAddresses));
+        const collectResolvedTargets = () => {
+            const resolvedTargets = new Array(normalizedTargetJids.length);
+            let resolvedTargetCount = 0;
             for (let index = 0; index < normalizedTargetJids.length; index += 1) {
-                if (!hasSessions[index]) {
+                const session = resolvedByIndex[index];
+                if (!session) {
                     continue;
                 }
-                const expectedIdentity = normalizedExpectedIdentityByJid.get(normalizedTargetJids[index]);
-                if (!expectedIdentity) {
-                    continue;
-                }
-                identityAddresses.push(normalizedTargetAddresses[index]);
-                expectedSerializedIdentities.push(toSerializedPubKey(expectedIdentity));
+                resolvedTargets[resolvedTargetCount] = {
+                    jid: normalizedTargetJids[index],
+                    address: normalizedTargetAddresses[index],
+                    session
+                };
+                resolvedTargetCount += 1;
             }
-            const storedIdentities = await signalStore.getRemoteIdentities(identityAddresses);
-            for (let index = 0; index < storedIdentities.length; index += 1) {
-                const storedIdentity = storedIdentities[index];
-                if (!storedIdentity ||
-                    !uint8Equal(storedIdentity, expectedSerializedIdentities[index])) {
+            resolvedTargets.length = resolvedTargetCount;
+            return resolvedTargets;
+        };
+        const missingIndices = [];
+        for (let index = 0; index < normalizedTargetJids.length; index += 1) {
+            const session = resolvedByIndex[index];
+            const expectedIdentity = normalizedExpectedIdentityByJid?.get(normalizedTargetJids[index]);
+            if (session && expectedIdentity) {
+                if (!uint8Equal(session.remote.pubKey, toSerializedPubKey(expectedIdentity))) {
                     throw new Error('identity mismatch');
                 }
             }
-        }
-        const missingIndices = [];
-        for (let index = 0; index < normalizedTargetJids.length; index += 1) {
-            if (!hasSessions[index]) {
+            if (!session) {
                 missingIndices.push(index);
             }
         }
         if (missingIndices.length === 0) {
-            return;
+            return collectResolvedTargets();
+        }
+        const batchRequest = new Array(missingIndices.length);
+        for (let index = 0; index < missingIndices.length; index += 1) {
+            batchRequest[index] = { jid: normalizedTargetJids[missingIndices[index]] };
         }
+        let batchResults;
         try {
-            const batchRequest = [];
-            for (let index = 0; index < missingIndices.length; index += 1) {
-                batchRequest.push({ jid: normalizedTargetJids[missingIndices[index]] });
-            }
-            const batchResults = await signalSessionSync.fetchKeyBundles(batchRequest);
-            const fallbackIndices = [];
-            const establishedIndices = [];
-            const establishPromises = [];
-            for (let index = 0; index < missingIndices.length; index += 1) {
-                const targetIndex = missingIndices[index];
-                const result = batchResults[index];
-                if (!result || !('bundle' in result)) {
-                    fallbackIndices.push(targetIndex);
-                    continue;
-                }
-                const targetJid = normalizedTargetJids[targetIndex];
-                const expectedIdentity = normalizedExpectedIdentityByJid?.get(targetJid);
-                const remoteIdentity = toSerializedPubKey(result.bundle.identity);
-                if (expectedIdentity &&
-                    !uint8Equal(remoteIdentity, toSerializedPubKey(expectedIdentity))) {
-                    throw new Error('identity mismatch');
-                }
-                establishedIndices.push(targetIndex);
-                establishPromises.push(signalProtocol
-                    .establishOutgoingSession(normalizedTargetAddresses[targetIndex], result.bundle)
-                    .then(() => {
-                    logger.debug('signal session synchronized from batch key fetch', {
-                        jid: targetJid,
-                        regId: result.bundle.regId,
-                        hasOneTimeKey: result.bundle.oneTimeKey !== undefined
-                    });
-                }));
+            batchResults = await signalSessionSync.fetchKeyBundles(batchRequest);
+        }
+        catch (error) {
+            logger.warn('signal batch key fetch failed', {
+                requested: missingIndices.length,
+                message: toError(error).message
+            });
+            return collectResolvedTargets();
+        }
+        const ensuredTargetIndices = new Array(missingIndices.length);
+        const ensurePromises = new Array(missingIndices.length);
+        let ensureCount = 0;
+        for (let index = 0; index < missingIndices.length; index += 1) {
+            const targetIndex = missingIndices[index];
+            const targetJid = normalizedTargetJids[targetIndex];
+            const batchResult = batchResults[index];
+            if (!batchResult?.bundle) {
+                logger.warn('signal batch key fetch returned target without bundle', {
+                    jid: targetJid,
+                    message: batchResult?.errorText ?? 'missing key bundle user in response'
+                });
+                continue;
             }
-            const establishmentResults = await Promise.allSettled(establishPromises);
-            for (let index = 0; index < establishmentResults.length; index += 1) {
-                const result = establishmentResults[index];
-                if (result.status === 'fulfilled') {
-                    continue;
-                }
-                const error = toError(result.reason);
-                if (error.message === 'identity mismatch') {
-                    throw error;
+            const expectedIdentity = normalizedExpectedIdentityByJid?.get(targetJid);
+            ensuredTargetIndices[ensureCount] = targetIndex;
+            ensurePromises[ensureCount] = ensureSessionWithDedup(normalizedTargetAddresses[targetIndex], targetJid, expectedIdentity, false, batchResult.bundle);
+            ensureCount += 1;
+        }
+        if (ensureCount === 0) {
+            return collectResolvedTargets();
+        }
+        ensuredTargetIndices.length = ensureCount;
+        ensurePromises.length = ensureCount;
+        const ensureResults = await Promise.allSettled(ensurePromises);
+        const fallbackIndices = [];
+        for (let index = 0; index < ensuredTargetIndices.length; index += 1) {
+            const targetIndex = ensuredTargetIndices[index];
+            const ensureResult = ensureResults[index];
+            if (ensureResult.status === 'rejected') {
+                const normalized = toError(ensureResult.reason);
+                if (normalized.message === 'identity mismatch') {
+                    throw normalized;
                 }
-                fallbackIndices.push(establishedIndices[index]);
+                logger.warn('signal session ensure failed during batch resolution', {
+                    jid: normalizedTargetJids[targetIndex],
+                    message: normalized.message
+                });
+                continue;
             }
-            if (fallbackIndices.length === 0) {
-                return;
+            const session = ensureResult.value;
+            if (session) {
+                resolvedByIndex[targetIndex] = session;
             }
-            logger.warn('signal batch key fetch returned partial errors, falling back to single requests', {
-                requested: missingIndices.length,
-                fallbackTargets: fallbackIndices.length
-            });
-            for (let index = 0; index < fallbackIndices.length; index += 1) {
-                const targetIndex = fallbackIndices[index];
-                const jid = normalizedTargetJids[targetIndex];
-                await ensureSession(normalizedTargetAddresses[targetIndex], jid, normalizedExpectedIdentityByJid?.get(jid));
+            else {
+                fallbackIndices.push(targetIndex);
             }
         }
-        catch (error) {
-            const normalized = toError(error);
-            if (normalized.message === 'identity mismatch') {
-                throw normalized;
+        if (fallbackIndices.length > 0) {
+            const fallbackAddresses = new Array(fallbackIndices.length);
+            for (let i = 0; i < fallbackIndices.length; i++) {
+                fallbackAddresses[i] = normalizedTargetAddresses[fallbackIndices[i]];
             }
-            logger.warn('signal batch key fetch failed, falling back to single requests', {
-                requested: missingIndices.length,
-                message: normalized.message
-            });
-            for (let index = 0; index < missingIndices.length; index += 1) {
-                const targetIndex = missingIndices[index];
-                const jid = normalizedTargetJids[targetIndex];
-                await ensureSession(normalizedTargetAddresses[targetIndex], jid, normalizedExpectedIdentityByJid?.get(jid));
+            const fallbackSessions = await sessionStore.getSessionsBatch(fallbackAddresses);
+            for (let i = 0; i < fallbackIndices.length; i++) {
+                const session = fallbackSessions[i];
+                if (session) {
+                    resolvedByIndex[fallbackIndices[i]] = session;
+                }
+                else {
+                    logger.warn('signal session ensure completed without persisted session', {
+                        jid: normalizedTargetJids[fallbackIndices[i]]
+                    });
+                }
             }
         }
+        return collectResolvedTargets();
     };
     return {
         ensureSession,

package/dist/esm/store/contracts/identity.store.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/store/contracts/message-secret.store.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/store/contracts/pre-key.store.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/store/contracts/privacy-token.store.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/store/contracts/session.store.js

@@ -0,0 +1 @@
+export {};