zapo-js 0.1.0 → 0.1.2

package/dist/esm/protocol/jid.js

@@ -1,33 +1,53 @@
 import { WA_DEFAULTS } from './constants.js';
-export 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 };
+}
+export function splitJid(jid) {
+    const { atIndex } = scanJid(jid);
+    return { user: jid.slice(0, atIndex), server: jid.slice(atIndex + 1) };
 }
 export 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}@${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}@${WA_DEFAULTS.HOST_DOMAIN}`;
 }
 export 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);
 }
 export function isGroupJid(jid) {
     return isJidType(jid, WA_DEFAULTS.GROUP_SERVER);
@@ -39,26 +59,14 @@ export function isGroupOrBroadcastJid(jid) {
     return isGroupJid(jid) || isBroadcastJid(jid);
 }
 export 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 };
 }
 export function toUserJid(jid) {
     const address = parseSignalAddressFromJid(jid);
@@ -66,29 +74,33 @@ export function toUserJid(jid) {
 }
 export 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}`;
 }
 export 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 };
 }
 export 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}@${WA_DEFAULTS.HOST_DOMAIN}`;
 }
+export function signalAddressKey(address) {
+    const server = address.server ?? WA_DEFAULTS.HOST_DOMAIN;
+    return `${address.user}|${server}|${address.device}`;
+}

package/dist/esm/protocol/media.js

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

package/dist/esm/protocol/nodes.js

@@ -23,6 +23,8 @@ export const 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/esm/protocol/usync.js

@@ -0,0 +1,11 @@
+export const WA_USYNC_MODES = Object.freeze({
+    QUERY: 'query'
+});
+export const WA_USYNC_CONTEXTS = Object.freeze({
+    INTERACTIVE: 'interactive',
+    NOTIFICATION: 'notification'
+});
+export const WA_USYNC_DEFAULTS = Object.freeze({
+    INDEX: '0',
+    LAST: 'true'
+});

package/dist/esm/retry/index.js

@@ -3,3 +3,4 @@ export { mapRetryReasonFromError } from './reason.js';
 export { parseRetryReceiptRequest } from './parse.js';
 export { decodeRetryReplayPayload, encodeRetryReplayPayload, pickRetryStateMax } from './outbound.js';
 export { WaRetryReplayService } from './replay.js';
+export { createOutboundRetryTracker } from './tracker.js';

package/dist/esm/retry/outbound.js

@@ -1,5 +1,4 @@
-import { base64ToBytes, bytesToBase64 } from '../util/base64.js';
-import { TEXT_DECODER, TEXT_ENCODER } from '../util/bytes.js';
+import { base64ToBytesChecked, bytesToBase64, TEXT_DECODER, TEXT_ENCODER } from '../util/bytes.js';
 function requireObject(value) {
     if (!value || typeof value !== 'object') {
         throw new Error('invalid retry replay payload');
@@ -44,7 +43,7 @@ export function decodeRetryReplayPayload(raw) {
             mode,
             to: requireString(parsed.to, 'to'),
             type: requireString(parsed.type, 'type'),
-            plaintext: base64ToBytes(requireString(parsed.plaintext, 'plaintext'), 'retry.plaintext')
+            plaintext: base64ToBytesChecked(requireString(parsed.plaintext, 'plaintext'), 'retry.plaintext')
         };
     }
     if (mode === 'encrypted') {
@@ -57,7 +56,7 @@ export function decodeRetryReplayPayload(raw) {
             to: requireString(parsed.to, 'to'),
             type: requireString(parsed.type, 'type'),
             encType,
-            ciphertext: base64ToBytes(requireString(parsed.ciphertext, 'ciphertext'), 'retry.ciphertext'),
+            ciphertext: base64ToBytesChecked(requireString(parsed.ciphertext, 'ciphertext'), 'retry.ciphertext'),
             participant: parsed.participant === undefined
                 ? undefined
                 : requireString(parsed.participant, 'participant')
@@ -66,7 +65,7 @@ export function decodeRetryReplayPayload(raw) {
     if (mode === 'opaque_node') {
         return {
             mode,
-            node: base64ToBytes(requireString(parsed.node, 'node'), 'retry.node')
+            node: base64ToBytesChecked(requireString(parsed.node, 'node'), 'retry.node')
         };
     }
     throw new Error(`invalid retry replay payload mode: ${mode}`);

package/dist/esm/retry/parse.js

@@ -1,7 +1,7 @@
 import { WA_MESSAGE_TAGS, WA_NODE_TAGS } from '../protocol/constants.js';
 import { SIGNAL_KEY_DATA_LENGTH, SIGNAL_KEY_ID_LENGTH, SIGNAL_REGISTRATION_ID_LENGTH, SIGNAL_SIGNATURE_LENGTH } from '../signal/api/constants.js';
-import { decodeNodeContentBase64OrBytes, findNodeChild } from '../transport/node/helpers.js';
-import { parseOptionalInt } from '../transport/stream/parse.js';
+import { decodeNodeContentBase64OrBytes, findNodeChildrenByTags } from '../transport/node/helpers.js';
+import { parseOptionalInt } from '../util/primitives.js';
 function parseFixedLengthBytes(value, byteLength, field) {
     const out = decodeNodeContentBase64OrBytes(value, field);
     if (out.byteLength !== byteLength) {
@@ -10,81 +10,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 = 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 = 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 = findNodeChild(node, WA_NODE_TAGS.IDENTITY);
-    const signedKeyNode = findNodeChild(node, WA_NODE_TAGS.SKEY);
-    if (!identityNode || !signedKeyNode) {
-        throw new Error('retry keys section missing identity or skey');
-    }
-    const signedKeyIdNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.ID);
-    const signedKeyValueNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.VALUE);
-    const signedKeySignatureNode = findNodeChild(signedKeyNode, WA_NODE_TAGS.SIGNATURE);
-    if (!signedKeyIdNode || !signedKeyValueNode || !signedKeySignatureNode) {
-        throw new Error('retry keys section has incomplete skey');
-    }
-    const keyNode = findNodeChild(node, WA_NODE_TAGS.KEY);
-    const keyIdNode = keyNode ? findNodeChild(keyNode, WA_NODE_TAGS.ID) : undefined;
-    const keyValueNode = keyNode ? findNodeChild(keyNode, WA_NODE_TAGS.VALUE) : undefined;
-    if (keyNode && (!keyIdNode || !keyValueNode)) {
-        throw new Error('retry keys section has incomplete key');
-    }
-    const deviceIdentityNode = findNodeChild(node, WA_NODE_TAGS.DEVICE_IDENTITY);
+    const [identityNode, signedKeyNode, keyNode, deviceIdentityNode] = findNodeChildrenByTags(node, [WA_NODE_TAGS.IDENTITY, WA_NODE_TAGS.SKEY, WA_NODE_TAGS.KEY, 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] = findNodeChildrenByTags(signedKey, [WA_NODE_TAGS.ID, WA_NODE_TAGS.VALUE, 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 = findNodeChildrenByTags(keyNode, [WA_NODE_TAGS.ID, 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, SIGNAL_KEY_DATA_LENGTH, 'retry.keys.identity'),
+        identity: parseFixedLengthBytes(identity.content, SIGNAL_KEY_DATA_LENGTH, 'retry.keys.identity'),
         deviceIdentity: deviceIdentityNode
             ? decodeNodeContentBase64OrBytes(deviceIdentityNode.content, 'retry.keys.device-identity')
             : undefined,
-        key: keyIdNode && keyValueNode
+        key: keyId && keyValue
             ? {
-                id: parseBigEndianUint(parseFixedLengthBytes(keyIdNode.content, SIGNAL_KEY_ID_LENGTH, 'retry.keys.key.id'), 'retry.keys.key.id'),
-                publicKey: parseFixedLengthBytes(keyValueNode.content, SIGNAL_KEY_DATA_LENGTH, 'retry.keys.key.value')
+                id: parseBigEndianUint(parseFixedLengthBytes(keyId.content, SIGNAL_KEY_ID_LENGTH, 'retry.keys.key.id'), 'retry.keys.key.id'),
+                publicKey: parseFixedLengthBytes(keyValue.content, SIGNAL_KEY_DATA_LENGTH, 'retry.keys.key.value')
             }
             : undefined,
         skey: {
-            id: parseBigEndianUint(parseFixedLengthBytes(signedKeyIdNode.content, SIGNAL_KEY_ID_LENGTH, 'retry.keys.skey.id'), 'retry.keys.skey.id'),
-            publicKey: parseFixedLengthBytes(signedKeyValueNode.content, SIGNAL_KEY_DATA_LENGTH, 'retry.keys.skey.value'),
-            signature: parseFixedLengthBytes(signedKeySignatureNode.content, SIGNAL_SIGNATURE_LENGTH, 'retry.keys.skey.signature')
+            id: parseBigEndianUint(parseFixedLengthBytes(signedKeyId.content, SIGNAL_KEY_ID_LENGTH, 'retry.keys.skey.id'), 'retry.keys.skey.id'),
+            publicKey: parseFixedLengthBytes(signedKeyValue.content, SIGNAL_KEY_DATA_LENGTH, 'retry.keys.skey.value'),
+            signature: parseFixedLengthBytes(signedKeySignature.content, SIGNAL_SIGNATURE_LENGTH, 'retry.keys.skey.signature')
         }
     };
 }
@@ -92,7 +73,9 @@ export function parseRetryReceiptRequest(node) {
     if (node.tag !== 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;
     }
@@ -101,19 +84,18 @@ export function parseRetryReceiptRequest(node) {
     if (!stanzaId || !from) {
         throw new Error('retry receipt is missing id/from attrs');
     }
-    const retryNode = findNodeChild(node, 'retry');
-    if (!retryNode) {
-        throw new Error('retry receipt is missing retry child');
-    }
-    const registrationNode = findNodeChild(node, WA_NODE_TAGS.REGISTRATION);
-    if (!registrationNode) {
-        throw new Error('retry receipt is missing registration child');
-    }
-    const originalMsgId = retryNode.attrs.id;
+    const [retryNode, registrationNode, keysNode] = findNodeChildrenByTags(node, [
+        'retry',
+        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, SIGNAL_REGISTRATION_ID_LENGTH, 'retry.registration');
+    const registration = parseFixedLengthBytes(registrationNodeValue.content, SIGNAL_REGISTRATION_ID_LENGTH, 'retry.registration');
     return {
         type: receiptType,
         stanzaId,
@@ -121,10 +103,10 @@ export 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: parseOptionalInt(retry.attrs.count) ?? 0,
+        retryReason: parseOptionalInt(retry.attrs.error ?? node.attrs.error),
+        t: retry.attrs.t ?? node.attrs.t,
         regId: parseBigEndianUint(registration, 'retry.registration'),
-        keyBundle: parseRetryKeyBundle(findNodeChild(node, 'keys'))
+        keyBundle: parseRetryKeyBundle(keysNode)
     };
 }

package/dist/esm/retry/replay.js

@@ -1,11 +1,11 @@
 import { wrapDeviceSentMessage } from '../message/device-sent.js';
 import { unpadPkcs7, writeRandomPadMax16 } from '../message/padding.js';
 import { proto } from '../proto.js';
-import { isGroupOrBroadcastJid, normalizeDeviceJid, parseSignalAddressFromJid, splitJid, toUserJid } from '../protocol/jid.js';
+import { isGroupOrBroadcastJid, normalizeDeviceJid, parseSignalAddressFromJid, toUserJid } from '../protocol/jid.js';
 import { decodeRetryReplayPayload } from './outbound.js';
 import { decodeBinaryNode } from '../transport/binary/index.js';
 import { buildGroupRetryMessageNode } from '../transport/node/builders/message.js';
-import { findNodeChild, getNodeChildrenByTag } from '../transport/node/helpers.js';
+import { findNodeChild } from '../transport/node/helpers.js';
 import { toError } from '../util/primitives.js';
 export class WaRetryReplayService {
     constructor(options) {
@@ -13,17 +13,19 @@ export class WaRetryReplayService {
     }
     async resendOutboundMessage(outbound, requesterJid, retryCount) {
         const payload = decodeRetryReplayPayload(outbound.replayPayload);
+        const requesterAddress = parseSignalAddressFromJid(requesterJid);
+        const normalizedRequesterJid = 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 (isGroupOrBroadcastJid(payload.to)) {
-            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid);
+            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress);
         }
         let payloadUserJid;
         let requesterUserJid;
@@ -37,8 +39,8 @@ export class WaRetryReplayService {
         if (payloadUserJid !== requesterUserJid) {
             return 'ineligible';
         }
-        const encrypted = await this.signalProtocol.encryptMessage(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,
@@ -48,15 +50,15 @@ export 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(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.ADVSignedDeviceIdentity.encode(signedIdentity).finish();
@@ -66,22 +68,22 @@ export class WaRetryReplayService {
             type: payload.type,
             id: outbound.messageId,
             requesterJid,
-            addressingMode: 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 (normalizeDeviceJid(payload.to) !== normalizeDeviceJid(requesterJid)) {
+        if (normalizeDeviceJid(payload.to) !== normalizedRequesterJid) {
             return 'ineligible';
         }
-        await this.messageClient.sendEncrypted({
+        await this.options.messageClient.sendEncrypted({
             to: requesterJid,
             encType: payload.encType,
             ciphertext: payload.ciphertext,
@@ -92,8 +94,11 @@ export class WaRetryReplayService {
         });
         return 'resent';
     }
-    async resendOpaquePayload(outbound, payload, requesterJid) {
+    async resendOpaquePayload(outbound, payload, normalizedRequesterJid) {
         const decoded = decodeBinaryNode(payload.node);
+        if (!this.isOpaqueReplayCompatible(decoded, normalizedRequesterJid)) {
+            return 'ineligible';
+        }
         const replayNode = decoded.attrs.id === outbound.messageId
             ? decoded
             : {
@@ -103,10 +108,7 @@ export 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) {
@@ -120,7 +122,7 @@ export class WaRetryReplayService {
             return writeRandomPadMax16(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: toError(error).message
@@ -140,38 +142,35 @@ export 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 = normalizeDeviceJid(requesterJid);
+    isOpaqueReplayCompatible(node, normalizedRequesterJid) {
         const participantsNode = findNodeChild(node, 'participants');
         if (participantsNode) {
-            const toNodes = 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 normalizeDeviceJid(participantJid) === requester;
+            const participantJid = participantNode.attrs.jid;
+            if (!participantJid)
+                return false;
+            return normalizeDeviceJid(participantJid) === normalizedRequesterJid;
         }
         if (node.attrs.participant) {
-            return normalizeDeviceJid(node.attrs.participant) === requester;
-        }
-        if (node.attrs.to) {
-            return normalizeDeviceJid(node.attrs.to) === requester;
+            return normalizeDeviceJid(node.attrs.participant) === normalizedRequesterJid;
         }
+        if (node.attrs.to)
+            return normalizeDeviceJid(node.attrs.to) === normalizedRequesterJid;
         return false;
     }
 }