zapo-js 0.1.0

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaParticipantsMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULTS = Object.freeze({
+    ttlMs: 5 * 60 * 1000,
+    maxGroups: 4096
+});
+class WaParticipantsMemoryStore {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        this.records = new Map();
+        this.ttlMs = ttlMs;
+        this.maxGroups = (0, coercion_1.resolvePositive)(options.maxGroups, DEFAULTS.maxGroups, 'WaParticipantsMemoryStoreOptions.maxGroups');
+        this.cleanupTimer = setInterval(() => {
+            void this.cleanupExpired(Date.now());
+        }, (0, collections_1.resolveCleanupIntervalMs)(ttlMs));
+        this.cleanupTimer.unref();
+    }
+    getTtlMs() {
+        return this.ttlMs;
+    }
+    async upsertGroupParticipants(snapshot) {
+        (0, collections_1.setBoundedMapEntry)(this.records, snapshot.groupJid, {
+            ...snapshot,
+            expiresAtMs: snapshot.updatedAtMs + this.ttlMs
+        }, this.maxGroups);
+    }
+    async getGroupParticipants(groupJid, nowMs = Date.now()) {
+        const record = this.records.get(groupJid);
+        if (!record) {
+            return null;
+        }
+        if (record.expiresAtMs <= nowMs) {
+            this.records.delete(groupJid);
+            return null;
+        }
+        return {
+            groupJid: record.groupJid,
+            participants: record.participants,
+            updatedAtMs: record.updatedAtMs
+        };
+    }
+    async deleteGroupParticipants(groupJid) {
+        return this.records.delete(groupJid) ? 1 : 0;
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [groupJid, record] of this.records) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            this.records.delete(groupJid);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.records.clear();
+    }
+    async destroy() {
+        clearInterval(this.cleanupTimer);
+        await this.clear();
+    }
+}
+exports.WaParticipantsMemoryStore = WaParticipantsMemoryStore;

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaRetryMemoryStore = void 0;
+const collections_1 = require("../../../util/collections");
+const DEFAULT_RETRY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+class WaRetryMemoryStore {
+    constructor(ttlMs = DEFAULT_RETRY_TTL_MS) {
+        this.outboundMessages = new Map();
+        this.inboundCounters = new Map();
+        this.ttlMs = ttlMs;
+        this.cleanupTimer = setInterval(() => {
+            void this.cleanupExpired(Date.now());
+        }, (0, collections_1.resolveCleanupIntervalMs)(ttlMs));
+        this.cleanupTimer.unref();
+    }
+    getTtlMs() {
+        return this.ttlMs;
+    }
+    async upsertOutboundMessage(record) {
+        this.outboundMessages.set(record.messageId, record);
+    }
+    async getOutboundMessage(messageId) {
+        return this.outboundMessages.get(messageId) ?? null;
+    }
+    async updateOutboundMessageState(messageId, state, updatedAtMs, expiresAtMs) {
+        const current = this.outboundMessages.get(messageId);
+        if (!current) {
+            return;
+        }
+        this.outboundMessages.set(messageId, {
+            ...current,
+            state,
+            updatedAtMs,
+            expiresAtMs
+        });
+    }
+    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
+        });
+        return count;
+    }
+    async cleanupExpired(nowMs) {
+        let removed = 0;
+        for (const [messageId, record] of this.outboundMessages) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            this.outboundMessages.delete(messageId);
+            removed += 1;
+        }
+        for (const [key, record] of this.inboundCounters) {
+            if (record.expiresAtMs > nowMs)
+                continue;
+            this.inboundCounters.delete(key);
+            removed += 1;
+        }
+        return removed;
+    }
+    async clear() {
+        this.outboundMessages.clear();
+        this.inboundCounters.clear();
+    }
+    async destroy() {
+        clearInterval(this.cleanupTimer);
+        await this.clear();
+    }
+    counterKey(messageId, requesterJid) {
+        return `${messageId}|${requesterJid}`;
+    }
+}
+exports.WaRetryMemoryStore = WaRetryMemoryStore;

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const signal_address_1 = require("../../../util/signal-address");
+const DEFAULT_SENDER_KEY_STORE_LIMITS = Object.freeze({
+    senderKeys: 8192,
+    senderDistributions: 8192
+});
+class SenderKeyMemoryStore {
+    constructor(options = {}) {
+        this.senderKeys = new Map();
+        this.senderDistributions = new Map();
+        this.maxSenderKeys = (0, coercion_1.resolvePositive)(options.maxSenderKeys, DEFAULT_SENDER_KEY_STORE_LIMITS.senderKeys, 'WaSenderKeyMemoryStoreOptions.maxSenderKeys');
+        this.maxSenderDistributions = (0, coercion_1.resolvePositive)(options.maxSenderDistributions, DEFAULT_SENDER_KEY_STORE_LIMITS.senderDistributions, 'WaSenderKeyMemoryStoreOptions.maxSenderDistributions');
+    }
+    async upsertSenderKey(record) {
+        (0, collections_1.setBoundedMapEntry)(this.senderKeys, this.makeKey(record.groupId, record.sender), record, this.maxSenderKeys);
+    }
+    async upsertSenderKeyDistribution(record) {
+        (0, collections_1.setBoundedMapEntry)(this.senderDistributions, this.makeKey(record.groupId, record.sender), record, this.maxSenderDistributions);
+    }
+    async upsertSenderKeyDistributions(records) {
+        for (const record of records) {
+            (0, collections_1.setBoundedMapEntry)(this.senderDistributions, this.makeKey(record.groupId, record.sender), record, this.maxSenderDistributions);
+        }
+    }
+    async getGroupSenderKeyList(groupId) {
+        const skList = [];
+        const skDistribList = [];
+        for (const record of this.senderKeys.values()) {
+            if (record.groupId === groupId) {
+                skList.push(record);
+            }
+        }
+        for (const record of this.senderDistributions.values()) {
+            if (record.groupId === groupId) {
+                skDistribList.push(record);
+            }
+        }
+        return {
+            skList,
+            skDistribList
+        };
+    }
+    async getDeviceSenderKey(groupId, sender) {
+        const record = this.senderKeys.get(this.makeKey(groupId, sender));
+        return record ?? null;
+    }
+    async getDeviceSenderKeyDistribution(groupId, sender) {
+        const record = this.senderDistributions.get(this.makeKey(groupId, sender));
+        return record ?? null;
+    }
+    async getDeviceSenderKeyDistributions(groupId, senders) {
+        return senders.map((sender) => this.senderDistributions.get(this.makeKey(groupId, sender)) ?? null);
+    }
+    async deleteDeviceSenderKey(target, groupId) {
+        let deleted = 0;
+        deleted += this.deleteMatching(this.senderKeys, target, groupId);
+        deleted += this.deleteMatching(this.senderDistributions, target, groupId);
+        return deleted;
+    }
+    async markForgetSenderKey(groupId, participants) {
+        let deleted = 0;
+        for (const participant of participants) {
+            deleted += await this.deleteDeviceSenderKey(participant, groupId);
+        }
+        return deleted;
+    }
+    async clear() {
+        this.senderKeys.clear();
+        this.senderDistributions.clear();
+    }
+    deleteMatching(map, target, groupId) {
+        let deleted = 0;
+        const targetAddressKey = (0, signal_address_1.signalAddressKey)(target);
+        for (const [key, record] of map.entries()) {
+            const sameGroup = groupId ? record.groupId === groupId : true;
+            const sameAddress = (0, signal_address_1.signalAddressKey)(record.sender) === targetAddressKey;
+            if (sameGroup && sameAddress) {
+                map.delete(key);
+                deleted += 1;
+            }
+        }
+        return deleted;
+    }
+    makeKey(groupId, sender) {
+        return `${groupId}|${(0, signal_address_1.signalAddressKey)(sender)}`;
+    }
+}
+exports.SenderKeyMemoryStore = SenderKeyMemoryStore;

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

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaSignalMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const signal_address_1 = require("../../../util/signal-address");
+const DEFAULT_SIGNAL_STORE_LIMITS = Object.freeze({
+    preKeys: 4096,
+    sessions: 8192,
+    remoteIdentities: 8192
+});
+class WaSignalMemoryStore {
+    constructor(options = {}) {
+        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;
+    }
+    async setRegistrationInfo(info) {
+        this.registrationInfo = info;
+    }
+    async getSignedPreKey() {
+        return this.signedPreKey;
+    }
+    async setSignedPreKey(record) {
+        this.signedPreKey = record;
+    }
+    async getSignedPreKeyById(keyId) {
+        if (!this.signedPreKey) {
+            return null;
+        }
+        return this.signedPreKey.keyId === keyId ? this.signedPreKey : null;
+    }
+    async setSignedPreKeyRotationTs(value) {
+        this.signedPreKeyRotationTs = value;
+    }
+    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 sortedIds = [...this.preKeys.keys()].sort((left, right) => left - right);
+        for (let index = 0; index < sortedIds.length; index += 1) {
+            const keyId = sortedIds[index];
+            if (this.uploadedPreKeys.has(keyId)) {
+                continue;
+            }
+            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) {
+        return keyIds.map((keyId) => this.preKeys.get(keyId) ?? null);
+    }
+    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 hasSession(address) {
+        return this.signalSessions.has((0, signal_address_1.signalAddressKey)(address));
+    }
+    async hasSessions(addresses) {
+        return addresses.map((address) => this.signalSessions.has((0, signal_address_1.signalAddressKey)(address)));
+    }
+    async getSession(address) {
+        return this.signalSessions.get((0, signal_address_1.signalAddressKey)(address)) ?? null;
+    }
+    async setSession(address, session) {
+        (0, collections_1.setBoundedMapEntry)(this.signalSessions, (0, signal_address_1.signalAddressKey)(address), session, this.maxSessions);
+    }
+    async deleteSession(address) {
+        this.signalSessions.delete((0, signal_address_1.signalAddressKey)(address));
+    }
+    async getRemoteIdentity(address) {
+        return this.remoteIdentities.get((0, signal_address_1.signalAddressKey)(address)) ?? null;
+    }
+    async setRemoteIdentity(address, identityKey) {
+        (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, (0, signal_address_1.signalAddressKey)(address), identityKey, this.maxRemoteIdentities);
+    }
+    async setRemoteIdentities(entries) {
+        for (const entry of entries) {
+            (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, (0, signal_address_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) {
+        if (this.uploadedPreKeys.has(keyId)) {
+            this.uploadedPreKeys.delete(keyId);
+        }
+        this.uploadedPreKeys.add(keyId);
+        while (this.uploadedPreKeys.size > this.maxPreKeys) {
+            const oldest = this.uploadedPreKeys.values().next().value;
+            if (oldest === undefined) {
+                break;
+            }
+            this.uploadedPreKeys.delete(oldest);
+        }
+    }
+}
+exports.WaSignalMemoryStore = WaSignalMemoryStore;

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaThreadMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULT_THREAD_MEMORY_STORE_LIMITS = Object.freeze({
+    threads: 10000
+});
+class WaThreadMemoryStore {
+    constructor(options = {}) {
+        this.threads = new Map();
+        this.maxThreads = (0, coercion_1.resolvePositive)(options.maxThreads, DEFAULT_THREAD_MEMORY_STORE_LIMITS.threads, 'WaThreadMemoryStoreOptions.maxThreads');
+    }
+    async upsert(record) {
+        (0, collections_1.setBoundedMapEntry)(this.threads, record.jid, record, this.maxThreads);
+    }
+    async getByJid(jid) {
+        return this.threads.get(jid) ?? null;
+    }
+    async list(limit) {
+        const normalizedLimit = (0, collections_1.normalizeQueryLimit)(limit, 100);
+        const out = [];
+        for (const thread of this.threads.values()) {
+            out.push(thread);
+            if (out.length >= normalizedLimit) {
+                break;
+            }
+        }
+        return out;
+    }
+    async deleteByJid(jid) {
+        return this.threads.delete(jid) ? 1 : 0;
+    }
+    async clear() {
+        this.threads.clear();
+    }
+}
+exports.WaThreadMemoryStore = WaThreadMemoryStore;

package/dist/store/providers/sqlite/BaseSqliteStore.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSqliteStore = void 0;
+const connection_1 = require("../../providers/sqlite/connection");
+const migrations_1 = require("../../providers/sqlite/migrations");
+class BaseSqliteStore {
+    constructor(options, migrationDomains) {
+        this.options = options;
+        this.migrationDomains = migrationDomains;
+        this.connectionPromise = null;
+    }
+    async getConnection() {
+        if (!this.connectionPromise) {
+            this.connectionPromise = (0, connection_1.openSqliteConnection)(this.options).then((connection) => (0, migrations_1.ensureSqliteMigrations)(connection, this.migrationDomains).then(() => connection));
+        }
+        return this.connectionPromise;
+    }
+    async withTransaction(run) {
+        const db = await this.getConnection();
+        db.exec('BEGIN');
+        try {
+            const result = await run(db);
+            db.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async destroy() {
+        const connectionPromise = this.connectionPromise;
+        this.connectionPromise = null;
+        if (!connectionPromise) {
+            return;
+        }
+        const connection = await connectionPromise;
+        connection.close();
+    }
+}
+exports.BaseSqliteStore = BaseSqliteStore;

package/dist/store/providers/sqlite/appstate.store.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaAppStateSqliteStore = void 0;
+const constants_1 = require("../../../appstate/constants");
+const sqlite_1 = require("../../../appstate/store/sqlite");
+const utils_1 = require("../../../appstate/utils");
+const BaseSqliteStore_1 = require("../../providers/sqlite/BaseSqliteStore");
+const bytes_1 = require("../../../util/bytes");
+const coercion_1 = require("../../../util/coercion");
+class WaAppStateSqliteStore extends BaseSqliteStore_1.BaseSqliteStore {
+    constructor(options) {
+        super(options, ['appState']);
+    }
+    async exportData() {
+        const db = await this.getConnection();
+        const keyRows = db.all(`SELECT key_id, key_data, timestamp, fingerprint
+             FROM appstate_sync_keys
+             WHERE session_id = ?`, [this.options.sessionId]);
+        const versionRows = db.all(`SELECT collection, version, hash
+             FROM appstate_collection_versions
+             WHERE session_id = ?`, [this.options.sessionId]);
+        const valueRows = db.all(`SELECT collection, index_mac_hex, value_mac
+             FROM appstate_collection_index_values
+             WHERE session_id = ?`, [this.options.sessionId]);
+        return {
+            keys: (0, sqlite_1.decodeAppStateSyncKeys)(keyRows),
+            collections: (0, sqlite_1.decodeAppStateCollections)(versionRows, valueRows)
+        };
+    }
+    async upsertSyncKeys(keys) {
+        let inserted = 0;
+        await this.withTransaction((db) => {
+            for (const key of keys) {
+                const existing = db.get(`SELECT key_data
+                     FROM appstate_sync_keys
+                     WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, key.keyId]);
+                if (existing &&
+                    (0, bytes_1.uint8Equal)((0, coercion_1.asBytes)(existing.key_data, 'appstate_sync_keys.key_data'), key.keyData)) {
+                    continue;
+                }
+                db.run(`INSERT INTO appstate_sync_keys (
+                        session_id,
+                        key_id,
+                        key_data,
+                        timestamp,
+                        fingerprint,
+                        key_epoch
+                    ) VALUES (?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(session_id, key_id) DO UPDATE SET
+                        key_data=excluded.key_data,
+                        timestamp=excluded.timestamp,
+                        fingerprint=excluded.fingerprint,
+                        key_epoch=excluded.key_epoch`, [
+                    this.options.sessionId,
+                    key.keyId,
+                    key.keyData,
+                    key.timestamp,
+                    (0, sqlite_1.encodeAppStateFingerprint)(key.fingerprint),
+                    (0, utils_1.keyEpoch)(key.keyId)
+                ]);
+                inserted += 1;
+            }
+        });
+        return inserted;
+    }
+    async getSyncKey(keyId) {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT key_id, key_data, timestamp, fingerprint
+             FROM appstate_sync_keys
+             WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
+        if (!row) {
+            return null;
+        }
+        return {
+            keyId: (0, coercion_1.asBytes)(row.key_id, 'appstate_sync_keys.key_id'),
+            keyData: (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data'),
+            timestamp: (0, coercion_1.asNumber)(row.timestamp, 'appstate_sync_keys.timestamp'),
+            fingerprint: (0, sqlite_1.decodeAppStateFingerprint)(row.fingerprint)
+        };
+    }
+    async getSyncKeyData(keyId) {
+        const db = await this.getConnection();
+        const row = db.get(`SELECT key_data
+             FROM appstate_sync_keys
+             WHERE session_id = ? AND key_id = ?`, [this.options.sessionId, keyId]);
+        if (!row) {
+            return null;
+        }
+        return (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data');
+    }
+    async getActiveSyncKey() {
+        const db = await this.getConnection();
+        const rows = db.all(`SELECT key_id, key_data, timestamp, fingerprint
+             FROM appstate_sync_keys
+             WHERE session_id = ?`, [this.options.sessionId]);
+        const keys = [];
+        for (const row of rows) {
+            const key = {
+                keyId: (0, coercion_1.asBytes)(row.key_id, 'appstate_sync_keys.key_id'),
+                keyData: (0, coercion_1.asBytes)(row.key_data, 'appstate_sync_keys.key_data'),
+                timestamp: (0, coercion_1.asNumber)(row.timestamp, 'appstate_sync_keys.timestamp'),
+                fingerprint: (0, sqlite_1.decodeAppStateFingerprint)(row.fingerprint)
+            };
+            keys.push(key);
+        }
+        return (0, utils_1.pickActiveSyncKey)(keys);
+    }
+    async getCollectionState(collection) {
+        const db = await this.getConnection();
+        const versionRow = db.get(`SELECT version, hash
+             FROM appstate_collection_versions
+             WHERE session_id = ? AND collection = ?`, [this.options.sessionId, collection]);
+        if (!versionRow) {
+            return {
+                version: 0,
+                hash: constants_1.APP_STATE_EMPTY_LT_HASH,
+                indexValueMap: new Map()
+            };
+        }
+        const valueRows = db.all(`SELECT index_mac_hex, value_mac
+             FROM appstate_collection_index_values
+             WHERE session_id = ? AND collection = ?`, [this.options.sessionId, collection]);
+        const indexValueMap = new Map();
+        for (const row of valueRows) {
+            indexValueMap.set((0, coercion_1.asString)(row.index_mac_hex, 'appstate_collection_index_values.index_mac_hex'), (0, coercion_1.asBytes)(row.value_mac, 'appstate_collection_index_values.value_mac'));
+        }
+        return {
+            version: (0, coercion_1.asNumber)(versionRow.version, 'appstate_collection_versions.version'),
+            hash: (0, coercion_1.asBytes)(versionRow.hash, 'appstate_collection_versions.hash'),
+            indexValueMap
+        };
+    }
+    async setCollectionStates(updates) {
+        if (updates.length === 0) {
+            return;
+        }
+        await this.withTransaction((db) => {
+            for (const update of updates) {
+                db.run(`INSERT INTO appstate_collection_versions (
+                        session_id,
+                        collection,
+                        version,
+                        hash
+                    ) VALUES (?, ?, ?, ?)
+                    ON CONFLICT(session_id, collection) DO UPDATE SET
+                        version=excluded.version,
+                        hash=excluded.hash`, [this.options.sessionId, update.collection, update.version, update.hash]);
+                db.run(`DELETE FROM appstate_collection_index_values
+                     WHERE session_id = ? AND collection = ?`, [this.options.sessionId, update.collection]);
+                for (const [indexMacHex, valueMac] of update.indexValueMap.entries()) {
+                    db.run(`INSERT INTO appstate_collection_index_values (
+                            session_id,
+                            collection,
+                            index_mac_hex,
+                            value_mac
+                        ) VALUES (?, ?, ?, ?)`, [this.options.sessionId, update.collection, indexMacHex, valueMac]);
+                }
+            }
+        });
+    }
+    async clear() {
+        await this.withTransaction((db) => {
+            db.run('DELETE FROM appstate_sync_keys WHERE session_id = ?', [this.options.sessionId]);
+            db.run('DELETE FROM appstate_collection_versions WHERE session_id = ?', [
+                this.options.sessionId
+            ]);
+            db.run('DELETE FROM appstate_collection_index_values WHERE session_id = ?', [
+                this.options.sessionId
+            ]);
+        });
+    }
+}
+exports.WaAppStateSqliteStore = WaAppStateSqliteStore;