zapo-js 0.1.1 → 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.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,9 +11,11 @@ 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");
+Object.defineProperty(exports, "createOutboundRetryTracker", { enumerable: true, get: function () { return tracker_1.createOutboundRetryTracker; } });

package/dist/retry/parse.js

@@ -1,101 +1,99 @@
 "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 parse_1 = require("../transport/stream/parse");
-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) {
-    if (bytes.byteLength === 0 || bytes.byteLength > 4) {
-        throw new Error(`${field} has invalid byte length`);
-    }
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    if (bytes.byteLength === 1) {
-        return view.getUint8(0);
-    }
-    if (bytes.byteLength === 2) {
-        return view.getUint16(0);
-    }
-    return bytes.byteLength === 3 ? (view.getUint16(0) << 8) | view.getUint8(2) : view.getUint32(0);
-}
-function parseRetryType(value) {
-    if (value === 'retry' || value === 'enc_rekey_retry') {
-        return value;
-    }
-    return null;
-}
-function parseRetryCount(value) {
-    const parsed = (0, parse_1.parseOptionalInt)(value);
-    if (parsed === undefined) {
-        return 0;
-    }
-    if (parsed < 0) {
-        throw new Error('retry count must be >= 0');
+const primitives_1 = require("../util/primitives");
+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 parsed;
+    return node;
 }
-function parseRetryReason(value) {
-    const parsed = (0, parse_1.parseOptionalInt)(value);
-    if (parsed === undefined) {
-        return undefined;
-    }
-    if (parsed < 0) {
-        throw new Error('retry reason must be >= 0');
+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;
+        }
     }
-    return parsed;
+    throw new Error('retry receipt to attr does not match local device');
 }
 function parseRetryKeyBundle(node) {
     if (!node) {
         return undefined;
     }
-    const identityNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.IDENTITY);
-    const signedKeyNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.SKEY);
-    if (!identityNode || !signedKeyNode) {
-        throw new Error('retry keys section missing identity or skey');
-    }
-    const signedKeyIdNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.ID);
-    const signedKeyValueNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.VALUE);
-    const signedKeySignatureNode = (0, helpers_1.findNodeChild)(signedKeyNode, constants_1.WA_NODE_TAGS.SIGNATURE);
-    if (!signedKeyIdNode || !signedKeyValueNode || !signedKeySignatureNode) {
-        throw new Error('retry keys section has incomplete skey');
-    }
-    const keyNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.KEY);
-    const keyIdNode = keyNode ? (0, helpers_1.findNodeChild)(keyNode, constants_1.WA_NODE_TAGS.ID) : undefined;
-    const keyValueNode = keyNode ? (0, helpers_1.findNodeChild)(keyNode, constants_1.WA_NODE_TAGS.VALUE) : undefined;
-    if (keyNode && (!keyIdNode || !keyValueNode)) {
-        throw new Error('retry keys section has incomplete key');
-    }
-    const deviceIdentityNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.DEVICE_IDENTITY);
+    const [identityNode, signedKeyNode, keyNode, deviceIdentityNode] = (0, helpers_1.findNodeChildrenByTags)(node, [constants_1.WA_NODE_TAGS.IDENTITY, constants_1.WA_NODE_TAGS.SKEY, constants_1.WA_NODE_TAGS.KEY, constants_1.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] = (0, helpers_1.findNodeChildrenByTags)(signedKey, [constants_1.WA_NODE_TAGS.ID, constants_1.WA_NODE_TAGS.VALUE, constants_1.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 = (0, helpers_1.findNodeChildrenByTags)(keyNode, [constants_1.WA_NODE_TAGS.ID, constants_1.WA_NODE_TAGS.VALUE]);
+        keyIdNode = keyNodes[0];
+        keyValueNode = keyNodes[1];
+    }
+    const keyId = keyNode ? requireNode(keyIdNode, 'retry keys section has incomplete key') : null;
+    const keyValue = keyNode
+        ? requireNode(keyValueNode, 'retry keys section has incomplete key')
+        : null;
     return {
-        identity: parseFixedLengthBytes(identityNode.content, 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: keyIdNode && keyValueNode
+        key: keyId && keyValue
             ? {
-                id: parseBigEndianUint(parseFixedLengthBytes(keyIdNode.content, constants_2.SIGNAL_KEY_ID_LENGTH, 'retry.keys.key.id'), 'retry.keys.key.id'),
-                publicKey: parseFixedLengthBytes(keyValueNode.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(signedKeyIdNode.content, constants_2.SIGNAL_KEY_ID_LENGTH, 'retry.keys.skey.id'), 'retry.keys.skey.id'),
-            publicKey: parseFixedLengthBytes(signedKeyValueNode.content, constants_2.SIGNAL_KEY_DATA_LENGTH, 'retry.keys.skey.value'),
-            signature: parseFixedLengthBytes(signedKeySignatureNode.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;
     }
-    const receiptType = parseRetryType(node.attrs.type);
+    const receiptType = node.attrs.type === 'retry' || node.attrs.type === 'enc_rekey_retry'
+        ? node.attrs.type
+        : null;
     if (!receiptType) {
         return null;
     }
@@ -104,30 +102,35 @@ function parseRetryReceiptRequest(node) {
     if (!stanzaId || !from) {
         throw new Error('retry receipt is missing id/from attrs');
     }
-    const retryNode = (0, helpers_1.findNodeChild)(node, 'retry');
-    if (!retryNode) {
-        throw new Error('retry receipt is missing retry child');
-    }
-    const registrationNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.REGISTRATION);
-    if (!registrationNode) {
-        throw new Error('retry receipt is missing registration child');
-    }
-    const originalMsgId = retryNode.attrs.id;
+    validateRetryReceiptToAttr(node.attrs.to, options?.expectedToJids);
+    const [retryNode, registrationNode, keysNode] = (0, helpers_1.findNodeChildrenByTags)(node, [
+        'retry',
+        constants_1.WA_NODE_TAGS.REGISTRATION,
+        'keys'
+    ]);
+    const retry = requireNode(retryNode, 'retry receipt is missing retry child');
+    const registrationNodeValue = requireNode(registrationNode, 'retry receipt is missing registration child');
+    const originalMsgId = retry.attrs.id;
     if (!originalMsgId) {
         throw new Error('retry receipt is missing retry.id');
     }
-    const registration = parseFixedLengthBytes(registrationNode.content, 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: parseRetryCount(retryNode.attrs.count),
-        retryReason: parseRetryReason(retryNode.attrs.error ?? node.attrs.error),
-        t: retryNode.attrs.t ?? node.attrs.t,
-        regId: parseBigEndianUint(registration, 'retry.registration'),
-        keyBundle: parseRetryKeyBundle((0, helpers_1.findNodeChild)(node, 'keys'))
+        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: (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;
+}