zapo-js 0.1.2 → 0.2.0

package/dist/esm/protocol/message.js

@@ -11,6 +11,66 @@ export const WA_MESSAGE_TYPES = Object.freeze({
     ACK_TYPE_ERROR: 'error',
     ACK_CLASS_ERROR: 'error',
     ACK_CLASS_MESSAGE: 'message',
-    RECEIPT_TYPE_PEER: 'peer_msg'
+    RECEIPT_TYPE_DELIVERY: 'delivery',
+    RECEIPT_TYPE_SENDER: 'sender',
+    RECEIPT_TYPE_INACTIVE: 'inactive',
+    RECEIPT_TYPE_READ: 'read',
+    RECEIPT_TYPE_READ_SELF: 'read-self',
+    RECEIPT_TYPE_PLAYED: 'played',
+    RECEIPT_TYPE_PLAYED_SELF: 'played-self',
+    RECEIPT_TYPE_HISTORY_SYNC: 'hist_sync',
+    RECEIPT_TYPE_PEER: 'peer_msg',
+    RECEIPT_TYPE_SERVER_ERROR: 'server-error',
+    RECEIPT_TYPE_RETRY: 'retry'
 });
 export const WA_RETRYABLE_ACK_CODES = Object.freeze(['408', '429', '500', '503']);
+export const WA_STANZA_MSG_TYPES = Object.freeze({
+    TEXT: 'text',
+    MEDIA: 'media',
+    MEDIA_NOTIFY: 'medianotify',
+    PAY: 'pay',
+    POLL: 'poll',
+    REACTION: 'reaction',
+    EVENT: 'event'
+});
+export const WA_EDIT_ATTRS = Object.freeze({
+    MESSAGE_EDIT: '1',
+    PIN_IN_CHAT: '2',
+    SENDER_REVOKE: '7',
+    ADMIN_REVOKE: '8'
+});
+export const WA_POLL_META_TYPES = Object.freeze({
+    CREATION: 'creation',
+    VOTE: 'vote',
+    RESULT_SNAPSHOT: 'result_snapshot',
+    EDIT: 'edit'
+});
+export const WA_EVENT_META_TYPES = Object.freeze({
+    CREATION: 'creation',
+    RESPONSE: 'response',
+    EDIT: 'edit'
+});
+export const WA_ENC_MEDIA_TYPES = Object.freeze({
+    IMAGE: 'image',
+    VIDEO: 'video',
+    PTV: 'ptv',
+    AUDIO: 'audio',
+    PTT: 'ptt',
+    LOCATION: 'location',
+    LIVE_LOCATION: 'livelocation',
+    VCARD: 'vcard',
+    CONTACT_ARRAY: 'contact_array',
+    DOCUMENT: 'document',
+    URL: 'url',
+    GIF: 'gif',
+    STICKER: 'sticker',
+    STICKER_PACK: 'sticker_pack',
+    LIST: 'list',
+    LIST_RESPONSE: 'list_response',
+    BUTTON: 'button',
+    BUTTON_RESPONSE: 'buttons_response',
+    ORDER: 'order',
+    PRODUCT: 'product',
+    NATIVE_FLOW_RESPONSE: 'native_flow_response',
+    GROUP_HISTORY: 'group_history'
+});

package/dist/esm/protocol/nodes.js

@@ -78,6 +78,8 @@ export const WA_XMLNS = Object.freeze({
     PRIVACY: 'privacy',
     BLOCKLIST: 'blocklist',
     USYNC: 'usync',
+    BUSINESS: 'w:biz',
+    STATUS: 'status',
     GROUPS: 'w:g2',
     NEWSLETTER: 'newsletter',
     XMPP_PING: 'urn:xmpp:ping',

package/dist/esm/protocol/notification.js

@@ -1,5 +1,7 @@
 export const WA_NOTIFICATION_TYPES = Object.freeze({
-    GROUP: 'w:gp2'
+    GROUP: 'w:gp2',
+    ENCRYPT: 'encrypt',
+    DEVICES: 'devices'
 });
 export const WA_GROUP_NOTIFICATION_TAGS = Object.freeze({
     REMOVE: 'remove',

package/dist/esm/protocol/privacy-token.js

@@ -0,0 +1,17 @@
+export const WA_PRIVACY_TOKEN_TYPES = Object.freeze({
+    TRUSTED_CONTACT: 'trusted_contact'
+});
+export const WA_PRIVACY_TOKEN_TAGS = Object.freeze({
+    TOKENS: 'tokens',
+    TOKEN: 'token',
+    TC_TOKEN: 'tctoken',
+    CS_TOKEN: 'cstoken'
+});
+export const WA_PRIVACY_TOKEN_NOTIFICATION_TYPE = 'privacy_token';
+export const WA_TC_TOKEN_DEFAULTS = Object.freeze({
+    DURATION_S: 604800,
+    NUM_BUCKETS: 4,
+    SENDER_DURATION_S: 604800,
+    SENDER_NUM_BUCKETS: 4,
+    MAX_DURATION_S: 15552000
+});

package/dist/esm/protocol/privacy.js

@@ -0,0 +1,55 @@
+export const WA_PRIVACY_CATEGORIES = Object.freeze({
+    READ_RECEIPTS: 'readreceipts',
+    LAST_SEEN: 'last',
+    ONLINE: 'online',
+    PROFILE_PICTURE: 'profile',
+    ABOUT: 'status',
+    GROUP_ADD: 'groupadd',
+    CALL_ADD: 'calladd',
+    MESSAGES: 'messages',
+    DEFENSE_MODE: 'defense'
+});
+export const WA_PRIVACY_VALUES = Object.freeze({
+    ALL: 'all',
+    CONTACTS: 'contacts',
+    CONTACT_BLACKLIST: 'contact_blacklist',
+    NONE: 'none',
+    MATCH_LAST_SEEN: 'match_last_seen',
+    KNOWN: 'known',
+    OFF: 'off',
+    ON_STANDARD: 'on_standard',
+    ERROR: 'error'
+});
+export const WA_PRIVACY_CATEGORY_TO_SETTING = Object.freeze({
+    [WA_PRIVACY_CATEGORIES.READ_RECEIPTS]: 'readReceipts',
+    [WA_PRIVACY_CATEGORIES.LAST_SEEN]: 'lastSeen',
+    [WA_PRIVACY_CATEGORIES.ONLINE]: 'online',
+    [WA_PRIVACY_CATEGORIES.PROFILE_PICTURE]: 'profilePicture',
+    [WA_PRIVACY_CATEGORIES.ABOUT]: 'about',
+    [WA_PRIVACY_CATEGORIES.GROUP_ADD]: 'groupAdd',
+    [WA_PRIVACY_CATEGORIES.CALL_ADD]: 'callAdd',
+    [WA_PRIVACY_CATEGORIES.MESSAGES]: 'messages',
+    [WA_PRIVACY_CATEGORIES.DEFENSE_MODE]: 'defenseMode'
+});
+export const WA_PRIVACY_SETTING_TO_CATEGORY = Object.freeze({
+    readReceipts: WA_PRIVACY_CATEGORIES.READ_RECEIPTS,
+    lastSeen: WA_PRIVACY_CATEGORIES.LAST_SEEN,
+    online: WA_PRIVACY_CATEGORIES.ONLINE,
+    profilePicture: WA_PRIVACY_CATEGORIES.PROFILE_PICTURE,
+    about: WA_PRIVACY_CATEGORIES.ABOUT,
+    groupAdd: WA_PRIVACY_CATEGORIES.GROUP_ADD,
+    callAdd: WA_PRIVACY_CATEGORIES.CALL_ADD,
+    messages: WA_PRIVACY_CATEGORIES.MESSAGES,
+    defenseMode: WA_PRIVACY_CATEGORIES.DEFENSE_MODE
+});
+export const WA_PRIVACY_DISALLOWED_LIST_CATEGORIES = Object.freeze({
+    ABOUT: WA_PRIVACY_CATEGORIES.ABOUT,
+    GROUP_ADD: WA_PRIVACY_CATEGORIES.GROUP_ADD,
+    LAST_SEEN: WA_PRIVACY_CATEGORIES.LAST_SEEN,
+    PROFILE_PICTURE: WA_PRIVACY_CATEGORIES.PROFILE_PICTURE
+});
+export const WA_PRIVACY_TAGS = Object.freeze({
+    CATEGORY: 'category',
+    LIST: 'list',
+    USER: 'user'
+});

package/dist/esm/protocol/stream.js

@@ -49,6 +49,18 @@ export const WA_STREAM_SIGNALING = Object.freeze({
     FORCE_LOGIN_CODE: 515,
     FORCE_LOGOUT_CODE: 516
 });
+export const WA_FAILURE_REASONS = Object.freeze({
+    GENERIC_FAILURE: 400,
+    NOT_AUTHORIZED: 401,
+    TEMP_BANNED: 402,
+    LOCKED: 403,
+    CLIENT_TOO_OLD: 405,
+    BANNED: 406,
+    BAD_USER_AGENT: 409,
+    INTERNAL_SERVER_ERROR: 500,
+    EXPERIMENTAL: 501,
+    SERVICE_UNAVAILABLE: 503
+});
 export const WA_DISCONNECT_REASONS = Object.freeze({
     CLIENT_DISCONNECTED: 'client_disconnected',
     COMMS_STOPPED: 'comms_stopped',
@@ -56,5 +68,18 @@ export const WA_DISCONNECT_REASONS = Object.freeze({
     STREAM_ERROR_DEVICE_REMOVED: 'stream_error_device_removed',
     STREAM_ERROR_ACK: 'stream_error_ack',
     STREAM_ERROR_XML_NOT_WELL_FORMED: 'stream_error_xml_not_well_formed',
-    STREAM_ERROR_OTHER: 'stream_error_other'
+    STREAM_ERROR_OTHER: 'stream_error_other',
+    STREAM_ERROR_FORCE_LOGIN: 'stream_error_force_login',
+    STREAM_ERROR_FORCE_LOGOUT: 'stream_error_force_logout',
+    FAILURE_LOCKED: 'failure_locked',
+    FAILURE_NOT_AUTHORIZED: 'failure_not_authorized',
+    FAILURE_BANNED: 'failure_banned',
+    FAILURE_CLIENT_TOO_OLD: 'failure_client_too_old',
+    FAILURE_BAD_USER_AGENT: 'failure_bad_user_agent',
+    FAILURE_SERVICE_UNAVAILABLE: 'failure_service_unavailable',
+    PRIMARY_IDENTITY_KEY_CHANGE: 'primary_identity_key_change'
+});
+export const WA_CONNECTION_REASONS = Object.freeze({
+    CONNECTED: 'connected',
+    RECONNECTED: 'reconnected'
 });

package/dist/esm/retry/codec.js

@@ -0,0 +1,216 @@
+import { concatBytes, TEXT_DECODER, TEXT_ENCODER } from '../util/bytes.js';
+const RETRY_PAYLOAD_CODEC_MAGIC = 0x5a;
+const RETRY_PAYLOAD_CODEC_VERSION = 1;
+const RETRY_PAYLOAD_MODE = Object.freeze({
+    plaintext: 1,
+    encrypted: 2,
+    opaque_node: 3
+});
+const RETRY_PAYLOAD_ENC_TYPE = Object.freeze({
+    msg: 1,
+    pkmsg: 2,
+    skmsg: 3
+});
+const RETRY_PAYLOAD_ENC_TYPE_REVERSE = Object.freeze({
+    1: 'msg',
+    2: 'pkmsg',
+    3: 'skmsg'
+});
+export function encodeRetryReplayPayload(payload) {
+    const chunks = [];
+    if (payload.mode === 'plaintext') {
+        const header = new Uint8Array(3);
+        header[0] = RETRY_PAYLOAD_CODEC_MAGIC;
+        header[1] = RETRY_PAYLOAD_CODEC_VERSION;
+        header[2] = RETRY_PAYLOAD_MODE.plaintext;
+        chunks.push(header);
+        pushStringField(chunks, payload.to, 'to');
+        pushStringField(chunks, payload.type, 'type');
+        pushBytesField(chunks, payload.plaintext, 'plaintext');
+        return concatBytes(chunks);
+    }
+    if (payload.mode === 'encrypted') {
+        const header = new Uint8Array(3);
+        header[0] = RETRY_PAYLOAD_CODEC_MAGIC;
+        header[1] = RETRY_PAYLOAD_CODEC_VERSION;
+        header[2] = RETRY_PAYLOAD_MODE.encrypted;
+        chunks.push(header);
+        pushStringField(chunks, payload.to, 'to');
+        pushStringField(chunks, payload.type, 'type');
+        const hasParticipant = payload.participant !== undefined;
+        const modeDetails = new Uint8Array(2);
+        modeDetails[0] = RETRY_PAYLOAD_ENC_TYPE[payload.encType];
+        modeDetails[1] = hasParticipant ? 1 : 0;
+        chunks.push(modeDetails);
+        if (hasParticipant) {
+            pushStringField(chunks, payload.participant, 'participant');
+        }
+        pushBytesField(chunks, payload.ciphertext, 'ciphertext');
+        return concatBytes(chunks);
+    }
+    const header = new Uint8Array(3);
+    header[0] = RETRY_PAYLOAD_CODEC_MAGIC;
+    header[1] = RETRY_PAYLOAD_CODEC_VERSION;
+    header[2] = RETRY_PAYLOAD_MODE.opaque_node;
+    chunks.push(header);
+    pushBytesField(chunks, payload.node, 'node');
+    return concatBytes(chunks);
+}
+export function decodeRetryReplayPayload(raw) {
+    if (raw.byteLength < 3) {
+        throw new Error('invalid retry replay payload: unsupported codec version');
+    }
+    if (raw[0] !== RETRY_PAYLOAD_CODEC_MAGIC || raw[1] !== RETRY_PAYLOAD_CODEC_VERSION) {
+        throw new Error('invalid retry replay payload: unsupported codec version');
+    }
+    return decodeCompactRetryReplayPayload(raw);
+}
+function decodeEncryptedType(value) {
+    const result = RETRY_PAYLOAD_ENC_TYPE_REVERSE[value];
+    if (!result) {
+        throw new Error(`invalid retry encrypted encType code: ${value}`);
+    }
+    return result;
+}
+function pushUint16(chunks, value, field) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0xffff) {
+        throw new Error(`invalid retry replay payload ${field} length`);
+    }
+    const out = new Uint8Array(2);
+    out[0] = value >>> 8;
+    out[1] = value & 0xff;
+    chunks.push(out);
+}
+function pushUint32(chunks, value, field) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0xffffffff) {
+        throw new Error(`invalid retry replay payload ${field} length`);
+    }
+    const out = new Uint8Array(4);
+    out[0] = (value >>> 24) & 0xff;
+    out[1] = (value >>> 16) & 0xff;
+    out[2] = (value >>> 8) & 0xff;
+    out[3] = value & 0xff;
+    chunks.push(out);
+}
+function pushStringField(chunks, value, field) {
+    const encoded = TEXT_ENCODER.encode(value);
+    pushUint16(chunks, encoded.byteLength, field);
+    chunks.push(encoded);
+}
+function pushBytesField(chunks, value, field) {
+    pushUint32(chunks, value.byteLength, field);
+    chunks.push(value);
+}
+function readUint8(raw, offset, field) {
+    if (offset >= raw.byteLength) {
+        throw new Error(`invalid retry replay payload field: ${field}`);
+    }
+    return [raw[offset], offset + 1];
+}
+function readUint16(raw, offset, field) {
+    if (offset + 2 > raw.byteLength) {
+        throw new Error(`invalid retry replay payload field: ${field}`);
+    }
+    return [((raw[offset] << 8) | raw[offset + 1]) >>> 0, offset + 2];
+}
+function readUint32(raw, offset, field) {
+    if (offset + 4 > raw.byteLength) {
+        throw new Error(`invalid retry replay payload field: ${field}`);
+    }
+    return [
+        ((raw[offset] << 24) |
+            (raw[offset + 1] << 16) |
+            (raw[offset + 2] << 8) |
+            raw[offset + 3]) >>>
+            0,
+        offset + 4
+    ];
+}
+function readString(raw, offset, field) {
+    const [byteLength, nextOffset] = readUint16(raw, offset, `${field}.length`);
+    const endOffset = nextOffset + byteLength;
+    if (endOffset > raw.byteLength) {
+        throw new Error(`invalid retry replay payload field: ${field}`);
+    }
+    return [TEXT_DECODER.decode(raw.subarray(nextOffset, endOffset)), endOffset];
+}
+function readBytes(raw, offset, field) {
+    const [byteLength, nextOffset] = readUint32(raw, offset, `${field}.length`);
+    const endOffset = nextOffset + byteLength;
+    if (endOffset > raw.byteLength) {
+        throw new Error(`invalid retry replay payload field: ${field}`);
+    }
+    return [raw.subarray(nextOffset, endOffset), endOffset];
+}
+function assertNoTrailingData(raw, offset) {
+    if (offset !== raw.byteLength) {
+        throw new Error('invalid retry replay payload: trailing data');
+    }
+}
+function decodeCompactRetryReplayPayload(raw) {
+    let offset = 0;
+    let magic = 0;
+    let version = 0;
+    let mode = 0;
+    [magic, offset] = readUint8(raw, offset, 'magic');
+    [version, offset] = readUint8(raw, offset, 'version');
+    [mode, offset] = readUint8(raw, offset, 'mode');
+    if (magic !== RETRY_PAYLOAD_CODEC_MAGIC || version !== RETRY_PAYLOAD_CODEC_VERSION) {
+        throw new Error('invalid retry replay payload: unsupported codec version');
+    }
+    if (mode === RETRY_PAYLOAD_MODE.plaintext) {
+        let to = '';
+        let type = '';
+        let plaintext = raw;
+        [to, offset] = readString(raw, offset, 'to');
+        [type, offset] = readString(raw, offset, 'type');
+        [plaintext, offset] = readBytes(raw, offset, 'plaintext');
+        assertNoTrailingData(raw, offset);
+        return {
+            mode: 'plaintext',
+            to,
+            type,
+            plaintext
+        };
+    }
+    if (mode === RETRY_PAYLOAD_MODE.encrypted) {
+        let to = '';
+        let type = '';
+        let encTypeCode = 0;
+        let hasParticipant = 0;
+        let participant;
+        let ciphertext = raw;
+        [to, offset] = readString(raw, offset, 'to');
+        [type, offset] = readString(raw, offset, 'type');
+        [encTypeCode, offset] = readUint8(raw, offset, 'encType');
+        [hasParticipant, offset] = readUint8(raw, offset, 'hasParticipant');
+        if (hasParticipant !== 0 && hasParticipant !== 1) {
+            throw new Error('invalid retry replay payload field: hasParticipant');
+        }
+        if (hasParticipant === 1) {
+            ;
+            [participant, offset] = readString(raw, offset, 'participant');
+        }
+        ;
+        [ciphertext, offset] = readBytes(raw, offset, 'ciphertext');
+        assertNoTrailingData(raw, offset);
+        return {
+            mode: 'encrypted',
+            to,
+            type,
+            encType: decodeEncryptedType(encTypeCode),
+            participant,
+            ciphertext
+        };
+    }
+    if (mode === RETRY_PAYLOAD_MODE.opaque_node) {
+        let node = raw;
+        [node, offset] = readBytes(raw, offset, 'node');
+        assertNoTrailingData(raw, offset);
+        return {
+            mode: 'opaque_node',
+            node
+        };
+    }
+    throw new Error(`invalid retry replay payload mode: ${mode}`);
+}

package/dist/esm/retry/constants.js

@@ -1,6 +1,6 @@
 export const MAX_RETRY_ATTEMPTS = 5;
 export const RETRY_KEYS_MIN_COUNT = 2;
-export const RETRY_OUTBOUND_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+export const RETRY_OUTBOUND_TTL_MS = 60 * 1000;
 export const RETRY_RECEIPT_VERSION = '1';
 export const RETRY_REASON = Object.freeze({
     UnknownError: 0,

package/dist/esm/retry/index.js

@@ -1,6 +1,6 @@
 export { MAX_RETRY_ATTEMPTS, RETRY_KEYS_MIN_COUNT, RETRY_OUTBOUND_TTL_MS, RETRY_REASON, RETRY_RECEIPT_VERSION } from './constants.js';
 export { mapRetryReasonFromError } from './reason.js';
-export { parseRetryReceiptRequest } from './parse.js';
-export { decodeRetryReplayPayload, encodeRetryReplayPayload, pickRetryStateMax } from './outbound.js';
+export { parseRetryReceiptRequest, pickRetryStateMax } from './parse.js';
+export { decodeRetryReplayPayload, encodeRetryReplayPayload } from './codec.js';
 export { WaRetryReplayService } from './replay.js';
 export { createOutboundRetryTracker } from './tracker.js';

package/dist/esm/retry/parse.js

@@ -1,34 +1,48 @@
 import { WA_MESSAGE_TAGS, WA_NODE_TAGS } from '../protocol/constants.js';
+import { normalizeDeviceJid } from '../protocol/jid.js';
+import { decodeExactLength, parseUint } from '../signal/api/codec.js';
 import { SIGNAL_KEY_DATA_LENGTH, SIGNAL_KEY_ID_LENGTH, SIGNAL_REGISTRATION_ID_LENGTH, SIGNAL_SIGNATURE_LENGTH } from '../signal/api/constants.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) {
-        throw new Error(`${field} must be ${byteLength} bytes`);
-    }
-    return out;
-}
-function parseBigEndianUint(bytes, field) {
-    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 RETRY_STATE_RANK = {
+    pending: 0,
+    delivered: 1,
+    read: 2,
+    played: 3,
+    ineligible: 4
+};
 function requireNode(node, message) {
     if (!node) {
         throw new Error(message);
     }
     return node;
 }
+function validateRetryReceiptToAttr(to, expectedToJids) {
+    if (!to || !expectedToJids || expectedToJids.length === 0) {
+        return;
+    }
+    let normalizedTo;
+    try {
+        normalizedTo = normalizeDeviceJid(to);
+    }
+    catch {
+        throw new Error('retry receipt has invalid to attr');
+    }
+    for (let index = 0; index < expectedToJids.length; index += 1) {
+        const expected = expectedToJids[index]?.trim();
+        if (!expected)
+            continue;
+        try {
+            if (normalizeDeviceJid(expected) === normalizedTo) {
+                return;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error('retry receipt to attr does not match local device');
+}
 function parseRetryKeyBundle(node) {
     if (!node) {
         return undefined;
@@ -52,24 +66,24 @@ function parseRetryKeyBundle(node) {
         ? requireNode(keyValueNode, 'retry keys section has incomplete key')
         : null;
     return {
-        identity: parseFixedLengthBytes(identity.content, SIGNAL_KEY_DATA_LENGTH, 'retry.keys.identity'),
+        identity: decodeExactLength(identity.content, 'retry.keys.identity', SIGNAL_KEY_DATA_LENGTH),
         deviceIdentity: deviceIdentityNode
             ? decodeNodeContentBase64OrBytes(deviceIdentityNode.content, 'retry.keys.device-identity')
             : undefined,
         key: keyId && keyValue
             ? {
-                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')
+                id: parseUint(decodeExactLength(keyId.content, 'retry.keys.key.id', SIGNAL_KEY_ID_LENGTH), 'retry.keys.key.id'),
+                publicKey: decodeExactLength(keyValue.content, 'retry.keys.key.value', SIGNAL_KEY_DATA_LENGTH)
             }
             : undefined,
         skey: {
-            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')
+            id: parseUint(decodeExactLength(signedKeyId.content, 'retry.keys.skey.id', SIGNAL_KEY_ID_LENGTH), 'retry.keys.skey.id'),
+            publicKey: decodeExactLength(signedKeyValue.content, 'retry.keys.skey.value', SIGNAL_KEY_DATA_LENGTH),
+            signature: decodeExactLength(signedKeySignature.content, 'retry.keys.skey.signature', SIGNAL_SIGNATURE_LENGTH)
         }
     };
 }
-export function parseRetryReceiptRequest(node) {
+export function parseRetryReceiptRequest(node, options) {
     if (node.tag !== WA_MESSAGE_TAGS.RECEIPT) {
         return null;
     }
@@ -84,6 +98,7 @@ export function parseRetryReceiptRequest(node) {
     if (!stanzaId || !from) {
         throw new Error('retry receipt is missing id/from attrs');
     }
+    validateRetryReceiptToAttr(node.attrs.to, options?.expectedToJids);
     const [retryNode, registrationNode, keysNode] = findNodeChildrenByTags(node, [
         'retry',
         WA_NODE_TAGS.REGISTRATION,
@@ -95,18 +110,23 @@ export function parseRetryReceiptRequest(node) {
     if (!originalMsgId) {
         throw new Error('retry receipt is missing retry.id');
     }
-    const registration = parseFixedLengthBytes(registrationNodeValue.content, SIGNAL_REGISTRATION_ID_LENGTH, 'retry.registration');
+    const registration = decodeExactLength(registrationNodeValue.content, 'retry.registration', SIGNAL_REGISTRATION_ID_LENGTH);
     return {
         type: receiptType,
         stanzaId,
         from,
         participant: node.attrs.participant,
         recipient: node.attrs.recipient,
+        offline: node.attrs.offline !== undefined,
+        isLid: node.attrs.is_lid === 'true',
         originalMsgId,
         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'),
+        regId: parseUint(registration, 'retry.registration'),
         keyBundle: parseRetryKeyBundle(keysNode)
     };
 }
+export function pickRetryStateMax(left, right) {
+    return RETRY_STATE_RANK[left] >= RETRY_STATE_RANK[right] ? left : right;
+}

package/dist/esm/retry/replay.js

@@ -1,8 +1,8 @@
 import { wrapDeviceSentMessage } from '../message/device-sent.js';
 import { unpadPkcs7, writeRandomPadMax16 } from '../message/padding.js';
 import { proto } from '../proto.js';
-import { isGroupOrBroadcastJid, normalizeDeviceJid, parseSignalAddressFromJid, toUserJid } from '../protocol/jid.js';
-import { decodeRetryReplayPayload } from './outbound.js';
+import { isGroupOrBroadcastJid, normalizeDeviceJid, parseJidFull, toUserJid } from '../protocol/jid.js';
+import { decodeRetryReplayPayload } from './codec.js';
 import { decodeBinaryNode } from '../transport/binary/index.js';
 import { buildGroupRetryMessageNode } from '../transport/node/builders/message.js';
 import { findNodeChild } from '../transport/node/helpers.js';
@@ -12,9 +12,12 @@ export class WaRetryReplayService {
         this.options = options;
     }
     async resendOutboundMessage(outbound, requesterJid, retryCount) {
-        const payload = decodeRetryReplayPayload(outbound.replayPayload);
-        const requesterAddress = parseSignalAddressFromJid(requesterJid);
-        const normalizedRequesterJid = normalizeDeviceJid(requesterJid);
+        const payload = outbound.replayPayload instanceof Uint8Array
+            ? decodeRetryReplayPayload(outbound.replayPayload)
+            : outbound.replayPayload;
+        const requesterParsed = parseJidFull(requesterJid);
+        const requesterAddress = requesterParsed.address;
+        const normalizedRequesterJid = requesterParsed.normalizedJid;
         if (payload.mode === 'plaintext') {
             return this.resendPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount);
         }
@@ -25,7 +28,7 @@ export class WaRetryReplayService {
     }
     async resendPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount) {
         if (isGroupOrBroadcastJid(payload.to)) {
-            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress);
+            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount);
         }
         let payloadUserJid;
         let requesterUserJid;
@@ -50,7 +53,7 @@ export class WaRetryReplayService {
         });
         return 'resent';
     }
-    async resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress) {
+    async resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount) {
         const plaintext = (await this.maybeWrapGroupRetryPlaintextForSelfDevice(payload, requesterJid)) ??
             payload.plaintext;
         const encrypted = await this.options.signalProtocol.encryptMessage(requesterAddress, plaintext);
@@ -71,6 +74,7 @@ export class WaRetryReplayService {
             addressingMode: requesterAddress.server === 'lid' ? 'lid' : 'pn',
             encType: encrypted.type,
             ciphertext: encrypted.ciphertext,
+            retryCount,
             deviceIdentity
         });
         await this.options.messageClient.sendMessageNode(retryNode);