zapo-js 0.1.1 → 0.1.2

package/dist/protocol/jid.js

@@ -11,36 +11,57 @@ exports.toUserJid = toUserJid;
 exports.normalizeDeviceJid = normalizeDeviceJid;
 exports.getLoginIdentity = getLoginIdentity;
 exports.parsePhoneJid = parsePhoneJid;
+exports.signalAddressKey = signalAddressKey;
 const constants_1 = require("./constants");
-function splitJid(jid) {
-    const atIndex = jid.indexOf('@');
-    if (atIndex < 1 || atIndex >= jid.length - 1) {
-        throw new Error(`invalid jid: ${jid}`);
+function scanJid(jid) {
+    let atIndex = -1;
+    let colonIndex = -1;
+    let dotIndex = -1;
+    for (let index = 0; index < jid.length; index++) {
+        const code = jid.charCodeAt(index);
+        if (code === 64) {
+            atIndex = index;
+            break;
+        }
+        if (code === 58 && colonIndex === -1)
+            colonIndex = index;
+        else if (code === 46 && dotIndex === -1 && colonIndex === -1)
+            dotIndex = index;
     }
-    return {
-        user: jid.slice(0, atIndex),
-        server: jid.slice(atIndex + 1)
-    };
+    if (atIndex < 1 || atIndex >= jid.length - 1)
+        throw new Error(`invalid jid: ${jid}`);
+    return { atIndex, colonIndex, dotIndex };
+}
+function splitJid(jid) {
+    const { atIndex } = scanJid(jid);
+    return { user: jid.slice(0, atIndex), server: jid.slice(atIndex + 1) };
 }
 function normalizeRecipientJid(to) {
     const input = to.trim();
-    if (input.length === 0) {
+    if (input.length === 0)
         throw new Error('recipient cannot be empty');
+    let hasDash = false;
+    let digits = '';
+    for (let index = 0; index < input.length; index += 1) {
+        const code = input.charCodeAt(index);
+        if (code === 64)
+            return input;
+        if (code === 45) {
+            hasDash = true;
+            continue;
+        }
+        if (code >= 48 && code <= 57)
+            digits += input[index];
     }
-    if (input.includes('@')) {
-        return input;
-    }
-    if (input.includes('-')) {
+    if (hasDash)
         return `${input}@${constants_1.WA_DEFAULTS.GROUP_SERVER}`;
-    }
-    const digits = input.replace(/\D/g, '');
-    if (digits.length === 0) {
+    if (digits.length === 0)
         throw new Error(`invalid recipient: ${to}`);
-    }
     return `${digits}@${constants_1.WA_DEFAULTS.HOST_DOMAIN}`;
 }
 function isJidType(jid, type) {
-    return jid.endsWith(`@${type}`);
+    const atIndex = jid.length - type.length - 1;
+    return atIndex >= 1 && jid.charCodeAt(atIndex) === 64 && jid.endsWith(type);
 }
 function isGroupJid(jid) {
     return isJidType(jid, constants_1.WA_DEFAULTS.GROUP_SERVER);
@@ -52,26 +73,14 @@ function isGroupOrBroadcastJid(jid) {
     return isGroupJid(jid) || isBroadcastJid(jid);
 }
 function parseSignalAddressFromJid(jid) {
-    const parsed = splitJid(jid);
-    const colonIndex = parsed.user.indexOf(':');
-    if (colonIndex === -1) {
-        return {
-            user: parsed.user,
-            server: parsed.server,
-            device: 0
-        };
-    }
-    const user = parsed.user.slice(0, colonIndex);
-    const deviceRaw = parsed.user.slice(colonIndex + 1);
-    const device = Number.parseInt(deviceRaw, 10);
-    if (!Number.isFinite(device) || device < 0) {
+    const { atIndex, colonIndex } = scanJid(jid);
+    const server = jid.slice(atIndex + 1);
+    if (colonIndex === -1)
+        return { user: jid.slice(0, atIndex), server, device: 0 };
+    const device = Number.parseInt(jid.slice(colonIndex + 1, atIndex), 10);
+    if (!Number.isFinite(device) || device < 0)
         throw new Error(`invalid jid device: ${jid}`);
-    }
-    return {
-        user,
-        server: parsed.server,
-        device
-    };
+    return { user: jid.slice(0, colonIndex), server, device };
 }
 function toUserJid(jid) {
     const address = parseSignalAddressFromJid(jid);
@@ -79,29 +88,33 @@ function toUserJid(jid) {
 }
 function normalizeDeviceJid(jid) {
     const address = parseSignalAddressFromJid(jid);
-    if (address.device === 0) {
+    if (address.device === 0)
         return `${address.user}@${address.server}`;
-    }
     return `${address.user}:${address.device}@${address.server}`;
 }
 function getLoginIdentity(meJid) {
-    const parsed = splitJid(meJid);
-    const [userAndAgent, devicePart = '0'] = parsed.user.split(':');
-    const userPart = userAndAgent.split('.')[0];
-    const username = Number.parseInt(userPart, 10);
-    const device = Number.parseInt(devicePart, 10);
-    if (!Number.isSafeInteger(username) || username <= 0) {
+    const { atIndex, colonIndex, dotIndex } = scanJid(meJid);
+    const userEndIndex = dotIndex === -1 ? (colonIndex === -1 ? atIndex : colonIndex) : dotIndex;
+    const username = Number.parseInt(meJid.slice(0, userEndIndex), 10);
+    const device = colonIndex === -1 ? 0 : Number.parseInt(meJid.slice(colonIndex + 1, atIndex), 10);
+    if (!Number.isSafeInteger(username) || username <= 0)
         throw new Error(`invalid numeric username from ${meJid}`);
-    }
-    if (!Number.isSafeInteger(device) || device < 0) {
+    if (!Number.isSafeInteger(device) || device < 0)
         throw new Error(`invalid device from ${meJid}`);
-    }
     return { username, device };
 }
 function parsePhoneJid(input) {
-    const digits = input.replace(/\D+/g, '');
-    if (!digits) {
-        throw new Error('phone number is empty after normalization');
+    let digits = '';
+    for (let index = 0; index < input.length; index += 1) {
+        const code = input.charCodeAt(index);
+        if (code >= 48 && code <= 57)
+            digits += input[index];
     }
+    if (!digits)
+        throw new Error('phone number is empty after normalization');
     return `${digits}@${constants_1.WA_DEFAULTS.HOST_DOMAIN}`;
 }
+function signalAddressKey(address) {
+    const server = address.server ?? constants_1.WA_DEFAULTS.HOST_DOMAIN;
+    return `${address.user}|${server}|${address.device}`;
+}

package/dist/protocol/media.js

@@ -17,8 +17,8 @@ exports.WA_MEDIA_HKDF_INFO = Object.freeze({
 });
 exports.WA_PREVIEW_MEDIA_HKDF_INFO = 'Messenger Preview Keys';
 function getWaMediaHkdfInfo(mediaType) {
-    if (mediaType in exports.WA_MEDIA_HKDF_INFO) {
-        return exports.WA_MEDIA_HKDF_INFO[mediaType];
-    }
+    const info = exports.WA_MEDIA_HKDF_INFO[mediaType];
+    if (info !== undefined)
+        return info;
     throw new Error(`unsupported media type: ${mediaType}`);
 }

package/dist/protocol/nodes.js

@@ -26,6 +26,8 @@ exports.WA_NODE_TAGS = Object.freeze({
     KEY_FETCH: 'key_fetch',
     LIST: 'list',
     USER: 'user',
+    CONTACT: 'contact',
+    LID: 'lid',
     PICTURE: 'picture',
     PRIVACY: 'privacy',
     PARTICIPATING: 'participating',

package/dist/protocol/usync.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WA_USYNC_DEFAULTS = exports.WA_USYNC_CONTEXTS = exports.WA_USYNC_MODES = void 0;
+exports.WA_USYNC_MODES = Object.freeze({
+    QUERY: 'query'
+});
+exports.WA_USYNC_CONTEXTS = Object.freeze({
+    INTERACTIVE: 'interactive',
+    NOTIFICATION: 'notification'
+});
+exports.WA_USYNC_DEFAULTS = Object.freeze({
+    INDEX: '0',
+    LAST: 'true'
+});

package/dist/retry/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaRetryReplayService = exports.pickRetryStateMax = exports.encodeRetryReplayPayload = exports.decodeRetryReplayPayload = exports.parseRetryReceiptRequest = exports.mapRetryReasonFromError = exports.RETRY_RECEIPT_VERSION = exports.RETRY_REASON = exports.RETRY_OUTBOUND_TTL_MS = exports.RETRY_KEYS_MIN_COUNT = exports.MAX_RETRY_ATTEMPTS = void 0;
+exports.createOutboundRetryTracker = exports.WaRetryReplayService = exports.pickRetryStateMax = exports.encodeRetryReplayPayload = exports.decodeRetryReplayPayload = exports.parseRetryReceiptRequest = exports.mapRetryReasonFromError = exports.RETRY_RECEIPT_VERSION = exports.RETRY_REASON = exports.RETRY_OUTBOUND_TTL_MS = exports.RETRY_KEYS_MIN_COUNT = exports.MAX_RETRY_ATTEMPTS = void 0;
 var constants_1 = require("./constants");
 Object.defineProperty(exports, "MAX_RETRY_ATTEMPTS", { enumerable: true, get: function () { return constants_1.MAX_RETRY_ATTEMPTS; } });
 Object.defineProperty(exports, "RETRY_KEYS_MIN_COUNT", { enumerable: true, get: function () { return constants_1.RETRY_KEYS_MIN_COUNT; } });
@@ -17,3 +17,5 @@ Object.defineProperty(exports, "encodeRetryReplayPayload", { enumerable: true, g
 Object.defineProperty(exports, "pickRetryStateMax", { enumerable: true, get: function () { return outbound_1.pickRetryStateMax; } });
 var replay_1 = require("./replay");
 Object.defineProperty(exports, "WaRetryReplayService", { enumerable: true, get: function () { return replay_1.WaRetryReplayService; } });
+var tracker_1 = require("./tracker");
+Object.defineProperty(exports, "createOutboundRetryTracker", { enumerable: true, get: function () { return tracker_1.createOutboundRetryTracker; } });

package/dist/retry/outbound.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeRetryReplayPayload = encodeRetryReplayPayload;
 exports.decodeRetryReplayPayload = decodeRetryReplayPayload;
 exports.pickRetryStateMax = pickRetryStateMax;
-const base64_1 = require("../util/base64");
 const bytes_1 = require("../util/bytes");
 function requireObject(value) {
     if (!value || typeof value !== 'object') {
@@ -23,7 +22,7 @@ function encodeRetryReplayPayload(payload) {
             mode: payload.mode,
             to: payload.to,
             type: payload.type,
-            plaintext: (0, base64_1.bytesToBase64)(payload.plaintext)
+            plaintext: (0, bytes_1.bytesToBase64)(payload.plaintext)
         }
         : payload.mode === 'encrypted'
             ? {
@@ -31,12 +30,12 @@ function encodeRetryReplayPayload(payload) {
                 to: payload.to,
                 type: payload.type,
                 encType: payload.encType,
-                ciphertext: (0, base64_1.bytesToBase64)(payload.ciphertext),
+                ciphertext: (0, bytes_1.bytesToBase64)(payload.ciphertext),
                 participant: payload.participant
             }
             : {
                 mode: payload.mode,
-                node: (0, base64_1.bytesToBase64)(payload.node)
+                node: (0, bytes_1.bytesToBase64)(payload.node)
             };
     return bytes_1.TEXT_ENCODER.encode(JSON.stringify(serialized));
 }
@@ -49,7 +48,7 @@ function decodeRetryReplayPayload(raw) {
             mode,
             to: requireString(parsed.to, 'to'),
             type: requireString(parsed.type, 'type'),
-            plaintext: (0, base64_1.base64ToBytes)(requireString(parsed.plaintext, 'plaintext'), 'retry.plaintext')
+            plaintext: (0, bytes_1.base64ToBytesChecked)(requireString(parsed.plaintext, 'plaintext'), 'retry.plaintext')
         };
     }
     if (mode === 'encrypted') {
@@ -62,7 +61,7 @@ function decodeRetryReplayPayload(raw) {
             to: requireString(parsed.to, 'to'),
             type: requireString(parsed.type, 'type'),
             encType,
-            ciphertext: (0, base64_1.base64ToBytes)(requireString(parsed.ciphertext, 'ciphertext'), 'retry.ciphertext'),
+            ciphertext: (0, bytes_1.base64ToBytesChecked)(requireString(parsed.ciphertext, 'ciphertext'), 'retry.ciphertext'),
             participant: parsed.participant === undefined
                 ? undefined
                 : requireString(parsed.participant, 'participant')
@@ -71,7 +70,7 @@ function decodeRetryReplayPayload(raw) {
     if (mode === 'opaque_node') {
         return {
             mode,
-            node: (0, base64_1.base64ToBytes)(requireString(parsed.node, 'node'), 'retry.node')
+            node: (0, bytes_1.base64ToBytesChecked)(requireString(parsed.node, 'node'), 'retry.node')
         };
     }
     throw new Error(`invalid retry replay payload mode: ${mode}`);

package/dist/retry/parse.js

@@ -4,7 +4,7 @@ exports.parseRetryReceiptRequest = parseRetryReceiptRequest;
 const constants_1 = require("../protocol/constants");
 const constants_2 = require("../signal/api/constants");
 const helpers_1 = require("../transport/node/helpers");
-const parse_1 = require("../transport/stream/parse");
+const primitives_1 = require("../util/primitives");
 function parseFixedLengthBytes(value, byteLength, field) {
     const out = (0, helpers_1.decodeNodeContentBase64OrBytes)(value, field);
     if (out.byteLength !== byteLength) {
@@ -13,81 +13,62 @@ function parseFixedLengthBytes(value, byteLength, field) {
     return out;
 }
 function parseBigEndianUint(bytes, field) {
-    if (bytes.byteLength === 0 || bytes.byteLength > 4) {
-        throw new Error(`${field} has invalid byte length`);
+    switch (bytes.byteLength) {
+        case 1:
+            return bytes[0];
+        case 2:
+            return (bytes[0] << 8) | bytes[1];
+        case 3:
+            return ((bytes[0] << 16) | (bytes[1] << 8) | bytes[2]) >>> 0;
+        case 4:
+            return ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0;
+        default:
+            throw new Error(`${field} has invalid byte length`);
     }
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    if (bytes.byteLength === 1) {
-        return view.getUint8(0);
-    }
-    if (bytes.byteLength === 2) {
-        return view.getUint16(0);
-    }
-    return bytes.byteLength === 3 ? (view.getUint16(0) << 8) | view.getUint8(2) : view.getUint32(0);
-}
-function parseRetryType(value) {
-    if (value === 'retry' || value === 'enc_rekey_retry') {
-        return value;
-    }
-    return null;
 }
-function parseRetryCount(value) {
-    const parsed = (0, parse_1.parseOptionalInt)(value);
-    if (parsed === undefined) {
-        return 0;
-    }
-    if (parsed < 0) {
-        throw new Error('retry count must be >= 0');
-    }
-    return parsed;
-}
-function parseRetryReason(value) {
-    const parsed = (0, parse_1.parseOptionalInt)(value);
-    if (parsed === undefined) {
-        return undefined;
-    }
-    if (parsed < 0) {
-        throw new Error('retry reason must be >= 0');
+function requireNode(node, message) {
+    if (!node) {
+        throw new Error(message);
     }
-    return parsed;
+    return node;
 }
 function parseRetryKeyBundle(node) {
     if (!node) {
         return undefined;
     }
-    const identityNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.IDENTITY);
-    const signedKeyNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.SKEY);
-    if (!identityNode || !signedKeyNode) {
-        throw new Error('retry keys section missing identity or skey');
-    }
-    const signedKeyIdNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.ID);
-    const signedKeyValueNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.VALUE);
-    const signedKeySignatureNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.SIGNATURE);
-    if (!signedKeyIdNode || !signedKeyValueNode || !signedKeySignatureNode) {
-        throw new Error('retry keys section has incomplete skey');
-    }
-    const keyNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.KEY);
-    const keyIdNode = keyNode ? (0, helpers_1.findNodeChild)(keyNode, constants_1.WA_NODE_TAGS.ID) : undefined;
-    const keyValueNode = keyNode ? (0, helpers_1.findNodeChild)(keyNode, constants_1.WA_NODE_TAGS.VALUE) : undefined;
-    if (keyNode && (!keyIdNode || !keyValueNode)) {
-        throw new Error('retry keys section has incomplete key');
-    }
-    const deviceIdentityNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.DEVICE_IDENTITY);
+    const [identityNode, signedKeyNode, keyNode, deviceIdentityNode] = (0, helpers_1.findNodeChildrenByTags)(node, [constants_1.WA_NODE_TAGS.IDENTITY, constants_1.WA_NODE_TAGS.SKEY, constants_1.WA_NODE_TAGS.KEY, constants_1.WA_NODE_TAGS.DEVICE_IDENTITY]);
+    const identity = requireNode(identityNode, 'retry keys section missing identity or skey');
+    const signedKey = requireNode(signedKeyNode, 'retry keys section missing identity or skey');
+    const [signedKeyIdNode, signedKeyValueNode, signedKeySignatureNode] = (0, helpers_1.findNodeChildrenByTags)(signedKey, [constants_1.WA_NODE_TAGS.ID, constants_1.WA_NODE_TAGS.VALUE, constants_1.WA_NODE_TAGS.SIGNATURE]);
+    const signedKeyId = requireNode(signedKeyIdNode, 'retry keys section has incomplete skey');
+    const signedKeyValue = requireNode(signedKeyValueNode, 'retry keys section has incomplete skey');
+    const signedKeySignature = requireNode(signedKeySignatureNode, 'retry keys section has incomplete skey');
+    let keyIdNode;
+    let keyValueNode;
+    if (keyNode) {
+        const keyNodes = (0, helpers_1.findNodeChildrenByTags)(keyNode, [constants_1.WA_NODE_TAGS.ID, constants_1.WA_NODE_TAGS.VALUE]);
+        keyIdNode = keyNodes[0];
+        keyValueNode = keyNodes[1];
+    }
+    const keyId = keyNode ? requireNode(keyIdNode, 'retry keys section has incomplete key') : null;
+    const keyValue = keyNode
+        ? requireNode(keyValueNode, 'retry keys section has incomplete key')
+        : null;
     return {
-        identity: parseFixedLengthBytes(identityNode.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.identity'),
+        identity: parseFixedLengthBytes(identity.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.identity'),
         deviceIdentity: deviceIdentityNode
             ? (0, helpers_1.decodeNodeContentBase64OrBytes)(deviceIdentityNode.content, 'retry.keys.device-identity')
             : undefined,
-        key: keyIdNode && keyValueNode
+        key: keyId && keyValue
             ? {
-                id: parseBigEndianUint(parseFixedLengthBytes(keyIdNode.content, constants_2.SIGNAL_KEY_ID_LENGTH, 'retry.keys.key.id'), 'retry.keys.key.id'),
-                publicKey: parseFixedLengthBytes(keyValueNode.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.key.value')
+                id: parseBigEndianUint(parseFixedLengthBytes(keyId.content, constants_2.SIGNAL_KEY_ID_LENGTH, 'retry.keys.key.id'), 'retry.keys.key.id'),
+                publicKey: parseFixedLengthBytes(keyValue.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.key.value')
             }
             : undefined,
         skey: {
-            id: parseBigEndianUint(parseFixedLengthBytes(signedKeyIdNode.content, constants_2.SIGNAL_KEY_ID_LENGTH, 'retry.keys.skey.id'), 'retry.keys.skey.id'),
-            publicKey: parseFixedLengthBytes(signedKeyValueNode.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.skey.value'),
-            signature: parseFixedLengthBytes(signedKeySignatureNode.content, constants_2.SIGNAL_SIGNATURE_LENGTH, 'retry.keys.skey.signature')
+            id: parseBigEndianUint(parseFixedLengthBytes(signedKeyId.content, constants_2.SIGNAL_KEY_ID_LENGTH, 'retry.keys.skey.id'), 'retry.keys.skey.id'),
+            publicKey: parseFixedLengthBytes(signedKeyValue.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.skey.value'),
+            signature: parseFixedLengthBytes(signedKeySignature.content, constants_2.SIGNAL_SIGNATURE_LENGTH, 'retry.keys.skey.signature')
         }
     };
 }
@@ -95,7 +76,9 @@ function parseRetryReceiptRequest(node) {
     if (node.tag !== constants_1.WA_MESSAGE_TAGS.RECEIPT) {
         return null;
     }
-    const receiptType = parseRetryType(node.attrs.type);
+    const receiptType = node.attrs.type === 'retry' || node.attrs.type === 'enc_rekey_retry'
+        ? node.attrs.type
+        : null;
     if (!receiptType) {
         return null;
     }
@@ -104,19 +87,18 @@ function parseRetryReceiptRequest(node) {
     if (!stanzaId || !from) {
         throw new Error('retry receipt is missing id/from attrs');
     }
-    const retryNode = (0, helpers_1.findNodeChild)(node, 'retry');
-    if (!retryNode) {
-        throw new Error('retry receipt is missing retry child');
-    }
-    const registrationNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.REGISTRATION);
-    if (!registrationNode) {
-        throw new Error('retry receipt is missing registration child');
-    }
-    const originalMsgId = retryNode.attrs.id;
+    const [retryNode, registrationNode, keysNode] = (0, helpers_1.findNodeChildrenByTags)(node, [
+        'retry',
+        constants_1.WA_NODE_TAGS.REGISTRATION,
+        'keys'
+    ]);
+    const retry = requireNode(retryNode, 'retry receipt is missing retry child');
+    const registrationNodeValue = requireNode(registrationNode, 'retry receipt is missing registration child');
+    const originalMsgId = retry.attrs.id;
     if (!originalMsgId) {
         throw new Error('retry receipt is missing retry.id');
     }
-    const registration = parseFixedLengthBytes(registrationNode.content, constants_2.SIGNAL_REGISTRATION_ID_LENGTH, 'retry.registration');
+    const registration = parseFixedLengthBytes(registrationNodeValue.content, constants_2.SIGNAL_REGISTRATION_ID_LENGTH, 'retry.registration');
     return {
         type: receiptType,
         stanzaId,
@@ -124,10 +106,10 @@ function parseRetryReceiptRequest(node) {
         participant: node.attrs.participant,
         recipient: node.attrs.recipient,
         originalMsgId,
-        retryCount: parseRetryCount(retryNode.attrs.count),
-        retryReason: parseRetryReason(retryNode.attrs.error ?? node.attrs.error),
-        t: retryNode.attrs.t ?? node.attrs.t,
+        retryCount: (0, primitives_1.parseOptionalInt)(retry.attrs.count) ?? 0,
+        retryReason: (0, primitives_1.parseOptionalInt)(retry.attrs.error ?? node.attrs.error),
+        t: retry.attrs.t ?? node.attrs.t,
         regId: parseBigEndianUint(registration, 'retry.registration'),
-        keyBundle: parseRetryKeyBundle((0, helpers_1.findNodeChild)(node, 'keys'))
+        keyBundle: parseRetryKeyBundle(keysNode)
     };
 }

package/dist/retry/replay.js

@@ -16,17 +16,19 @@ class WaRetryReplayService {
     }
     async resendOutboundMessage(outbound, requesterJid, retryCount) {
         const payload = (0, outbound_1.decodeRetryReplayPayload)(outbound.replayPayload);
+        const requesterAddress = (0, jid_1.parseSignalAddressFromJid)(requesterJid);
+        const normalizedRequesterJid = (0, jid_1.normalizeDeviceJid)(requesterJid);
         if (payload.mode === 'plaintext') {
-            return this.resendPlaintextPayload(outbound, payload, requesterJid, retryCount);
+            return this.resendPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount);
         }
         if (payload.mode === 'encrypted') {
-            return this.resendEncryptedPayload(outbound, payload, requesterJid, retryCount);
+            return this.resendEncryptedPayload(outbound, payload, requesterJid, normalizedRequesterJid, retryCount);
         }
-        return this.resendOpaquePayload(outbound, payload, requesterJid);
+        return this.resendOpaquePayload(outbound, payload, normalizedRequesterJid);
     }
-    async resendPlaintextPayload(outbound, payload, requesterJid, retryCount) {
+    async resendPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount) {
         if ((0, jid_1.isGroupOrBroadcastJid)(payload.to)) {
-            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid);
+            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress);
         }
         let payloadUserJid;
         let requesterUserJid;
@@ -40,8 +42,8 @@ class WaRetryReplayService {
         if (payloadUserJid !== requesterUserJid) {
             return 'ineligible';
         }
-        const encrypted = await this.signalProtocol.encryptMessage((0, jid_1.parseSignalAddressFromJid)(requesterJid), payload.plaintext);
-        await this.messageClient.sendEncrypted({
+        const encrypted = await this.options.signalProtocol.encryptMessage(requesterAddress, payload.plaintext);
+        await this.options.messageClient.sendEncrypted({
             to: requesterJid,
             encType: encrypted.type,
             ciphertext: encrypted.ciphertext,
@@ -51,15 +53,15 @@ class WaRetryReplayService {
         });
         return 'resent';
     }
-    async resendGroupPlaintextPayload(outbound, payload, requesterJid) {
+    async resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress) {
         const plaintext = (await this.maybeWrapGroupRetryPlaintextForSelfDevice(payload, requesterJid)) ??
             payload.plaintext;
-        const encrypted = await this.signalProtocol.encryptMessage((0, jid_1.parseSignalAddressFromJid)(requesterJid), plaintext);
+        const encrypted = await this.options.signalProtocol.encryptMessage(requesterAddress, plaintext);
         let deviceIdentity;
         if (encrypted.type === 'pkmsg') {
-            const signedIdentity = this.getCurrentSignedIdentity();
+            const signedIdentity = this.options.getCurrentSignedIdentity();
             if (!signedIdentity) {
-                this.logger.warn('retry request rejected: missing signed identity for pkmsg group retry');
+                this.options.logger.warn('retry request rejected: missing signed identity for pkmsg group retry');
                 return 'ineligible';
             }
             deviceIdentity = _proto_1.proto.ADVSignedDeviceIdentity.encode(signedIdentity).finish();
@@ -69,22 +71,22 @@ class WaRetryReplayService {
             type: payload.type,
             id: outbound.messageId,
             requesterJid,
-            addressingMode: (0, jid_1.splitJid)(requesterJid).server === 'lid' ? 'lid' : 'pn',
+            addressingMode: requesterAddress.server === 'lid' ? 'lid' : 'pn',
             encType: encrypted.type,
             ciphertext: encrypted.ciphertext,
             deviceIdentity
         });
-        await this.messageClient.sendMessageNode(retryNode);
+        await this.options.messageClient.sendMessageNode(retryNode);
         return 'resent';
     }
-    async resendEncryptedPayload(outbound, payload, requesterJid, retryCount) {
+    async resendEncryptedPayload(outbound, payload, requesterJid, normalizedRequesterJid, retryCount) {
         if (payload.encType === 'skmsg') {
             return 'ineligible';
         }
-        if ((0, jid_1.normalizeDeviceJid)(payload.to) !== (0, jid_1.normalizeDeviceJid)(requesterJid)) {
+        if ((0, jid_1.normalizeDeviceJid)(payload.to) !== normalizedRequesterJid) {
             return 'ineligible';
         }
-        await this.messageClient.sendEncrypted({
+        await this.options.messageClient.sendEncrypted({
             to: requesterJid,
             encType: payload.encType,
             ciphertext: payload.ciphertext,
@@ -95,8 +97,11 @@ class WaRetryReplayService {
         });
         return 'resent';
     }
-    async resendOpaquePayload(outbound, payload, requesterJid) {
+    async resendOpaquePayload(outbound, payload, normalizedRequesterJid) {
         const decoded = (0, binary_1.decodeBinaryNode)(payload.node);
+        if (!this.isOpaqueReplayCompatible(decoded, normalizedRequesterJid)) {
+            return 'ineligible';
+        }
         const replayNode = decoded.attrs.id === outbound.messageId
             ? decoded
             : {
@@ -106,10 +111,7 @@ class WaRetryReplayService {
                     id: outbound.messageId
                 }
             };
-        if (!this.isOpaqueReplayCompatible(replayNode, requesterJid)) {
-            return 'ineligible';
-        }
-        await this.messageClient.sendMessageNode(replayNode);
+        await this.options.messageClient.sendMessageNode(replayNode);
         return 'resent';
     }
     async maybeWrapGroupRetryPlaintextForSelfDevice(payload, requesterJid) {
@@ -123,7 +125,7 @@ class WaRetryReplayService {
             return (0, padding_1.writeRandomPadMax16)(_proto_1.proto.Message.encode(wrapped).finish());
         }
         catch (error) {
-            this.logger.warn('retry request failed to wrap deviceSent payload for self requester', {
+            this.options.logger.warn('retry request failed to wrap deviceSent payload for self requester', {
                 requester: requesterJid,
                 to: payload.to,
                 message: (0, primitives_1.toError)(error).message
@@ -143,38 +145,35 @@ class WaRetryReplayService {
         }
         return false;
     }
-    get logger() {
-        return this.options.logger;
-    }
-    get messageClient() {
-        return this.options.messageClient;
-    }
-    get signalProtocol() {
-        return this.options.signalProtocol;
-    }
-    getCurrentSignedIdentity() {
-        return this.options.getCurrentSignedIdentity();
-    }
-    isOpaqueReplayCompatible(node, requesterJid) {
-        const requester = (0, jid_1.normalizeDeviceJid)(requesterJid);
+    isOpaqueReplayCompatible(node, normalizedRequesterJid) {
         const participantsNode = (0, helpers_1.findNodeChild)(node, 'participants');
         if (participantsNode) {
-            const toNodes = (0, helpers_1.getNodeChildrenByTag)(participantsNode, 'to');
-            if (toNodes.length !== 1) {
-                return false;
+            const participantsContent = Array.isArray(participantsNode.content)
+                ? participantsNode.content
+                : [];
+            let participantNode;
+            let participantCount = 0;
+            for (let index = 0; index < participantsContent.length; index++) {
+                const child = participantsContent[index];
+                if (child.tag !== 'to')
+                    continue;
+                participantCount++;
+                if (participantCount > 1)
+                    return false;
+                participantNode = child;
             }
-            const participantJid = toNodes[0].attrs.jid;
-            if (!participantJid) {
+            if (participantCount !== 1 || !participantNode)
                 return false;
-            }
-            return (0, jid_1.normalizeDeviceJid)(participantJid) === requester;
+            const participantJid = participantNode.attrs.jid;
+            if (!participantJid)
+                return false;
+            return (0, jid_1.normalizeDeviceJid)(participantJid) === normalizedRequesterJid;
         }
         if (node.attrs.participant) {
-            return (0, jid_1.normalizeDeviceJid)(node.attrs.participant) === requester;
-        }
-        if (node.attrs.to) {
-            return (0, jid_1.normalizeDeviceJid)(node.attrs.to) === requester;
+            return (0, jid_1.normalizeDeviceJid)(node.attrs.participant) === normalizedRequesterJid;
         }
+        if (node.attrs.to)
+            return (0, jid_1.normalizeDeviceJid)(node.attrs.to) === normalizedRequesterJid;
         return false;
     }
 }