zapo-js 0.1.2 → 0.2.0

package/dist/retry/codec.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeRetryReplayPayload = encodeRetryReplayPayload;
+exports.decodeRetryReplayPayload = decodeRetryReplayPayload;
+const bytes_1 = require("../util/bytes");
+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'
+});
+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 (0, bytes_1.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 (0, bytes_1.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 (0, bytes_1.concatBytes)(chunks);
+}
+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 = bytes_1.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 [bytes_1.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/retry/constants.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RETRY_REASON = exports.RETRY_RECEIPT_VERSION = exports.RETRY_OUTBOUND_TTL_MS = exports.RETRY_KEYS_MIN_COUNT = exports.MAX_RETRY_ATTEMPTS = void 0;
 exports.MAX_RETRY_ATTEMPTS = 5;
 exports.RETRY_KEYS_MIN_COUNT = 2;
-exports.RETRY_OUTBOUND_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+exports.RETRY_OUTBOUND_TTL_MS = 60 * 1000;
 exports.RETRY_RECEIPT_VERSION = '1';
 exports.RETRY_REASON = Object.freeze({
     UnknownError: 0,

package/dist/retry/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.createOutboundRetryTracker = exports.WaRetryReplayService = exports.encodeRetryReplayPayload = exports.decodeRetryReplayPayload = exports.pickRetryStateMax = 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; } });
@@ -11,10 +11,10 @@ var reason_1 = require("./reason");
 Object.defineProperty(exports, "mapRetryReasonFromError", { enumerable: true, get: function () { return reason_1.mapRetryReasonFromError; } });
 var parse_1 = require("./parse");
 Object.defineProperty(exports, "parseRetryReceiptRequest", { enumerable: true, get: function () { return parse_1.parseRetryReceiptRequest; } });
-var outbound_1 = require("./outbound");
-Object.defineProperty(exports, "decodeRetryReplayPayload", { enumerable: true, get: function () { return outbound_1.decodeRetryReplayPayload; } });
-Object.defineProperty(exports, "encodeRetryReplayPayload", { enumerable: true, get: function () { return outbound_1.encodeRetryReplayPayload; } });
-Object.defineProperty(exports, "pickRetryStateMax", { enumerable: true, get: function () { return outbound_1.pickRetryStateMax; } });
+Object.defineProperty(exports, "pickRetryStateMax", { enumerable: true, get: function () { return parse_1.pickRetryStateMax; } });
+var codec_1 = require("./codec");
+Object.defineProperty(exports, "decodeRetryReplayPayload", { enumerable: true, get: function () { return codec_1.decodeRetryReplayPayload; } });
+Object.defineProperty(exports, "encodeRetryReplayPayload", { enumerable: true, get: function () { return codec_1.encodeRetryReplayPayload; } });
 var replay_1 = require("./replay");
 Object.defineProperty(exports, "WaRetryReplayService", { enumerable: true, get: function () { return replay_1.WaRetryReplayService; } });
 var tracker_1 = require("./tracker");

package/dist/retry/parse.js

@@ -1,37 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRetryReceiptRequest = parseRetryReceiptRequest;
+exports.pickRetryStateMax = pickRetryStateMax;
 const constants_1 = require("../protocol/constants");
+const jid_1 = require("../protocol/jid");
+const codec_1 = require("../signal/api/codec");
 const constants_2 = require("../signal/api/constants");
 const helpers_1 = require("../transport/node/helpers");
 const primitives_1 = require("../util/primitives");
-function parseFixedLengthBytes(value, byteLength, field) {
-    const out = (0, helpers_1.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 = (0, jid_1.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 ((0, jid_1.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;
@@ -55,24 +70,24 @@ function parseRetryKeyBundle(node) {
         ? requireNode(keyValueNode, 'retry keys section has incomplete key')
         : null;
     return {
-        identity: parseFixedLengthBytes(identity.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.identity'),
+        identity: (0, codec_1.decodeExactLength)(identity.content, 'retry.keys.identity', constants_2.SIGNAL_KEY_DATA_LENGTH),
         deviceIdentity: deviceIdentityNode
             ? (0, helpers_1.decodeNodeContentBase64OrBytes)(deviceIdentityNode.content, 'retry.keys.device-identity')
             : undefined,
         key: keyId && keyValue
             ? {
-                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')
+                id: (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(keyId.content, 'retry.keys.key.id', constants_2.SIGNAL_KEY_ID_LENGTH), 'retry.keys.key.id'),
+                publicKey: (0, codec_1.decodeExactLength)(keyValue.content, 'retry.keys.key.value', constants_2.SIGNAL_KEY_DATA_LENGTH)
             }
             : undefined,
         skey: {
-            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')
+            id: (0, codec_1.parseUint)((0, codec_1.decodeExactLength)(signedKeyId.content, 'retry.keys.skey.id', constants_2.SIGNAL_KEY_ID_LENGTH), 'retry.keys.skey.id'),
+            publicKey: (0, codec_1.decodeExactLength)(signedKeyValue.content, 'retry.keys.skey.value', constants_2.SIGNAL_KEY_DATA_LENGTH),
+            signature: (0, codec_1.decodeExactLength)(signedKeySignature.content, 'retry.keys.skey.signature', constants_2.SIGNAL_SIGNATURE_LENGTH)
         }
     };
 }
-function parseRetryReceiptRequest(node) {
+function parseRetryReceiptRequest(node, options) {
     if (node.tag !== constants_1.WA_MESSAGE_TAGS.RECEIPT) {
         return null;
     }
@@ -87,6 +102,7 @@ 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] = (0, helpers_1.findNodeChildrenByTags)(node, [
         'retry',
         constants_1.WA_NODE_TAGS.REGISTRATION,
@@ -98,18 +114,23 @@ function parseRetryReceiptRequest(node) {
     if (!originalMsgId) {
         throw new Error('retry receipt is missing retry.id');
     }
-    const registration = parseFixedLengthBytes(registrationNodeValue.content, constants_2.SIGNAL_REGISTRATION_ID_LENGTH, 'retry.registration');
+    const registration = (0, codec_1.decodeExactLength)(registrationNodeValue.content, 'retry.registration', constants_2.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: (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'),
+        regId: (0, codec_1.parseUint)(registration, 'retry.registration'),
         keyBundle: parseRetryKeyBundle(keysNode)
     };
 }
+function pickRetryStateMax(left, right) {
+    return RETRY_STATE_RANK[left] >= RETRY_STATE_RANK[right] ? left : right;
+}

package/dist/retry/replay.js

@@ -5,7 +5,7 @@ const device_sent_1 = require("../message/device-sent");
 const padding_1 = require("../message/padding");
 const _proto_1 = require("../proto.js");
 const jid_1 = require("../protocol/jid");
-const outbound_1 = require("./outbound");
+const codec_1 = require("./codec");
 const binary_1 = require("../transport/binary");
 const message_1 = require("../transport/node/builders/message");
 const helpers_1 = require("../transport/node/helpers");
@@ -15,9 +15,12 @@ class WaRetryReplayService {
         this.options = options;
     }
     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);
+        const payload = outbound.replayPayload instanceof Uint8Array
+            ? (0, codec_1.decodeRetryReplayPayload)(outbound.replayPayload)
+            : outbound.replayPayload;
+        const requesterParsed = (0, jid_1.parseJidFull)(requesterJid);
+        const requesterAddress = requesterParsed.address;
+        const normalizedRequesterJid = requesterParsed.normalizedJid;
         if (payload.mode === 'plaintext') {
             return this.resendPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount);
         }
@@ -28,7 +31,7 @@ class WaRetryReplayService {
     }
     async resendPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount) {
         if ((0, jid_1.isGroupOrBroadcastJid)(payload.to)) {
-            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress);
+            return this.resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount);
         }
         let payloadUserJid;
         let requesterUserJid;
@@ -53,7 +56,7 @@ 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);
@@ -74,6 +77,7 @@ class WaRetryReplayService {
             addressingMode: requesterAddress.server === 'lid' ? 'lid' : 'pn',
             encType: encrypted.type,
             ciphertext: encrypted.ciphertext,
+            retryCount,
             deviceIdentity
         });
         await this.options.messageClient.sendMessageNode(retryNode);

package/dist/retry/tracker.js

@@ -1,12 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOutboundRetryTracker = createOutboundRetryTracker;
+const jid_1 = require("../protocol/jid");
+const codec_1 = require("./codec");
 const constants_1 = require("./constants");
-const outbound_1 = require("./outbound");
 const primitives_1 = require("../util/primitives");
 function createOutboundRetryTracker(options) {
     const { retryStore, logger } = options;
     const retryTtlMs = retryStore.getTtlMs?.() ?? constants_1.RETRY_OUTBOUND_TTL_MS;
+    const supportsRawReplayPayload = retryStore.supportsRawReplayPayload?.() ?? false;
+    const normalizeEligibleRequesterDeviceJids = (values) => {
+        if (!values || values.length === 0) {
+            return undefined;
+        }
+        const deduped = new Set();
+        for (let index = 0; index < values.length; index += 1) {
+            const raw = values[index]?.trim();
+            if (!raw) {
+                continue;
+            }
+            try {
+                deduped.add((0, jid_1.normalizeDeviceJid)(raw));
+            }
+            catch {
+                continue;
+            }
+        }
+        if (deduped.size === 0) {
+            return undefined;
+        }
+        return Array.from(deduped);
+    };
     const safeUpsertRetryOutboundRecord = async (record) => {
         try {
             await retryStore.upsertOutboundMessage(record);
@@ -25,34 +49,48 @@ function createOutboundRetryTracker(options) {
     return {
         track: async (hint, publish) => {
             const nowMs = Date.now();
-            const expiresAtMs = nowMs + retryTtlMs;
-            const hintedMessageId = hint.messageIdHint?.trim();
             const replayMode = hint.replayPayload.mode;
             const resolvedToJid = hint.toJid ?? (replayMode === 'opaque_node' ? '' : hint.replayPayload.to);
-            const replayPayload = (0, outbound_1.encodeRetryReplayPayload)(hint.replayPayload);
-            let hintedPersisted = false;
-            const createRetryOutboundRecord = (messageId, createdAtMs, updatedAtMs, expiresAtMs) => ({
+            const replayPayload = supportsRawReplayPayload
+                ? hint.replayPayload
+                : (0, codec_1.encodeRetryReplayPayload)(hint.replayPayload);
+            let eligibleRequesterDeviceJids = normalizeEligibleRequesterDeviceJids(hint.eligibleRequesterDeviceJids);
+            if (!eligibleRequesterDeviceJids &&
+                resolvedToJid &&
+                !(0, jid_1.isGroupOrBroadcastJid)(resolvedToJid)) {
+                try {
+                    eligibleRequesterDeviceJids = [(0, jid_1.normalizeDeviceJid)(resolvedToJid)];
+                }
+                catch {
+                    eligibleRequesterDeviceJids = undefined;
+                }
+            }
+            const createRetryOutboundRecord = (messageId, updatedAtMs, expiresAtMs) => ({
                 messageId,
                 toJid: resolvedToJid,
                 participantJid: hint.participantJid,
                 recipientJid: hint.recipientJid,
+                eligibleRequesterDeviceJids,
+                deliveredRequesterDeviceJids: [],
                 messageType: hint.type,
                 replayMode,
                 replayPayload,
                 state: 'pending',
-                createdAtMs,
+                createdAtMs: nowMs,
                 updatedAtMs,
                 expiresAtMs
             });
-            if (hintedMessageId) {
-                hintedPersisted = await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(hintedMessageId, nowMs, nowMs, expiresAtMs));
-            }
             const result = await publish();
-            if (hintedPersisted && hintedMessageId && result.id === hintedMessageId) {
+            const persistedMessageId = result.id.trim();
+            if (!persistedMessageId) {
+                logger.warn('retry outbound record skipped: publish returned empty message id', {
+                    to: resolvedToJid,
+                    mode: replayMode
+                });
                 return result;
             }
             const persistedNowMs = Date.now();
-            await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(result.id, hintedMessageId ? nowMs : persistedNowMs, persistedNowMs, persistedNowMs + retryTtlMs));
+            await safeUpsertRetryOutboundRecord(createRetryOutboundRecord(persistedMessageId, persistedNowMs, persistedNowMs + retryTtlMs));
             return result;
         }
     };