@alannxd/baileys 6.0.5 → 6.0.6

package/lib/Signal/Group/sender-key-record.js

@@ -1,12 +1,15 @@
-import { BufferJSON } from '../../Utils/generics.js';
-import { SenderKeyState } from './sender-key-state.js';
-export class SenderKeyRecord {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyRecord = void 0;
+const generics_1 = require("../../Utils/generics");
+const sender_key_state_1 = require("./sender-key-state");
+class SenderKeyRecord {
     constructor(serialized) {
         this.MAX_STATES = 5;
         this.senderKeyStates = [];
         if (serialized) {
             for (const structure of serialized) {
-                this.senderKeyStates.push(new SenderKeyState(null, null, null, null, null, null, structure));
+                this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(null, null, null, null, null, null, structure));
             }
         }
     }
@@ -20,22 +23,31 @@ export class SenderKeyRecord {
         return this.senderKeyStates.find(state => state.getKeyId() === keyId);
     }
     addSenderKeyState(id, iteration, chainKey, signatureKey) {
-        this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, null, signatureKey));
+        this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(id, iteration, chainKey, null, signatureKey));
         if (this.senderKeyStates.length > this.MAX_STATES) {
             this.senderKeyStates.shift();
         }
     }
     setSenderKeyState(id, iteration, chainKey, keyPair) {
         this.senderKeyStates.length = 0;
-        this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, keyPair));
+        this.senderKeyStates.push(new sender_key_state_1.SenderKeyState(id, iteration, chainKey, keyPair));
     }
     serialize() {
         return this.senderKeyStates.map(state => state.getStructure());
     }
     static deserialize(data) {
-        const str = Buffer.from(data).toString('utf-8');
-        const parsed = JSON.parse(str, BufferJSON.reviver);
+        let parsed;
+        if (typeof data === 'string') {
+            parsed = JSON.parse(data, generics_1.BufferJSON.reviver);
+        }
+        else if (data instanceof Uint8Array) {
+            const str = Buffer.from(data).toString('utf-8');
+            parsed = JSON.parse(str, generics_1.BufferJSON.reviver);
+        }
+        else {
+            parsed = data;
+        }
         return new SenderKeyRecord(parsed);
     }
 }
-//# sourceMappingURL=sender-key-record.js.map
+exports.SenderKeyRecord = SenderKeyRecord;

package/lib/Signal/Group/sender-key-state.d.ts

@@ -1,5 +1,5 @@
-import { SenderChainKey } from './sender-chain-key.js';
-import { SenderMessageKey } from './sender-message-key.js';
+import { SenderChainKey } from './sender-chain-key';
+import { SenderMessageKey } from './sender-message-key';
 interface SenderChainKeyStructure {
     iteration: number;
     seed: Uint8Array;
@@ -21,10 +21,10 @@ interface SenderKeyStateStructure {
 export declare class SenderKeyState {
     private readonly MAX_MESSAGE_KEYS;
     private readonly senderKeyStateStructure;
-    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null | string, signatureKeyPair?: {
-        public: Uint8Array | string;
-        private: Uint8Array | string;
-    } | null, signatureKeyPublic?: Uint8Array | string | null, signatureKeyPrivate?: Uint8Array | string | null, senderKeyStateStructure?: SenderKeyStateStructure | null);
+    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null, signatureKeyPair?: {
+        public: Uint8Array;
+        private: Uint8Array;
+    } | null, signatureKeyPublic?: Uint8Array | null, signatureKeyPrivate?: Uint8Array | null, senderKeyStateStructure?: SenderKeyStateStructure | null);
     getKeyId(): number;
     getSenderChainKey(): SenderChainKey;
     setSenderChainKey(chainKey: SenderChainKey): void;
@@ -36,4 +36,3 @@ export declare class SenderKeyState {
     getStructure(): SenderKeyStateStructure;
 }
 export {};
-//# sourceMappingURL=sender-key-state.d.ts.map

package/lib/Signal/Group/sender-key-state.js

@@ -1,31 +1,37 @@
-import { SenderChainKey } from './sender-chain-key.js';
-import { SenderMessageKey } from './sender-message-key.js';
-export class SenderKeyState {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderKeyState = void 0;
+const sender_chain_key_1 = require("./sender-chain-key");
+const sender_message_key_1 = require("./sender-message-key");
+class SenderKeyState {
     constructor(id, iteration, chainKey, signatureKeyPair, signatureKeyPublic, signatureKeyPrivate, senderKeyStateStructure) {
         this.MAX_MESSAGE_KEYS = 2000;
         if (senderKeyStateStructure) {
-            this.senderKeyStateStructure = {
-                ...senderKeyStateStructure,
-                senderMessageKeys: Array.isArray(senderKeyStateStructure.senderMessageKeys)
-                    ? senderKeyStateStructure.senderMessageKeys
-                    : []
-            };
+            this.senderKeyStateStructure = senderKeyStateStructure;
         }
         else {
             if (signatureKeyPair) {
                 signatureKeyPublic = signatureKeyPair.public;
                 signatureKeyPrivate = signatureKeyPair.private;
             }
+            chainKey = typeof chainKey === 'string' ? Buffer.from(chainKey, 'base64') : chainKey;
+            const senderChainKeyStructure = {
+                iteration: iteration || 0,
+                seed: chainKey || Buffer.alloc(0)
+            };
+            const signingKeyStructure = {
+                public: typeof signatureKeyPublic === 'string'
+                    ? Buffer.from(signatureKeyPublic, 'base64')
+                    : signatureKeyPublic || Buffer.alloc(0)
+            };
+            if (signatureKeyPrivate) {
+                signingKeyStructure.private =
+                    typeof signatureKeyPrivate === 'string' ? Buffer.from(signatureKeyPrivate, 'base64') : signatureKeyPrivate;
+            }
             this.senderKeyStateStructure = {
                 senderKeyId: id || 0,
-                senderChainKey: {
-                    iteration: iteration || 0,
-                    seed: Buffer.from(chainKey || [])
-                },
-                senderSigningKey: {
-                    public: Buffer.from(signatureKeyPublic || []),
-                    private: Buffer.from(signatureKeyPrivate || [])
-                },
+                senderChainKey: senderChainKeyStructure,
+                senderSigningKey: signingKeyStructure,
                 senderMessageKeys: []
             };
         }
@@ -34,7 +40,7 @@ export class SenderKeyState {
         return this.senderKeyStateStructure.senderKeyId;
     }
     getSenderChainKey() {
-        return new SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
+        return new sender_chain_key_1.SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
     }
     setSenderChainKey(chainKey) {
         this.senderKeyStateStructure.senderChainKey = {
@@ -43,17 +49,26 @@ export class SenderKeyState {
         };
     }
     getSigningKeyPublic() {
-        const publicKey = Buffer.from(this.senderKeyStateStructure.senderSigningKey.public);
-        if (publicKey.length === 32) {
-            const fixed = Buffer.alloc(33);
-            fixed[0] = 0x05;
-            publicKey.copy(fixed, 1);
-            return fixed;
+        const publicKey = this.senderKeyStateStructure.senderSigningKey.public;
+        if (publicKey instanceof Buffer) {
+            return publicKey;
         }
-        return publicKey;
+        else if (typeof publicKey === 'string') {
+            return Buffer.from(publicKey, 'base64');
+        }
+        return Buffer.from(publicKey || []);
     }
     getSigningKeyPrivate() {
         const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
+        if (!privateKey) {
+            return undefined;
+        }
+        if (privateKey instanceof Buffer) {
+            return privateKey;
+        }
+        else if (typeof privateKey === 'string') {
+            return Buffer.from(privateKey, 'base64');
+        }
         return Buffer.from(privateKey || []);
     }
     hasSenderMessageKey(iteration) {
@@ -73,7 +88,7 @@ export class SenderKeyState {
         if (index !== -1) {
             const messageKey = this.senderKeyStateStructure.senderMessageKeys[index];
             this.senderKeyStateStructure.senderMessageKeys.splice(index, 1);
-            return new SenderMessageKey(messageKey.iteration, messageKey.seed);
+            return new sender_message_key_1.SenderMessageKey(messageKey.iteration, messageKey.seed);
         }
         return null;
     }
@@ -81,4 +96,4 @@ export class SenderKeyState {
         return this.senderKeyStateStructure;
     }
 }
-//# sourceMappingURL=sender-key-state.js.map
+exports.SenderKeyState = SenderKeyState;

package/lib/Signal/Group/sender-message-key.d.ts

@@ -9,4 +9,3 @@ export declare class SenderMessageKey {
     getCipherKey(): Uint8Array;
     getSeed(): Uint8Array;
 }
-//# sourceMappingURL=sender-message-key.d.ts.map

package/lib/Signal/Group/sender-message-key.js

@@ -1,7 +1,10 @@
-import { deriveSecrets } from 'libsignal/src/crypto.js';
-export class SenderMessageKey {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SenderMessageKey = void 0;
+const crypto_1 = require("libsignal/src/crypto");
+class SenderMessageKey {
     constructor(iteration, seed) {
-        const derivative = deriveSecrets(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
+        const derivative = (0, crypto_1.deriveSecrets)(seed, Buffer.alloc(32), Buffer.from('WhisperGroup'));
         const keys = new Uint8Array(32);
         keys.set(new Uint8Array(derivative[0].slice(16)));
         keys.set(new Uint8Array(derivative[1].slice(0, 16)), 16);
@@ -23,4 +26,4 @@ export class SenderMessageKey {
         return this.seed;
     }
 }
-//# sourceMappingURL=sender-message-key.js.map
+exports.SenderMessageKey = SenderMessageKey;

package/lib/Signal/libsignal.d.ts

@@ -1,5 +1,3 @@
-import type { LIDMapping, SignalAuthState } from '../Types/index.js';
-import type { SignalRepositoryWithLIDStore } from '../Types/Signal.js';
-import type { ILogger } from '../Utils/logger.js';
-export declare function makeLibSignalRepository(auth: SignalAuthState, logger: ILogger, pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>): SignalRepositoryWithLIDStore;
-//# sourceMappingURL=libsignal.d.ts.map
+import { SignalAuthState } from '../Types';
+import { SignalRepository } from '../Types/Signal';
+export declare function makeLibSignalRepository(auth: SignalAuthState): SignalRepository;