zapo-js 0.1.1 → 0.2.0

package/dist/esm/protocol/jid.js

@@ -1,33 +1,64 @@
 import { WA_DEFAULTS } from './constants.js';
-export function splitJid(jid) {
+const KNOWN_SERVERS = {
+    [WA_DEFAULTS.HOST_DOMAIN]: WA_DEFAULTS.HOST_DOMAIN,
+    [WA_DEFAULTS.GROUP_SERVER]: WA_DEFAULTS.GROUP_SERVER,
+    [WA_DEFAULTS.BROADCAST_SERVER]: WA_DEFAULTS.BROADCAST_SERVER,
+    [WA_DEFAULTS.LID_SERVER]: WA_DEFAULTS.LID_SERVER,
+    [WA_DEFAULTS.HOSTED_SERVER]: WA_DEFAULTS.HOSTED_SERVER,
+    [WA_DEFAULTS.HOSTED_LID_SERVER]: WA_DEFAULTS.HOSTED_LID_SERVER,
+    [WA_DEFAULTS.MSGR_SERVER]: WA_DEFAULTS.MSGR_SERVER,
+    [WA_DEFAULTS.INTEROP_SERVER]: WA_DEFAULTS.INTEROP_SERVER
+};
+/**
+ * Returns the canonical reference for known server strings, avoiding
+ * thousands of duplicate sliced copies (e.g. "lid", "s.whatsapp.net")
+ * that would otherwise be created by repeated JID parsing.
+ */
+function internServer(server) {
+    return KNOWN_SERVERS[server] ?? server;
+}
+function extractDigits(input) {
+    let digits = '';
+    for (let index = 0; index < input.length; index += 1) {
+        const code = input.charCodeAt(index);
+        if (code >= 48 && code <= 57)
+            digits += input[index];
+    }
+    return digits;
+}
+function findAtIndex(jid) {
     const atIndex = jid.indexOf('@');
-    if (atIndex < 1 || atIndex >= jid.length - 1) {
+    if (atIndex < 1 || atIndex >= jid.length - 1)
         throw new Error(`invalid jid: ${jid}`);
-    }
-    return {
-        user: jid.slice(0, atIndex),
-        server: jid.slice(atIndex + 1)
-    };
+    return atIndex;
+}
+export function splitJid(jid) {
+    const atIndex = findAtIndex(jid);
+    return { user: jid.slice(0, atIndex), server: internServer(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;
+    for (let index = 0; index < input.length; index += 1) {
+        const code = input.charCodeAt(index);
+        if (code === 64)
+            return input;
+        if (code === 45) {
+            hasDash = true;
+        }
     }
-    if (input.includes('@')) {
-        return input;
-    }
-    if (input.includes('-')) {
+    const digits = extractDigits(input);
+    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}`);
+function isJidType(jid, 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,56 +70,106 @@ 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 atIndex = findAtIndex(jid);
+    const colonIndex = jid.indexOf(':', 0);
+    const server = internServer(jid.slice(atIndex + 1));
+    if (colonIndex === -1 || colonIndex > atIndex) {
+        return { user: jid.slice(0, atIndex), 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 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) {
+export function parseJidFull(jid) {
     const address = parseSignalAddressFromJid(jid);
-    return `${address.user}@${address.server}`;
+    const userJid = `${address.user}@${address.server}`;
+    const normalizedJid = address.device === 0 ? userJid : `${address.user}:${address.device}@${address.server}`;
+    return { address, userJid, normalizedJid };
+}
+export function canonicalizeSignalServer(server, hostDomain = WA_DEFAULTS.HOST_DOMAIN) {
+    if (server === WA_DEFAULTS.HOSTED_SERVER)
+        return hostDomain;
+    if (server === WA_DEFAULTS.HOSTED_LID_SERVER)
+        return WA_DEFAULTS.LID_SERVER;
+    return server;
+}
+export function canonicalizeSignalJid(jid, hostDomain = WA_DEFAULTS.HOST_DOMAIN) {
+    const address = parseSignalAddressFromJid(jid);
+    const server = canonicalizeSignalServer(address.server ?? WA_DEFAULTS.HOST_DOMAIN, hostDomain);
+    if (address.device === 0)
+        return `${address.user}@${server}`;
+    return `${address.user}:${address.device}@${server}`;
+}
+export function toUserJid(jid, options = {}) {
+    const address = parseSignalAddressFromJid(jid);
+    const server = options.canonicalizeSignalServer === true
+        ? canonicalizeSignalServer(address.server ?? WA_DEFAULTS.HOST_DOMAIN, options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN)
+        : address.server;
+    return `${address.user}@${server}`;
 }
 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 isHostedDeviceId(deviceId) {
+    return deviceId === WA_DEFAULTS.HOSTED_DEVICE_ID;
+}
+export function isHostedServer(server) {
+    return server === WA_DEFAULTS.HOSTED_SERVER || server === WA_DEFAULTS.HOSTED_LID_SERVER;
+}
+export function isHostedDeviceJid(jid) {
+    const { user, server } = splitJid(jid);
+    if (isHostedServer(server)) {
+        return true;
+    }
+    const colonIndex = user.indexOf(':');
+    if (colonIndex < 0) {
+        return false;
+    }
+    const deviceId = Number.parseInt(user.slice(colonIndex + 1), 10);
+    return Number.isSafeInteger(deviceId) && isHostedDeviceId(deviceId);
+}
+export function buildDeviceJid(user, normalizedServer, deviceId, options = {}) {
+    if (options.isHosted === true) {
+        if (!isHostedDeviceId(deviceId)) {
+            return `${user}:${deviceId}@${normalizedServer}`;
+        }
+        const hostedServer = options.rawServer === WA_DEFAULTS.HOSTED_LID_SERVER ||
+            normalizedServer === WA_DEFAULTS.LID_SERVER
+            ? WA_DEFAULTS.HOSTED_LID_SERVER
+            : WA_DEFAULTS.HOSTED_SERVER;
+        return `${user}:${WA_DEFAULTS.HOSTED_DEVICE_ID}@${hostedServer}`;
+    }
+    if (deviceId === 0) {
+        return `${user}@${normalizedServer}`;
+    }
+    return `${user}:${deviceId}@${normalizedServer}`;
+}
 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 = findAtIndex(meJid);
+    const colonIndex = meJid.indexOf(':', 0);
+    const dotIndex = meJid.indexOf('.', 0);
+    const hasColon = colonIndex !== -1 && colonIndex < atIndex;
+    const hasDot = dotIndex !== -1 && dotIndex < atIndex && (colonIndex === -1 || dotIndex < colonIndex);
+    const userEndIndex = hasDot ? dotIndex : hasColon ? colonIndex : atIndex;
+    const username = Number.parseInt(meJid.slice(0, userEndIndex), 10);
+    const device = hasColon ? Number.parseInt(meJid.slice(colonIndex + 1, atIndex), 10) : 0;
+    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) {
+    const digits = extractDigits(input);
+    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/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

@@ -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',
@@ -76,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/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/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,