zapo-js 0.3.0 → 1.0.0

package/dist/esm/protocol/message.js

@@ -11,6 +11,7 @@ export const WA_MESSAGE_TYPES = Object.freeze({
     ACK_TYPE_ERROR: 'error',
     ACK_CLASS_ERROR: 'error',
     ACK_CLASS_MESSAGE: 'message',
+    ACK_CLASS_CALL: 'call',
     RECEIPT_TYPE_DELIVERY: 'delivery',
     RECEIPT_TYPE_SENDER: 'sender',
     RECEIPT_TYPE_INACTIVE: 'inactive',
@@ -21,7 +22,8 @@ export const WA_MESSAGE_TYPES = Object.freeze({
     RECEIPT_TYPE_HISTORY_SYNC: 'hist_sync',
     RECEIPT_TYPE_PEER: 'peer_msg',
     RECEIPT_TYPE_SERVER_ERROR: 'server-error',
-    RECEIPT_TYPE_RETRY: 'retry'
+    RECEIPT_TYPE_RETRY: 'retry',
+    RECEIPT_TYPE_ENC_REKEY_RETRY: 'enc_rekey_retry'
 });
 export const WA_RETRYABLE_ACK_CODES = Object.freeze(['408', '429', '500', '503']);
 export const WA_STANZA_MSG_TYPES = Object.freeze({
@@ -36,6 +38,7 @@ export const WA_STANZA_MSG_TYPES = Object.freeze({
 export const WA_EDIT_ATTRS = Object.freeze({
     MESSAGE_EDIT: '1',
     PIN_IN_CHAT: '2',
+    NEWSLETTER_EDIT: '3',
     SENDER_REVOKE: '7',
     ADMIN_REVOKE: '8'
 });

package/dist/esm/protocol/newsletter.js

@@ -0,0 +1,61 @@
+export const WA_NEWSLETTER_ROLES = Object.freeze({
+    SUBSCRIBER: 'SUBSCRIBER',
+    GUEST: 'GUEST',
+    ADMIN: 'ADMIN',
+    OWNER: 'OWNER'
+});
+export const WA_NEWSLETTER_STATE_TYPES = Object.freeze({
+    ACTIVE: 'ACTIVE',
+    SUSPENDED: 'SUSPENDED',
+    GEOSUSPENDED: 'GEOSUSPENDED',
+    DELETED: 'DELETED',
+    NON_EXISTING: 'NON_EXISTING'
+});
+export const WA_NEWSLETTER_PICTURE_TYPES = Object.freeze({
+    IMAGE: 'IMAGE',
+    PREVIEW: 'PREVIEW'
+});
+export const WA_NEWSLETTER_FETCH_KEY_TYPES = Object.freeze({
+    JID: 'JID',
+    INVITE: 'INVITE'
+});
+export const WA_NEWSLETTER_VIEW_ROLES = Object.freeze({
+    GUEST: 'GUEST',
+    SUBSCRIBER: 'SUBSCRIBER',
+    ADMIN: 'ADMIN',
+    OWNER: 'OWNER'
+});
+export const WA_NEWSLETTER_MUTE_TYPES = Object.freeze({
+    ADMIN_ACTIVITY: 'MUTE_ADMIN_ACTIVITY',
+    FOLLOWER_ACTIVITY: 'MUTE_FOLLOWER_ACTIVITY'
+});
+export const WA_NEWSLETTER_MUTE_VALUES = Object.freeze({
+    ON: 'ON',
+    OFF: 'OFF'
+});
+export const WA_NEWSLETTER_SEND_TYPES = Object.freeze({
+    TEXT: 'text',
+    MEDIA: 'media',
+    REACTION: 'reaction',
+    REVOKE: 'revoke'
+});
+export const WA_NEWSLETTER_RECEIVE_TYPES = Object.freeze({
+    TEXT: 'NewsletterText',
+    MEDIA: 'NewsletterMedia',
+    REACTION: 'NewsletterReaction',
+    REACTION_REVOKE: 'NewsletterReactionRevoke',
+    REVOKE: 'NewsletterRevoke',
+    EDIT: 'NewsletterEdit',
+    POLL_CREATION: 'NewsletterPollCreation',
+    POLL_VOTE: 'NewsletterPollVote',
+    POLL_RESULT_SNAPSHOT: 'NewsletterPollResultSnapshot',
+    QUIZ_CREATION: 'NewsletterQuizCreation',
+    QUESTION: 'NewsletterQuestion',
+    QUESTION_REPLY: 'NewsletterQuestionReply',
+    QUESTION_RESPONSE: 'NewsletterQuestionResponse',
+    WAMO_EMPTY: 'NewsletterWAMOEmpty'
+});
+export const WA_NEWSLETTER_VERIFICATION_STATES = Object.freeze({
+    VERIFIED: 'VERIFIED',
+    UNVERIFIED: 'UNVERIFIED'
+});

package/dist/esm/protocol/nodes.js

@@ -62,7 +62,23 @@ export const WA_NODE_TAGS = Object.freeze({
     EPHEMERAL: 'ephemeral',
     MEMBERSHIP_APPROVAL_MODE: 'membership_approval_mode',
     GROUP_JOIN: 'group_join',
-    ABPROPS: 'abprops'
+    ABPROPS: 'abprops',
+    PLAINTEXT: 'plaintext',
+    PRESENCE: 'presence',
+    CHATSTATE: 'chatstate',
+    CALL: 'call',
+    COMPOSING: 'composing',
+    PAUSED: 'paused',
+    BIZ: 'biz',
+    INTERACTIVE: 'interactive',
+    NATIVE_FLOW: 'native_flow',
+    BOT: 'bot',
+    META: 'meta',
+    STATUS: 'status',
+    USERNAME: 'username',
+    TEXT_STATUS: 'text_status',
+    DISAPPEARING_MODE: 'disappearing_mode',
+    BUSINESS: 'business'
 });
 export const WA_IQ_TYPES = Object.freeze({
     GET: 'get',
@@ -84,8 +100,12 @@ export const WA_XMLNS = Object.freeze({
     STATUS: 'status',
     GROUPS: 'w:g2',
     NEWSLETTER: 'newsletter',
+    TOS: 'tos',
     XMPP_PING: 'urn:xmpp:ping',
     WHATSAPP_PING: 'w:p',
     ABPROPS: 'abt',
-    MEX: 'w:mex'
+    MEX: 'w:mex',
+    BOT: 'bot',
+    DISAPPEARING_MODE: 'disappearing_mode',
+    PASSIVE: 'passive'
 });

package/dist/esm/protocol/notification.js

@@ -3,7 +3,21 @@ export const WA_NOTIFICATION_TYPES = Object.freeze({
     ENCRYPT: 'encrypt',
     DEVICES: 'devices',
     SERVER: 'server',
-    REGISTRATION: 'registration'
+    REGISTRATION: 'registration',
+    NEWSLETTER: 'newsletter',
+    BUSINESS: 'business',
+    PICTURE: 'picture'
+});
+export const WA_BUSINESS_NOTIFICATION_TAGS = Object.freeze({
+    VERIFIED_NAME: 'verified_name',
+    REMOVE: 'remove',
+    PROFILE: 'profile',
+    PRODUCT_CATALOG: 'product_catalog',
+    SUBSCRIPTIONS: 'subscriptions',
+    FEATURE_FLAGS: 'feature_flags'
+});
+export const WA_NEWSLETTER_NOTIFICATION_TAGS = Object.freeze({
+    LIVE_UPDATES: 'live_updates'
 });
 export const WA_REGISTRATION_NOTIFICATION_TAGS = Object.freeze({
     WA_OLD_REGISTRATION: 'wa_old_registration',
@@ -54,5 +68,7 @@ export const WA_GROUP_NOTIFICATION_TAGS = Object.freeze({
     IS_CAPI_HOSTED_GROUP: 'is_capi_hosted_group',
     GROUP_SAFETY_CHECK: 'group_safety_check',
     LIMIT_SHARING_ENABLED: 'limit_sharing_enabled',
-    MISSING_PARTICIPANT_IDENTIFICATION: 'missing_participant_identification'
+    MISSING_PARTICIPANT_IDENTIFICATION: 'missing_participant_identification',
+    GROUP_HISTORY: 'group_history',
+    NO_GROUP_HISTORY: 'no_group_history'
 });

package/dist/esm/protocol/presence.js

@@ -0,0 +1,13 @@
+export const WA_PRESENCE_TYPES = Object.freeze({
+    AVAILABLE: 'available',
+    UNAVAILABLE: 'unavailable',
+    SUBSCRIBE: 'subscribe'
+});
+export const WA_PRESENCE_LAST_SENTINELS = Object.freeze({
+    DENY: 'deny',
+    NONE: 'none',
+    ERROR: 'error'
+});
+export const WA_CHATSTATE_MEDIA = Object.freeze({
+    AUDIO: 'audio'
+});

package/dist/esm/protocol/status.js

@@ -0,0 +1,6 @@
+export const WA_STATUS_DISTRIBUTION_SETTINGS = Object.freeze({
+    CONTACTS: 'contacts',
+    ALLOWLIST: 'allowlist',
+    DENYLIST: 'denylist',
+    CLOSE_FRIENDS: 'close_friends'
+});

package/dist/esm/retry/codec.js

@@ -16,6 +16,10 @@ const RETRY_PAYLOAD_ENC_TYPE_REVERSE = Object.freeze({
     2: 'pkmsg',
     3: 'skmsg'
 });
+/**
+ * Encodes a {@link WaRetryReplayPayload} into the on-disk codec format used
+ * by the retry store. Supports the `plaintext`/`encrypted`/`opaque_node` modes.
+ */
 export function encodeRetryReplayPayload(payload) {
     const chunks = [];
     if (payload.mode === 'plaintext') {
@@ -56,6 +60,7 @@ export function encodeRetryReplayPayload(payload) {
     pushBytesField(chunks, payload.node, 'node');
     return concatBytes(chunks);
 }
+/** Inverse of {@link encodeRetryReplayPayload}. Throws on bad magic/version. */
 export function decodeRetryReplayPayload(raw) {
     if (raw.byteLength < 3) {
         throw new Error('invalid retry replay payload: unsupported codec version');

package/dist/esm/retry/parse.js

@@ -1,8 +1,8 @@
-import { WA_MESSAGE_TAGS, WA_NODE_TAGS } from '../protocol/constants.js';
+import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, 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 { decodeExactLength, parseSignalKeyBundleFromNode, parseUint } from '../signal/api/codec.js';
+import { SIGNAL_REGISTRATION_ID_LENGTH } from '../signal/api/constants.js';
+import { findNodeChildrenByTags } from '../transport/node/helpers.js';
 import { parseOptionalInt } from '../util/primitives.js';
 const RETRY_STATE_RANK = {
     pending: 0,
@@ -47,47 +47,25 @@ function parseRetryKeyBundle(node) {
     if (!node) {
         return undefined;
     }
-    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;
+    const parsed = parseSignalKeyBundleFromNode(node, 'retry.keys');
     return {
-        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: 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: 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)
-        }
+        identity: parsed.identity,
+        ...(parsed.deviceIdentity ? { deviceIdentity: parsed.deviceIdentity } : {}),
+        ...(parsed.oneTimeKey ? { key: parsed.oneTimeKey } : {}),
+        skey: parsed.signedKey
     };
 }
+/**
+ * Parses an incoming `receipt` stanza into a {@link WaParsedRetryRequest}.
+ * Returns `null` when the stanza is not a retry/rekey-retry receipt; throws
+ * when required attrs/children are missing.
+ */
 export function parseRetryReceiptRequest(node, options) {
     if (node.tag !== WA_MESSAGE_TAGS.RECEIPT) {
         return null;
     }
-    const receiptType = node.attrs.type === 'retry' || node.attrs.type === 'enc_rekey_retry'
+    const receiptType = node.attrs.type === WA_MESSAGE_TYPES.RECEIPT_TYPE_RETRY ||
+        node.attrs.type === WA_MESSAGE_TYPES.RECEIPT_TYPE_ENC_REKEY_RETRY
         ? node.attrs.type
         : null;
     if (!receiptType) {
@@ -127,6 +105,10 @@ export function parseRetryReceiptRequest(node, options) {
         keyBundle: parseRetryKeyBundle(keysNode)
     };
 }
+/**
+ * Returns whichever of `left`/`right` represents the more advanced retry
+ * state (according to the internal precedence rank).
+ */
 export function pickRetryStateMax(left, right) {
     return RETRY_STATE_RANK[left] >= RETRY_STATE_RANK[right] ? left : right;
 }

package/dist/esm/retry/reason.js

@@ -37,6 +37,11 @@ const RETRY_REASON_MATCHERS = [
         code: RETRY_REASON.StatusRevokeDelay
     }
 ];
+/**
+ * Maps a decryption/Signal error to the appropriate {@link WaRetryReasonCode}
+ * so an outbound retry receipt carries the correct `error` attribute.
+ * Returns `undefined` when no known reason matches.
+ */
 export function mapRetryReasonFromError(error) {
     const message = toError(error).message.toLowerCase();
     for (const matcher of RETRY_REASON_MATCHERS) {

package/dist/esm/retry/replay.js

@@ -1,16 +1,28 @@
-import { wrapDeviceSentMessage } from '../message/device-sent.js';
-import { unpadPkcs7, writeRandomPadMax16 } from '../message/padding.js';
+import { injectDeviceListMetadata } from '../message/crypto/icdc.js';
+import { wrapDeviceSentMessage } from '../message/encode/device-sent.js';
+import { unpadPkcs7, writeRandomPadMax16 } from '../message/encode/padding.js';
 import { proto } from '../proto.js';
-import { isGroupOrBroadcastJid, normalizeDeviceJid, parseJidFull, toUserJid } from '../protocol/jid.js';
+import { WA_DEFAULTS, WA_NODE_TAGS } from '../protocol/constants.js';
+import { isGroupOrBroadcastJid, isHostedDeviceJid, isStatusBroadcastJid, 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 { buildGroupRetryMessageNode, buildMetaNode } from '../transport/node/builders/message.js';
 import { findNodeChild } from '../transport/node/helpers.js';
 import { toError } from '../util/primitives.js';
+/**
+ * Replays a previously-sent outbound message in response to an incoming
+ * retry receipt. Dispatches to plaintext/encrypted/opaque-node handlers
+ * based on the stored payload shape.
+ */
 export class WaRetryReplayService {
     constructor(options) {
         this.options = options;
     }
+    /**
+     * Resends `outbound` to `requesterJid`. Returns `'resent'` on a fresh
+     * send or `'ineligible'` when the cached payload cannot satisfy the
+     * request (e.g. requester not in the original device list).
+     */
     async resendOutboundMessage(outbound, requesterJid, retryCount) {
         const payload = outbound.replayPayload instanceof Uint8Array
             ? decodeRetryReplayPayload(outbound.replayPayload)
@@ -39,43 +51,137 @@ export class WaRetryReplayService {
         catch {
             return 'ineligible';
         }
-        if (payloadUserJid !== requesterUserJid) {
+        const requesterIsSelf = this.isRequesterCurrentAccount(requesterJid);
+        if (payloadUserJid !== requesterUserJid && !requesterIsSelf) {
             return 'ineligible';
         }
-        const encrypted = await this.options.signalProtocol.encryptMessage(requesterAddress, payload.plaintext);
+        const plaintext = (await this.refreshRetryPlaintext(payload, {
+            wrapAsDeviceSent: requesterIsSelf,
+            includeRecipientIcdc: true,
+            logContext: 'direct'
+        })) ?? payload.plaintext;
+        await this.options.sessionResolver.ensureSession(requesterAddress, requesterJid);
+        const encrypted = await this.options.signalProtocol.encryptMessage(requesterAddress, plaintext);
+        const deviceIdentity = encrypted.type === 'pkmsg' ? this.resolveSignedDeviceIdentity('direct') : undefined;
+        const metaNode = isHostedDeviceJid(requesterJid)
+            ? buildMetaNode({ sender_intent: 'hosted' })
+            : undefined;
         await this.options.messageClient.sendEncrypted({
             to: requesterJid,
             encType: encrypted.type,
             ciphertext: encrypted.ciphertext,
             encCount: retryCount,
             id: outbound.messageId,
-            type: payload.type
+            type: payload.type,
+            deviceIdentity,
+            metaNode
         });
         return 'resent';
     }
+    resolveSignedDeviceIdentity(context) {
+        const signedIdentity = this.options.getCurrentCredentials()?.signedIdentity;
+        if (!signedIdentity) {
+            this.options.logger.warn('retry request missing signed identity for pkmsg envelope', {
+                context
+            });
+            return undefined;
+        }
+        return proto.ADVSignedDeviceIdentity.encode(signedIdentity).finish();
+    }
+    async refreshRetryPlaintext(payload, options) {
+        if (!options.wrapAsDeviceSent && !this.options.resolveUserIcdc) {
+            return null;
+        }
+        try {
+            const messageBytes = unpadPkcs7(payload.plaintext);
+            const decoded = proto.Message.decode(messageBytes);
+            let message = decoded;
+            let changed = false;
+            if (this.options.resolveUserIcdc) {
+                const meUserJid = this.safeUserJid(this.options.getCurrentCredentials()?.meJid);
+                const recipientUserJid = options.includeRecipientIcdc
+                    ? this.safeUserJid(payload.to)
+                    : null;
+                const [senderIcdc, recipientIcdc] = await Promise.all([
+                    meUserJid ? this.options.resolveUserIcdc(meUserJid) : Promise.resolve(null),
+                    recipientUserJid
+                        ? this.options.resolveUserIcdc(recipientUserJid)
+                        : Promise.resolve(null)
+                ]);
+                const injected = injectDeviceListMetadata(message, senderIcdc, recipientIcdc);
+                if (injected !== message) {
+                    message = injected;
+                    changed = true;
+                }
+            }
+            if (options.wrapAsDeviceSent && !message.deviceSentMessage) {
+                message = wrapDeviceSentMessage(message, payload.to);
+                changed = true;
+            }
+            if (!changed) {
+                return null;
+            }
+            return writeRandomPadMax16(proto.Message.encode(message).finish());
+        }
+        catch (error) {
+            this.options.logger.warn('retry request failed to refresh plaintext', {
+                context: options.logContext,
+                to: payload.to,
+                message: toError(error).message
+            });
+            return null;
+        }
+    }
+    safeUserJid(jid) {
+        if (!jid)
+            return null;
+        try {
+            return toUserJid(jid);
+        }
+        catch {
+            return null;
+        }
+    }
     async resendGroupPlaintextPayload(outbound, payload, requesterJid, requesterAddress, retryCount) {
-        const plaintext = (await this.maybeWrapGroupRetryPlaintextForSelfDevice(payload, requesterJid)) ??
-            payload.plaintext;
+        const plaintext = (await this.refreshRetryPlaintext(payload, {
+            wrapAsDeviceSent: this.isRequesterCurrentAccount(requesterJid),
+            includeRecipientIcdc: false,
+            logContext: 'group'
+        })) ?? payload.plaintext;
         const encrypted = await this.options.signalProtocol.encryptMessage(requesterAddress, plaintext);
         let deviceIdentity;
         if (encrypted.type === 'pkmsg') {
-            const signedIdentity = this.options.getCurrentSignedIdentity();
+            const signedIdentity = this.options.getCurrentCredentials()?.signedIdentity;
             if (!signedIdentity) {
                 this.options.logger.warn('retry request rejected: missing signed identity for pkmsg group retry');
                 return 'ineligible';
             }
             deviceIdentity = proto.ADVSignedDeviceIdentity.encode(signedIdentity).finish();
         }
+        const isStatus = isStatusBroadcastJid(payload.to);
+        const metaAttrs = {};
+        if (isStatus) {
+            metaAttrs.status_setting = payload.statusSetting ?? 'contacts';
+        }
+        if (isHostedDeviceJid(requesterJid)) {
+            metaAttrs.sender_intent = 'hosted';
+        }
+        const metaNode = Object.keys(metaAttrs).length > 0 ? buildMetaNode(metaAttrs) : undefined;
         const retryNode = buildGroupRetryMessageNode({
             to: payload.to,
             type: payload.type,
             id: outbound.messageId,
             requesterJid,
-            addressingMode: requesterAddress.server === 'lid' ? 'lid' : 'pn',
+            addressingMode: isStatus
+                ? undefined
+                : requesterAddress.server === WA_DEFAULTS.LID_SERVER
+                    ? 'lid'
+                    : 'pn',
             encType: encrypted.type,
             ciphertext: encrypted.ciphertext,
             retryCount,
-            deviceIdentity
+            deviceIdentity,
+            metaNode
         });
         await this.options.messageClient.sendMessageNode(retryNode);
         return 'resent';
@@ -87,6 +193,12 @@ export class WaRetryReplayService {
         if (normalizeDeviceJid(payload.to) !== normalizedRequesterJid) {
             return 'ineligible';
         }
+        const deviceIdentity = payload.encType === 'pkmsg'
+            ? this.resolveSignedDeviceIdentity('encrypted_replay')
+            : undefined;
+        const metaNode = isHostedDeviceJid(requesterJid)
+            ? buildMetaNode({ sender_intent: 'hosted' })
+            : undefined;
         await this.options.messageClient.sendEncrypted({
             to: requesterJid,
             encType: payload.encType,
@@ -94,7 +206,9 @@ export class WaRetryReplayService {
             encCount: retryCount,
             id: outbound.messageId,
             type: payload.type,
-            participant: payload.participant
+            participant: payload.participant,
+            deviceIdentity,
+            metaNode
         });
         return 'resent';
     }
@@ -115,39 +229,19 @@ export class WaRetryReplayService {
         await this.options.messageClient.sendMessageNode(replayNode);
         return 'resent';
     }
-    async maybeWrapGroupRetryPlaintextForSelfDevice(payload, requesterJid) {
-        if (!this.isRequesterCurrentAccount(requesterJid)) {
-            return null;
-        }
-        try {
-            const messageBytes = unpadPkcs7(payload.plaintext);
-            const message = proto.Message.decode(messageBytes);
-            const wrapped = wrapDeviceSentMessage(message, payload.to);
-            return writeRandomPadMax16(proto.Message.encode(wrapped).finish());
-        }
-        catch (error) {
-            this.options.logger.warn('retry request failed to wrap deviceSent payload for self requester', {
-                requester: requesterJid,
-                to: payload.to,
-                message: toError(error).message
-            });
-            return null;
-        }
-    }
     isRequesterCurrentAccount(requesterJid) {
         const requesterUser = toUserJid(requesterJid);
-        const meJid = this.options.getCurrentMeJid();
-        if (meJid && toUserJid(meJid) === requesterUser) {
+        const credentials = this.options.getCurrentCredentials();
+        if (credentials?.meJid && toUserJid(credentials.meJid) === requesterUser) {
             return true;
         }
-        const meLid = this.options.getCurrentMeLid();
-        if (meLid && toUserJid(meLid) === requesterUser) {
+        if (credentials?.meLid && toUserJid(credentials.meLid) === requesterUser) {
             return true;
         }
         return false;
     }
     isOpaqueReplayCompatible(node, normalizedRequesterJid) {
-        const participantsNode = findNodeChild(node, 'participants');
+        const participantsNode = findNodeChild(node, WA_NODE_TAGS.PARTICIPANTS);
         if (participantsNode) {
             const participantsContent = Array.isArray(participantsNode.content)
                 ? participantsNode.content

package/dist/esm/retry/tracker.js

@@ -1,7 +1,8 @@
-import { isGroupOrBroadcastJid, normalizeDeviceJid } from '../protocol/jid.js';
+import { isGroupOrBroadcastJid, toUserJid } from '../protocol/jid.js';
 import { encodeRetryReplayPayload } from './codec.js';
 import { RETRY_OUTBOUND_TTL_MS } from './constants.js';
 import { toError } from '../util/primitives.js';
+/** Builds an {@link OutboundRetryTracker} backed by a {@link WaRetryStore}. */
 export function createOutboundRetryTracker(options) {
     const { retryStore, logger } = options;
     const retryTtlMs = retryStore.getTtlMs?.() ?? RETRY_OUTBOUND_TTL_MS;
@@ -17,7 +18,7 @@ export function createOutboundRetryTracker(options) {
                 continue;
             }
             try {
-                deduped.add(normalizeDeviceJid(raw));
+                deduped.add(toUserJid(raw));
             }
             catch {
                 continue;
@@ -45,7 +46,6 @@ export function createOutboundRetryTracker(options) {
     };
     return {
         track: async (hint, publish) => {
-            const nowMs = Date.now();
             const replayMode = hint.replayPayload.mode;
             const resolvedToJid = hint.toJid ?? (replayMode === 'opaque_node' ? '' : hint.replayPayload.to);
             const replayPayload = supportsRawReplayPayload
@@ -56,7 +56,7 @@ export function createOutboundRetryTracker(options) {
                 resolvedToJid &&
                 !isGroupOrBroadcastJid(resolvedToJid)) {
                 try {
-                    eligibleRequesterDeviceJids = [normalizeDeviceJid(resolvedToJid)];
+                    eligibleRequesterDeviceJids = [toUserJid(resolvedToJid)];
                 }
                 catch {
                     eligibleRequesterDeviceJids = undefined;
@@ -65,15 +65,11 @@ export function createOutboundRetryTracker(options) {
             const createRetryOutboundRecord = (messageId, updatedAtMs, expiresAtMs) => ({
                 messageId,
                 toJid: resolvedToJid,
-                participantJid: hint.participantJid,
-                recipientJid: hint.recipientJid,
                 eligibleRequesterDeviceJids,
                 deliveredRequesterDeviceJids: [],
-                messageType: hint.type,
                 replayMode,
                 replayPayload,
                 state: 'pending',
-                createdAtMs: nowMs,
                 updatedAtMs,
                 expiresAtMs
             });