zapo-js 0.2.0 → 0.3.0

package/dist/store/providers/memory/pre-key.store.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaPreKeyMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULT_MAX_PRE_KEYS = 4096;
+class WaPreKeyMemoryStore {
+    constructor(options = {}) {
+        this.preKeys = new Map();
+        this.uploadedPreKeys = new Set();
+        this.serverHasPreKeys = false;
+        this.nextPreKeyId = 1;
+        this.maxPreKeys = (0, coercion_1.resolvePositive)(options.maxPreKeys, DEFAULT_MAX_PRE_KEYS, 'WaPreKeyMemoryStoreOptions.maxPreKeys');
+    }
+    async putPreKey(record) {
+        (0, collections_1.setBoundedMapEntry)(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
+            this.uploadedPreKeys.delete(keyId);
+        });
+        if (record.keyId >= this.nextPreKeyId) {
+            this.nextPreKeyId = record.keyId + 1;
+        }
+    }
+    async getOrGenPreKeys(count, generator) {
+        if (!Number.isSafeInteger(count) || count <= 0) {
+            throw new Error(`invalid prekey count: ${count}`);
+        }
+        const available = [];
+        const availableKeyIds = [];
+        for (const keyId of this.preKeys.keys()) {
+            if (!this.uploadedPreKeys.has(keyId)) {
+                availableKeyIds.push(keyId);
+            }
+        }
+        availableKeyIds.sort((left, right) => left - right);
+        for (let index = 0; index < availableKeyIds.length; index += 1) {
+            const keyId = availableKeyIds[index];
+            const record = this.preKeys.get(keyId);
+            if (!record) {
+                continue;
+            }
+            available.push(record);
+            if (available.length >= count) {
+                return available;
+            }
+        }
+        while (available.length < count) {
+            const record = await generator(this.nextPreKeyId++);
+            (0, collections_1.setBoundedMapEntry)(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
+                this.uploadedPreKeys.delete(keyId);
+            });
+            available.push(record);
+        }
+        return available;
+    }
+    async getPreKeyById(keyId) {
+        return this.preKeys.get(keyId) ?? null;
+    }
+    async getPreKeysById(keyIds) {
+        const result = new Array(keyIds.length);
+        for (let i = 0; i < keyIds.length; i += 1) {
+            result[i] = this.preKeys.get(keyIds[i]) ?? null;
+        }
+        return result;
+    }
+    async consumePreKeyById(keyId) {
+        const record = this.preKeys.get(keyId) ?? null;
+        if (!record) {
+            return null;
+        }
+        this.preKeys.delete(keyId);
+        this.uploadedPreKeys.delete(keyId);
+        return record;
+    }
+    async getOrGenSinglePreKey(generator) {
+        const preKeys = await this.getOrGenPreKeys(1, generator);
+        return preKeys[0];
+    }
+    async markKeyAsUploaded(keyId) {
+        if (keyId < 0 || keyId >= this.nextPreKeyId) {
+            throw new Error(`prekey ${keyId} is out of boundary`);
+        }
+        for (const candidate of this.preKeys.keys()) {
+            if (candidate <= keyId) {
+                this.uploadedPreKeys.add(candidate);
+            }
+        }
+    }
+    async setServerHasPreKeys(value) {
+        this.serverHasPreKeys = value;
+    }
+    async getServerHasPreKeys() {
+        return this.serverHasPreKeys;
+    }
+    async clear() {
+        this.preKeys.clear();
+        this.uploadedPreKeys.clear();
+        this.serverHasPreKeys = false;
+        this.nextPreKeyId = 1;
+    }
+}
+exports.WaPreKeyMemoryStore = WaPreKeyMemoryStore;

package/dist/store/providers/memory/retry.store.js

@@ -1,17 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaRetryMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
 const collections_1 = require("../../../util/collections");
-const DEFAULT_RETRY_TTL_MS = 60 * 1000;
+const DEFAULTS = Object.freeze({
+    ttlMs: 60 * 1000,
+    maxOutboundMessages: 10000,
+    maxInboundCounters: 20000
+});
 class WaRetryMemoryStore {
-    constructor(ttlMs = DEFAULT_RETRY_TTL_MS) {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('retry ttlMs must be a positive finite number');
+        }
         this.outboundMessages = new Map();
         this.eligibleSets = new Map();
         this.inboundCounters = new Map();
         this.ttlMs = ttlMs;
+        this.maxOutboundMessages = (0, coercion_1.resolvePositive)(options.maxOutboundMessages, DEFAULTS.maxOutboundMessages, 'WaRetryMemoryStoreOptions.maxOutboundMessages');
+        this.maxInboundCounters = (0, coercion_1.resolvePositive)(options.maxInboundCounters, DEFAULTS.maxInboundCounters, 'WaRetryMemoryStoreOptions.maxInboundCounters');
         this.cleanupTimer = setInterval(() => {
             void this.cleanupExpired(Date.now());
-        }, (0, collections_1.resolveCleanupIntervalMs)(ttlMs));
+        }, (0, collections_1.resolveCleanupIntervalMs)(this.ttlMs));
         this.cleanupTimer.unref();
     }
     getTtlMs() {
@@ -57,7 +67,7 @@ class WaRetryMemoryStore {
         return { eligible: true, delivered: false };
     }
     async upsertOutboundMessage(record) {
-        this.outboundMessages.set(record.messageId, {
+        const storedRecord = {
             ...record,
             eligibleRequesterDeviceJids: record.eligibleRequesterDeviceJids
                 ? [...record.eligibleRequesterDeviceJids]
@@ -65,6 +75,9 @@ class WaRetryMemoryStore {
             deliveredRequesterDeviceJids: record.deliveredRequesterDeviceJids
                 ? [...record.deliveredRequesterDeviceJids]
                 : undefined
+        };
+        (0, collections_1.setBoundedMapEntry)(this.outboundMessages, record.messageId, storedRecord, this.maxOutboundMessages, (messageId) => {
+            this.eligibleSets.delete(messageId);
         });
         if (record.eligibleRequesterDeviceJids && record.eligibleRequesterDeviceJids.length > 0) {
             this.eligibleSets.set(record.messageId, new Set(record.eligibleRequesterDeviceJids));
@@ -86,11 +99,13 @@ class WaRetryMemoryStore {
         if (!current) {
             return;
         }
-        this.outboundMessages.set(messageId, {
+        (0, collections_1.setBoundedMapEntry)(this.outboundMessages, messageId, {
             ...current,
             state,
             updatedAtMs,
             expiresAtMs
+        }, this.maxOutboundMessages, (evictedMessageId) => {
+            this.eligibleSets.delete(evictedMessageId);
         });
     }
     async markOutboundRequesterDelivered(messageId, requesterDeviceJid, updatedAtMs, expiresAtMs) {
@@ -100,21 +115,20 @@ class WaRetryMemoryStore {
         }
         const delivered = new Set(current.deliveredRequesterDeviceJids ?? []);
         delivered.add(requesterDeviceJid);
-        this.outboundMessages.set(messageId, {
+        (0, collections_1.setBoundedMapEntry)(this.outboundMessages, messageId, {
             ...current,
             deliveredRequesterDeviceJids: Array.from(delivered),
             updatedAtMs,
             expiresAtMs
+        }, this.maxOutboundMessages, (evictedMessageId) => {
+            this.eligibleSets.delete(evictedMessageId);
         });
     }
     async incrementInboundCounter(messageId, requesterJid, _updatedAtMs, expiresAtMs) {
         const key = this.counterKey(messageId, requesterJid);
         const current = this.inboundCounters.get(key);
         const count = current ? current.count + 1 : 1;
-        this.inboundCounters.set(key, {
-            count,
-            expiresAtMs
-        });
+        (0, collections_1.setBoundedMapEntry)(this.inboundCounters, key, { count, expiresAtMs }, this.maxInboundCounters);
         return count;
     }
     async cleanupExpired(nowMs) {

package/dist/store/providers/memory/session.store.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaSessionMemoryStore = void 0;
+const jid_1 = require("../../../protocol/jid");
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULT_MAX_SESSIONS = 8192;
+class WaSessionMemoryStore {
+    constructor(options = {}) {
+        this.signalSessions = new Map();
+        this.maxSessions = (0, coercion_1.resolvePositive)(options.maxSessions, DEFAULT_MAX_SESSIONS, 'WaSessionMemoryStoreOptions.maxSessions');
+    }
+    async hasSession(address) {
+        return this.signalSessions.has((0, jid_1.signalAddressKey)(address));
+    }
+    async hasSessions(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.has((0, jid_1.signalAddressKey)(addresses[i]));
+        }
+        return result;
+    }
+    async getSession(address) {
+        return this.signalSessions.get((0, jid_1.signalAddressKey)(address)) ?? null;
+    }
+    async getSessionsBatch(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.get((0, jid_1.signalAddressKey)(addresses[i])) ?? null;
+        }
+        return result;
+    }
+    async setSession(address, session) {
+        (0, collections_1.setBoundedMapEntry)(this.signalSessions, (0, jid_1.signalAddressKey)(address), session, this.maxSessions);
+    }
+    async setSessionsBatch(entries) {
+        for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            (0, collections_1.setBoundedMapEntry)(this.signalSessions, (0, jid_1.signalAddressKey)(entry.address), entry.session, this.maxSessions);
+        }
+    }
+    async deleteSession(address) {
+        this.signalSessions.delete((0, jid_1.signalAddressKey)(address));
+    }
+    async clear() {
+        this.signalSessions.clear();
+    }
+}
+exports.WaSessionMemoryStore = WaSessionMemoryStore;

package/dist/store/providers/memory/signal.store.js

@@ -1,28 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaSignalMemoryStore = void 0;
-const jid_1 = require("../../../protocol/jid");
-const coercion_1 = require("../../../util/coercion");
-const collections_1 = require("../../../util/collections");
-const DEFAULT_SIGNAL_STORE_LIMITS = Object.freeze({
-    preKeys: 4096,
-    sessions: 8192,
-    remoteIdentities: 8192
-});
 class WaSignalMemoryStore {
-    constructor(options = {}) {
+    constructor() {
         this.registrationInfo = null;
         this.signedPreKey = null;
         this.signedPreKeyRotationTs = null;
-        this.preKeys = new Map();
-        this.uploadedPreKeys = new Set();
-        this.serverHasPreKeys = false;
-        this.signalSessions = new Map();
-        this.remoteIdentities = new Map();
-        this.nextPreKeyId = 1;
-        this.maxPreKeys = (0, coercion_1.resolvePositive)(options.maxPreKeys, DEFAULT_SIGNAL_STORE_LIMITS.preKeys, 'WaSignalMemoryStoreOptions.maxPreKeys');
-        this.maxSessions = (0, coercion_1.resolvePositive)(options.maxSessions, DEFAULT_SIGNAL_STORE_LIMITS.sessions, 'WaSignalMemoryStoreOptions.maxSessions');
-        this.maxRemoteIdentities = (0, coercion_1.resolvePositive)(options.maxRemoteIdentities, DEFAULT_SIGNAL_STORE_LIMITS.remoteIdentities, 'WaSignalMemoryStoreOptions.maxRemoteIdentities');
     }
     async getRegistrationInfo() {
         return this.registrationInfo;
@@ -48,156 +31,10 @@ class WaSignalMemoryStore {
     async getSignedPreKeyRotationTs() {
         return this.signedPreKeyRotationTs;
     }
-    async putPreKey(record) {
-        (0, collections_1.setBoundedMapEntry)(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
-            this.uploadedPreKeys.delete(keyId);
-        });
-        if (record.keyId >= this.nextPreKeyId) {
-            this.nextPreKeyId = record.keyId + 1;
-        }
-    }
-    async getOrGenPreKeys(count, generator) {
-        if (!Number.isSafeInteger(count) || count <= 0) {
-            throw new Error(`invalid prekey count: ${count}`);
-        }
-        const available = [];
-        const availableKeyIds = [];
-        for (const keyId of this.preKeys.keys()) {
-            if (!this.uploadedPreKeys.has(keyId)) {
-                availableKeyIds.push(keyId);
-            }
-        }
-        availableKeyIds.sort((left, right) => left - right);
-        for (let index = 0; index < availableKeyIds.length; index += 1) {
-            const keyId = availableKeyIds[index];
-            const record = this.preKeys.get(keyId);
-            if (!record) {
-                continue;
-            }
-            available.push(record);
-            if (available.length >= count) {
-                return available;
-            }
-        }
-        while (available.length < count) {
-            const record = await generator(this.nextPreKeyId++);
-            (0, collections_1.setBoundedMapEntry)(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
-                this.uploadedPreKeys.delete(keyId);
-            });
-            available.push(record);
-        }
-        return available;
-    }
-    async getPreKeyById(keyId) {
-        return this.preKeys.get(keyId) ?? null;
-    }
-    async getPreKeysById(keyIds) {
-        const result = new Array(keyIds.length);
-        for (let i = 0; i < keyIds.length; i += 1) {
-            result[i] = this.preKeys.get(keyIds[i]) ?? null;
-        }
-        return result;
-    }
-    async consumePreKeyById(keyId) {
-        const record = this.preKeys.get(keyId) ?? null;
-        if (!record) {
-            return null;
-        }
-        this.preKeys.delete(keyId);
-        this.uploadedPreKeys.delete(keyId);
-        return record;
-    }
-    async getOrGenSinglePreKey(generator) {
-        const preKeys = await this.getOrGenPreKeys(1, generator);
-        return preKeys[0];
-    }
-    async markKeyAsUploaded(keyId) {
-        if (keyId < 0 || keyId >= this.nextPreKeyId) {
-            throw new Error(`prekey ${keyId} is out of boundary`);
-        }
-        for (const candidate of this.preKeys.keys()) {
-            if (candidate <= keyId) {
-                this.addUploadedPreKey(candidate);
-            }
-        }
-    }
-    async setServerHasPreKeys(value) {
-        this.serverHasPreKeys = value;
-    }
-    async getServerHasPreKeys() {
-        return this.serverHasPreKeys;
-    }
-    async getSignalMeta() {
-        return {
-            serverHasPreKeys: this.serverHasPreKeys,
-            signedPreKeyRotationTs: this.signedPreKeyRotationTs,
-            registrationInfo: this.registrationInfo,
-            signedPreKey: this.signedPreKey
-        };
-    }
-    async hasSession(address) {
-        return this.signalSessions.has((0, jid_1.signalAddressKey)(address));
-    }
-    async hasSessions(addresses) {
-        const result = new Array(addresses.length);
-        for (let i = 0; i < addresses.length; i += 1) {
-            result[i] = this.signalSessions.has((0, jid_1.signalAddressKey)(addresses[i]));
-        }
-        return result;
-    }
-    async getSession(address) {
-        return this.signalSessions.get((0, jid_1.signalAddressKey)(address)) ?? null;
-    }
-    async getSessionsBatch(addresses) {
-        const result = new Array(addresses.length);
-        for (let i = 0; i < addresses.length; i += 1) {
-            result[i] = this.signalSessions.get((0, jid_1.signalAddressKey)(addresses[i])) ?? null;
-        }
-        return result;
-    }
-    async setSession(address, session) {
-        (0, collections_1.setBoundedMapEntry)(this.signalSessions, (0, jid_1.signalAddressKey)(address), session, this.maxSessions);
-    }
-    async setSessionsBatch(entries) {
-        for (let index = 0; index < entries.length; index += 1) {
-            const entry = entries[index];
-            (0, collections_1.setBoundedMapEntry)(this.signalSessions, (0, jid_1.signalAddressKey)(entry.address), entry.session, this.maxSessions);
-        }
-    }
-    async deleteSession(address) {
-        this.signalSessions.delete((0, jid_1.signalAddressKey)(address));
-    }
-    async getRemoteIdentity(address) {
-        return this.remoteIdentities.get((0, jid_1.signalAddressKey)(address)) ?? null;
-    }
-    async getRemoteIdentities(addresses) {
-        const result = new Array(addresses.length);
-        for (let i = 0; i < addresses.length; i += 1) {
-            result[i] = this.remoteIdentities.get((0, jid_1.signalAddressKey)(addresses[i])) ?? null;
-        }
-        return result;
-    }
-    async setRemoteIdentity(address, identityKey) {
-        (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, (0, jid_1.signalAddressKey)(address), identityKey, this.maxRemoteIdentities);
-    }
-    async setRemoteIdentities(entries) {
-        for (const entry of entries) {
-            (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, (0, jid_1.signalAddressKey)(entry.address), entry.identityKey, this.maxRemoteIdentities);
-        }
-    }
     async clear() {
         this.registrationInfo = null;
         this.signedPreKey = null;
         this.signedPreKeyRotationTs = null;
-        this.preKeys.clear();
-        this.uploadedPreKeys.clear();
-        this.serverHasPreKeys = false;
-        this.signalSessions.clear();
-        this.remoteIdentities.clear();
-        this.nextPreKeyId = 1;
-    }
-    addUploadedPreKey(keyId) {
-        this.uploadedPreKeys.add(keyId);
     }
 }
 exports.WaSignalMemoryStore = WaSignalMemoryStore;

package/dist/transport/WaComms.js

@@ -7,7 +7,6 @@ const constants_1 = require("../protocol/constants");
 const WaNoiseSession_1 = require("./noise/WaNoiseSession");
 const WaWebSocket_1 = require("./WaWebSocket");
 const bytes_1 = require("../util/bytes");
-const bytes_2 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 const WA_FRAME_HANDLER_QUEUE_MAX_SIZE = 4096;
 const WA_FRAME_HANDLER_MAX_CONCURRENCY = 8;
@@ -32,7 +31,9 @@ class WaComms {
             protocols: this.config.protocols,
             dispatcher: this.config.dispatcher,
             agent: this.config.agent,
-            timeoutIntervalMs: this.config.timeoutIntervalMs
+            headers: this.config.headers,
+            timeoutIntervalMs: this.config.timeoutIntervalMs,
+            rawWebSocketConstructor: this.config.rawWebSocketConstructor
         }, logger);
         this.socket.setHandlers({
             onOpen: async () => {
@@ -340,7 +341,7 @@ class WaComms {
             this.noiseSession = null;
             throw error;
         }
-        const buffered = await session.pushWireChunk(bytes_2.EMPTY_BYTES);
+        const buffered = await session.pushWireChunk(bytes_1.EMPTY_BYTES);
         this.routeDecodedFrames(buffered);
         this.resumeHandshakeFailures = 0;
         this.lastServerStaticKey = session.getServerStaticKey();

package/dist/transport/WaWebSocket.js

@@ -111,7 +111,8 @@ class WaWebSocket {
         });
         this.socketUrls = resolveSocketUrls(config);
         this.logger = logger;
-        this.webSocketCtor = resolveWebSocketConstructor();
+        this.webSocketCtor = config.rawWebSocketConstructor ?? resolveWebSocketConstructor();
+        this.customWebSocketCtor = Boolean(config.rawWebSocketConstructor);
         this.socketRuntime = resolveSocketRuntime();
         this.connectingSockets = new Set();
         this.handlers = {};
@@ -447,6 +448,13 @@ class WaWebSocket {
         const headers = this.config.headers;
         const dispatcher = this.config.dispatcher;
         const agent = this.config.agent;
+        if (this.customWebSocketCtor) {
+            return new this.webSocketCtor(url, this.config.protocols, {
+                headers,
+                dispatcher,
+                agent
+            });
+        }
         let hasHeaders = false;
         if (headers) {
             for (const key in headers) {

package/dist/transport/index.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.queryWithContext = exports.parseIqError = exports.buildIqNode = exports.assertIqResult = exports.WaNodeTransport = exports.WaNodeOrchestrator = exports.WaKeepAlive = exports.WaWebSocket = exports.WaComms = exports.toProxyDispatcher = exports.toProxyAgent = exports.isProxyTransport = exports.isProxyDispatcher = exports.isProxyAgent = void 0;
+exports.queryWithContext = exports.parseIqError = exports.buildIqNode = exports.assertIqResult = exports.buildMobileLoginPayload = exports.WaMobileTcpSocketCtor = exports.WaMobileTcpSocket = exports.WaNodeTransport = exports.WaNodeOrchestrator = exports.WaKeepAlive = exports.WaWebSocket = exports.WaNoiseSocket = exports.WaNoiseHandshake = exports.verifyNoiseCertificateChain = exports.WaComms = exports.toProxyDispatcher = exports.toProxyAgent = exports.isProxyTransport = exports.isProxyDispatcher = exports.isProxyAgent = exports.encodeBinaryNodeStanza = exports.encodeBinaryNode = exports.decodeBinaryNodeStanza = exports.decodeBinaryNode = void 0;
+var binary_1 = require("./binary");
+Object.defineProperty(exports, "decodeBinaryNode", { enumerable: true, get: function () { return binary_1.decodeBinaryNode; } });
+Object.defineProperty(exports, "decodeBinaryNodeStanza", { enumerable: true, get: function () { return binary_1.decodeBinaryNodeStanza; } });
+Object.defineProperty(exports, "encodeBinaryNode", { enumerable: true, get: function () { return binary_1.encodeBinaryNode; } });
+Object.defineProperty(exports, "encodeBinaryNodeStanza", { enumerable: true, get: function () { return binary_1.encodeBinaryNodeStanza; } });
 var proxy_1 = require("./proxy");
 Object.defineProperty(exports, "isProxyAgent", { enumerable: true, get: function () { return proxy_1.isProxyAgent; } });
 Object.defineProperty(exports, "isProxyDispatcher", { enumerable: true, get: function () { return proxy_1.isProxyDispatcher; } });
@@ -9,6 +14,12 @@ Object.defineProperty(exports, "toProxyAgent", { enumerable: true, get: function
 Object.defineProperty(exports, "toProxyDispatcher", { enumerable: true, get: function () { return proxy_1.toProxyDispatcher; } });
 var WaComms_1 = require("./WaComms");
 Object.defineProperty(exports, "WaComms", { enumerable: true, get: function () { return WaComms_1.WaComms; } });
+var WaNoiseCert_1 = require("./noise/WaNoiseCert");
+Object.defineProperty(exports, "verifyNoiseCertificateChain", { enumerable: true, get: function () { return WaNoiseCert_1.verifyNoiseCertificateChain; } });
+var WaNoiseHandshake_1 = require("./noise/WaNoiseHandshake");
+Object.defineProperty(exports, "WaNoiseHandshake", { enumerable: true, get: function () { return WaNoiseHandshake_1.WaNoiseHandshake; } });
+var WaNoiseSocket_1 = require("./noise/WaNoiseSocket");
+Object.defineProperty(exports, "WaNoiseSocket", { enumerable: true, get: function () { return WaNoiseSocket_1.WaNoiseSocket; } });
 var WaWebSocket_1 = require("./WaWebSocket");
 Object.defineProperty(exports, "WaWebSocket", { enumerable: true, get: function () { return WaWebSocket_1.WaWebSocket; } });
 var WaKeepAlive_1 = require("./keepalive/WaKeepAlive");
@@ -17,6 +28,11 @@ var WaNodeOrchestrator_1 = require("./node/WaNodeOrchestrator");
 Object.defineProperty(exports, "WaNodeOrchestrator", { enumerable: true, get: function () { return WaNodeOrchestrator_1.WaNodeOrchestrator; } });
 var WaNodeTransport_1 = require("./node/WaNodeTransport");
 Object.defineProperty(exports, "WaNodeTransport", { enumerable: true, get: function () { return WaNodeTransport_1.WaNodeTransport; } });
+var WaMobileTcpSocket_1 = require("./node/WaMobileTcpSocket");
+Object.defineProperty(exports, "WaMobileTcpSocket", { enumerable: true, get: function () { return WaMobileTcpSocket_1.WaMobileTcpSocket; } });
+Object.defineProperty(exports, "WaMobileTcpSocketCtor", { enumerable: true, get: function () { return WaMobileTcpSocket_1.WaMobileTcpSocketCtor; } });
+var WaMobileClientPayload_1 = require("./noise/WaMobileClientPayload");
+Object.defineProperty(exports, "buildMobileLoginPayload", { enumerable: true, get: function () { return WaMobileClientPayload_1.buildMobileLoginPayload; } });
 var query_1 = require("./node/query");
 Object.defineProperty(exports, "assertIqResult", { enumerable: true, get: function () { return query_1.assertIqResult; } });
 Object.defineProperty(exports, "buildIqNode", { enumerable: true, get: function () { return query_1.buildIqNode; } });

package/dist/transport/keepalive/WaKeepAlive.js

@@ -11,7 +11,8 @@ class WaKeepAlive {
         this.logger = options.logger;
         this.nodeOrchestrator = options.nodeOrchestrator;
         this.getCommsFn = options.getComms;
-        this.intervalMs = options.intervalMs ?? constants_1.WA_DEFAULTS.HEALTH_CHECK_INTERVAL_MS;
+        this.baseIntervalMs = options.intervalMs ?? constants_1.WA_DEFAULTS.HEALTH_CHECK_INTERVAL_MS;
+        this.getIntervalMs = options.getIntervalMs;
         this.timeoutMs = options.timeoutMs ?? constants_1.WA_DEFAULTS.DEAD_SOCKET_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? constants_1.WA_DEFAULTS.HOST_DOMAIN;
         this.jitterRatio = this.normalizeJitterRatio(options.jitterRatio);
@@ -22,7 +23,7 @@ class WaKeepAlive {
     }
     start() {
         this.logger.info('keepalive start', {
-            intervalMs: this.intervalMs,
+            intervalMs: this.resolveIntervalMs(),
             timeoutMs: this.timeoutMs,
             jitterRatio: this.jitterRatio,
             minJitterMs: this.minJitterMs
@@ -51,7 +52,7 @@ class WaKeepAlive {
         this.logger.trace('keepalive scheduled', {
             generation,
             inMs: nextDelayMs,
-            baseIntervalMs: this.intervalMs
+            baseIntervalMs: this.resolveIntervalMs()
         });
     }
     async run(generation) {
@@ -113,20 +114,28 @@ class WaKeepAlive {
         const normalized = value;
         return Math.min(Math.max(normalized, 0), KEEPALIVE_MAX_JITTER_RATIO);
     }
+    resolveIntervalMs() {
+        const candidate = this.getIntervalMs?.() ?? this.baseIntervalMs;
+        if (!Number.isFinite(candidate) || candidate <= 0) {
+            return this.baseIntervalMs;
+        }
+        return candidate;
+    }
     computeNextDelayMs() {
-        if (this.intervalMs <= 0) {
+        const intervalMs = this.resolveIntervalMs();
+        if (intervalMs <= 0) {
             return 0;
         }
         if (this.jitterRatio <= 0 && this.minJitterMs <= 0) {
-            return this.intervalMs;
+            return intervalMs;
         }
-        const ratioJitterMs = Math.floor(this.intervalMs * this.jitterRatio);
+        const ratioJitterMs = Math.floor(intervalMs * this.jitterRatio);
         const jitterWindowMs = Math.max(this.minJitterMs, ratioJitterMs);
         if (jitterWindowMs <= 0) {
-            return this.intervalMs;
+            return intervalMs;
         }
         const offsetMs = Math.floor(Math.random() * (jitterWindowMs * 2 + 1) - jitterWindowMs);
-        return Math.max(1, this.intervalMs + offsetMs);
+        return Math.max(1, intervalMs + offsetMs);
     }
     clearTimer() {
         if (!this.timer) {