zapo-js 0.1.1 → 0.2.0

package/dist/crypto/core/constants.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SERIALIZED_PUB_KEY_PREFIX = void 0;
-exports.SERIALIZED_PUB_KEY_PREFIX = 5;

package/dist/crypto/core/encoding.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeBase64Url = decodeBase64Url;
-exports.assert32 = assert32;
-const bytes_1 = require("../../util/bytes");
-/**
- * Base64 URL encoding utilities
- */
-/**
- * Decodes a base64url encoded string to Uint8Array
- */
-function decodeBase64Url(value, field) {
-    if (!value) {
-        throw new Error(`missing ${field}`);
-    }
-    const padded = value
-        .replace(/-/g, '+')
-        .replace(/_/g, '/')
-        .padEnd(Math.ceil(value.length / 4) * 4, '=');
-    return (0, bytes_1.base64ToBytes)(padded);
-}
-/**
- * Asserts that a Uint8Array is exactly 32 bytes
- */
-function assert32(value, name) {
-    if (value.length !== 32) {
-        throw new Error(`${name} must be 32 bytes`);
-    }
-}

package/dist/esm/crypto/core/constants.js

@@ -1 +0,0 @@
-export const SERIALIZED_PUB_KEY_PREFIX = 5;

package/dist/esm/crypto/core/encoding.js

@@ -1,25 +0,0 @@
-import { base64ToBytes } from '../../util/bytes.js';
-/**
- * Base64 URL encoding utilities
- */
-/**
- * Decodes a base64url encoded string to Uint8Array
- */
-export function decodeBase64Url(value, field) {
-    if (!value) {
-        throw new Error(`missing ${field}`);
-    }
-    const padded = value
-        .replace(/-/g, '+')
-        .replace(/_/g, '/')
-        .padEnd(Math.ceil(value.length / 4) * 4, '=');
-    return base64ToBytes(padded);
-}
-/**
- * Asserts that a Uint8Array is exactly 32 bytes
- */
-export function assert32(value, name) {
-    if (value.length !== 32) {
-        throw new Error(`${name} must be 32 bytes`);
-    }
-}

package/dist/esm/retry/outbound.js

@@ -1,83 +0,0 @@
-import { base64ToBytes, bytesToBase64 } from '../util/base64.js';
-import { TEXT_DECODER, TEXT_ENCODER } from '../util/bytes.js';
-function requireObject(value) {
-    if (!value || typeof value !== 'object') {
-        throw new Error('invalid retry replay payload');
-    }
-    return value;
-}
-function requireString(value, field) {
-    if (typeof value !== 'string') {
-        throw new Error(`invalid retry replay payload field: ${field}`);
-    }
-    return value;
-}
-export function encodeRetryReplayPayload(payload) {
-    const serialized = payload.mode === 'plaintext'
-        ? {
-            mode: payload.mode,
-            to: payload.to,
-            type: payload.type,
-            plaintext: bytesToBase64(payload.plaintext)
-        }
-        : payload.mode === 'encrypted'
-            ? {
-                mode: payload.mode,
-                to: payload.to,
-                type: payload.type,
-                encType: payload.encType,
-                ciphertext: bytesToBase64(payload.ciphertext),
-                participant: payload.participant
-            }
-            : {
-                mode: payload.mode,
-                node: bytesToBase64(payload.node)
-            };
-    return TEXT_ENCODER.encode(JSON.stringify(serialized));
-}
-export function decodeRetryReplayPayload(raw) {
-    const json = JSON.parse(TEXT_DECODER.decode(raw));
-    const parsed = requireObject(json);
-    const mode = requireString(parsed.mode, 'mode');
-    if (mode === 'plaintext') {
-        return {
-            mode,
-            to: requireString(parsed.to, 'to'),
-            type: requireString(parsed.type, 'type'),
-            plaintext: base64ToBytes(requireString(parsed.plaintext, 'plaintext'), 'retry.plaintext')
-        };
-    }
-    if (mode === 'encrypted') {
-        const encType = requireString(parsed.encType, 'encType');
-        if (encType !== 'msg' && encType !== 'pkmsg' && encType !== 'skmsg') {
-            throw new Error(`invalid retry encrypted encType: ${encType}`);
-        }
-        return {
-            mode,
-            to: requireString(parsed.to, 'to'),
-            type: requireString(parsed.type, 'type'),
-            encType,
-            ciphertext: base64ToBytes(requireString(parsed.ciphertext, 'ciphertext'), 'retry.ciphertext'),
-            participant: parsed.participant === undefined
-                ? undefined
-                : requireString(parsed.participant, 'participant')
-        };
-    }
-    if (mode === 'opaque_node') {
-        return {
-            mode,
-            node: base64ToBytes(requireString(parsed.node, 'node'), 'retry.node')
-        };
-    }
-    throw new Error(`invalid retry replay payload mode: ${mode}`);
-}
-const RETRY_STATE_RANK = {
-    pending: 0,
-    delivered: 1,
-    read: 2,
-    played: 3,
-    ineligible: 4
-};
-export function pickRetryStateMax(left, right) {
-    return RETRY_STATE_RANK[left] >= RETRY_STATE_RANK[right] ? left : right;
-}

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

@@ -1,37 +0,0 @@
-import { openSqliteConnection } from '../../providers/sqlite/connection.js';
-import { ensureSqliteMigrations } from '../../providers/sqlite/migrations.js';
-export class BaseSqliteStore {
-    constructor(options, migrationDomains) {
-        this.options = options;
-        this.migrationDomains = migrationDomains;
-        this.connectionPromise = null;
-    }
-    async getConnection() {
-        if (!this.connectionPromise) {
-            this.connectionPromise = openSqliteConnection(this.options).then((connection) => 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();
-    }
-}

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

@@ -1,169 +0,0 @@
-import { APP_STATE_EMPTY_LT_HASH } from '../../../appstate/constants.js';
-import { decodeAppStateCollections, decodeAppStateFingerprint, decodeAppStateSyncKeys, encodeAppStateFingerprint } from '../../../appstate/store/sqlite.js';
-import { keyEpoch, pickActiveSyncKey } from '../../../appstate/utils.js';
-import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
-import { uint8Equal } from '../../../util/bytes.js';
-import { asBytes, asNumber, asString } from '../../../util/coercion.js';
-export class WaAppStateSqliteStore extends 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: decodeAppStateSyncKeys(keyRows),
-            collections: 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 &&
-                    uint8Equal(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,
-                    encodeAppStateFingerprint(key.fingerprint),
-                    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: asBytes(row.key_id, 'appstate_sync_keys.key_id'),
-            keyData: asBytes(row.key_data, 'appstate_sync_keys.key_data'),
-            timestamp: asNumber(row.timestamp, 'appstate_sync_keys.timestamp'),
-            fingerprint: 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 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: asBytes(row.key_id, 'appstate_sync_keys.key_id'),
-                keyData: asBytes(row.key_data, 'appstate_sync_keys.key_data'),
-                timestamp: asNumber(row.timestamp, 'appstate_sync_keys.timestamp'),
-                fingerprint: decodeAppStateFingerprint(row.fingerprint)
-            };
-            keys.push(key);
-        }
-        return 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: 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(asString(row.index_mac_hex, 'appstate_collection_index_values.index_mac_hex'), asBytes(row.value_mac, 'appstate_collection_index_values.value_mac'));
-        }
-        return {
-            version: asNumber(versionRow.version, 'appstate_collection_versions.version'),
-            hash: 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
-            ]);
-        });
-    }
-}

package/dist/esm/store/providers/sqlite/auth.store.js

@@ -1,176 +0,0 @@
-import { proto } from '../../../proto.js';
-import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore.js';
-import { asBytes, asNumber, asOptionalBytes, asOptionalNumber, asOptionalString, toBoolOrUndef } from '../../../util/coercion.js';
-export class WaAuthSqliteStore extends BaseSqliteStore {
-    constructor(options) {
-        super(options, ['auth']);
-    }
-    async load() {
-        const db = await this.getConnection();
-        const row = db.get(`SELECT
-                noise_pub_key,
-                noise_priv_key,
-                registration_id,
-                identity_pub_key,
-                identity_priv_key,
-                signed_prekey_id,
-                signed_prekey_pub_key,
-                signed_prekey_priv_key,
-                signed_prekey_signature,
-                adv_secret_key,
-                signed_identity,
-                me_jid,
-                me_lid,
-                me_display_name,
-                companion_enc_static,
-                platform,
-                server_static_key,
-                server_has_prekeys,
-                routing_info,
-                last_success_ts,
-                props_version,
-                ab_props_version,
-                connection_location,
-                account_creation_ts
-            FROM auth_credentials
-            WHERE session_id = ?`, [this.options.sessionId]);
-        if (!row) {
-            return null;
-        }
-        const signedIdentityBytes = asOptionalBytes(row.signed_identity);
-        return {
-            noiseKeyPair: {
-                pubKey: asBytes(row.noise_pub_key, 'noise_pub_key'),
-                privKey: asBytes(row.noise_priv_key, 'noise_priv_key')
-            },
-            registrationInfo: {
-                registrationId: asNumber(row.registration_id, 'registration_id'),
-                identityKeyPair: {
-                    pubKey: asBytes(row.identity_pub_key, 'identity_pub_key'),
-                    privKey: asBytes(row.identity_priv_key, 'identity_priv_key')
-                }
-            },
-            signedPreKey: {
-                keyId: asNumber(row.signed_prekey_id, 'signed_prekey_id'),
-                keyPair: {
-                    pubKey: asBytes(row.signed_prekey_pub_key, 'signed_prekey_pub_key'),
-                    privKey: asBytes(row.signed_prekey_priv_key, 'signed_prekey_priv_key')
-                },
-                signature: asBytes(row.signed_prekey_signature, 'signed_prekey_signature'),
-                uploaded: false
-            },
-            advSecretKey: asBytes(row.adv_secret_key, 'adv_secret_key'),
-            signedIdentity: signedIdentityBytes
-                ? proto.ADVSignedDeviceIdentity.decode(signedIdentityBytes)
-                : undefined,
-            meJid: asOptionalString(row.me_jid),
-            meLid: asOptionalString(row.me_lid),
-            meDisplayName: asOptionalString(row.me_display_name),
-            companionEncStatic: asOptionalBytes(row.companion_enc_static),
-            platform: asOptionalString(row.platform),
-            serverStaticKey: asOptionalBytes(row.server_static_key),
-            serverHasPreKeys: toBoolOrUndef(row.server_has_prekeys),
-            routingInfo: asOptionalBytes(row.routing_info),
-            lastSuccessTs: asOptionalNumber(row.last_success_ts),
-            propsVersion: asOptionalNumber(row.props_version),
-            abPropsVersion: asOptionalNumber(row.ab_props_version),
-            connectionLocation: asOptionalString(row.connection_location),
-            accountCreationTs: asOptionalNumber(row.account_creation_ts)
-        };
-    }
-    async save(credentials) {
-        await this.withTransaction(async (db) => {
-            db.run(`INSERT INTO auth_credentials (
-                    session_id,
-                    noise_pub_key,
-                    noise_priv_key,
-                    registration_id,
-                    identity_pub_key,
-                    identity_priv_key,
-                    signed_prekey_id,
-                    signed_prekey_pub_key,
-                    signed_prekey_priv_key,
-                    signed_prekey_signature,
-                    adv_secret_key,
-                    signed_identity,
-                    me_jid,
-                    me_lid,
-                    me_display_name,
-                    companion_enc_static,
-                    platform,
-                    server_static_key,
-                    server_has_prekeys,
-                    routing_info,
-                    last_success_ts,
-                    props_version,
-                    ab_props_version,
-                    connection_location,
-                    account_creation_ts
-                ) VALUES (
-                    ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
-                )
-                ON CONFLICT(session_id) DO UPDATE SET
-                    noise_pub_key=excluded.noise_pub_key,
-                    noise_priv_key=excluded.noise_priv_key,
-                    registration_id=excluded.registration_id,
-                    identity_pub_key=excluded.identity_pub_key,
-                    identity_priv_key=excluded.identity_priv_key,
-                    signed_prekey_id=excluded.signed_prekey_id,
-                    signed_prekey_pub_key=excluded.signed_prekey_pub_key,
-                    signed_prekey_priv_key=excluded.signed_prekey_priv_key,
-                    signed_prekey_signature=excluded.signed_prekey_signature,
-                    adv_secret_key=excluded.adv_secret_key,
-                    signed_identity=excluded.signed_identity,
-                    me_jid=excluded.me_jid,
-                    me_lid=excluded.me_lid,
-                    me_display_name=excluded.me_display_name,
-                    companion_enc_static=excluded.companion_enc_static,
-                    platform=excluded.platform,
-                    server_static_key=excluded.server_static_key,
-                    server_has_prekeys=excluded.server_has_prekeys,
-                    routing_info=excluded.routing_info,
-                    last_success_ts=excluded.last_success_ts,
-                    props_version=excluded.props_version,
-                    ab_props_version=excluded.ab_props_version,
-                    connection_location=excluded.connection_location,
-                    account_creation_ts=excluded.account_creation_ts`, [
-                this.options.sessionId,
-                credentials.noiseKeyPair.pubKey,
-                credentials.noiseKeyPair.privKey,
-                credentials.registrationInfo.registrationId,
-                credentials.registrationInfo.identityKeyPair.pubKey,
-                credentials.registrationInfo.identityKeyPair.privKey,
-                credentials.signedPreKey.keyId,
-                credentials.signedPreKey.keyPair.pubKey,
-                credentials.signedPreKey.keyPair.privKey,
-                credentials.signedPreKey.signature,
-                credentials.advSecretKey,
-                credentials.signedIdentity
-                    ? proto.ADVSignedDeviceIdentity.encode(credentials.signedIdentity).finish()
-                    : null,
-                credentials.meJid ?? null,
-                credentials.meLid ?? null,
-                credentials.meDisplayName ?? null,
-                credentials.companionEncStatic ?? null,
-                credentials.platform ?? null,
-                credentials.serverStaticKey ?? null,
-                credentials.serverHasPreKeys === undefined
-                    ? null
-                    : credentials.serverHasPreKeys
-                        ? 1
-                        : 0,
-                credentials.routingInfo ?? null,
-                credentials.lastSuccessTs ?? null,
-                credentials.propsVersion ?? null,
-                credentials.abPropsVersion ?? null,
-                credentials.connectionLocation ?? null,
-                credentials.accountCreationTs ?? null
-            ]);
-        });
-    }
-    async clear() {
-        await this.withTransaction(async (db) => {
-            db.run('DELETE FROM auth_credentials WHERE session_id = ?', [this.options.sessionId]);
-        });
-    }
-}