@mrlegendbot/baileys 1.2.5 → 1.2.6

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

@@ -0,0 +1,18 @@
+interface Sender {
+    id: string;
+    deviceId: number;
+    toString(): string;
+}
+export declare class SenderKeyName {
+    private readonly groupId;
+    private readonly sender;
+    constructor(groupId: string, sender: Sender);
+    getGroupId(): string;
+    getSender(): Sender;
+    serialize(): string;
+    toString(): string;
+    equals(other: SenderKeyName | null): boolean;
+    hashCode(): number;
+}
+export {};
+//# sourceMappingURL=sender-key-name.d.ts.map

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

@@ -1,46 +1,48 @@
 function isNull(str) {
-  return str === null || str === '';
+    return str === null || str === '';
 }
 function intValue(num) {
-  const MAX_VALUE = 0x7fffffff;
-  const MIN_VALUE = -0x80000000;
-  if (num > MAX_VALUE || num < MIN_VALUE) {
-    return num & 0xffffffff;
-  }
-  return num;
+    const MAX_VALUE = 0x7fffffff;
+    const MIN_VALUE = -0x80000000;
+    if (num > MAX_VALUE || num < MIN_VALUE) {
+        return num & 0xffffffff;
+    }
+    return num;
 }
 function hashCode(strKey) {
-  let hash = 0;
-  if (!isNull(strKey)) {
-    for (let i = 0; i < strKey.length; i++) {
-      hash = hash * 31 + strKey.charCodeAt(i);
-      hash = intValue(hash);
-    }
-  }
-  return hash;
+    let hash = 0;
+    if (!isNull(strKey)) {
+        for (let i = 0; i < strKey.length; i++) {
+            hash = hash * 31 + strKey.charCodeAt(i);
+            hash = intValue(hash);
+        }
+    }
+    return hash;
 }
 export class SenderKeyName {
-  constructor(groupId, sender) {
-    this.groupId = groupId;
-    this.sender = sender;
-  }
-  getGroupId() {
-    return this.groupId;
-  }
-  getSender() {
-    return this.sender;
-  }
-  serialize() {
-    return `${this.groupId}::${this.sender.id}::${this.sender.deviceId}`;
-  }
-  toString() {
-    return this.serialize();
-  }
-  equals(other) {
-    if (other === null) return false;
-    return this.groupId === other.groupId && this.sender.toString() === other.sender.toString();
-  }
-  hashCode() {
-    return hashCode(this.groupId) ^ hashCode(this.sender.toString());
-  }
+    constructor(groupId, sender) {
+        this.groupId = groupId;
+        this.sender = sender;
+    }
+    getGroupId() {
+        return this.groupId;
+    }
+    getSender() {
+        return this.sender;
+    }
+    serialize() {
+        return `${this.groupId}::${this.sender.id}::${this.sender.deviceId}`;
+    }
+    toString() {
+        return this.serialize();
+    }
+    equals(other) {
+        if (other === null)
+            return false;
+        return this.groupId === other.groupId && this.sender.toString() === other.sender.toString();
+    }
+    hashCode() {
+        return hashCode(this.groupId) ^ hashCode(this.sender.toString());
+    }
 }
+//# sourceMappingURL=sender-key-name.js.map

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

@@ -0,0 +1,31 @@
+import { SenderKeyState } from './sender-key-state.js';
+export interface SenderKeyStateStructure {
+    senderKeyId: number;
+    senderChainKey: {
+        iteration: number;
+        seed: Uint8Array;
+    };
+    senderSigningKey: {
+        public: Uint8Array;
+        private?: Uint8Array;
+    };
+    senderMessageKeys: Array<{
+        iteration: number;
+        seed: Uint8Array;
+    }>;
+}
+export declare class SenderKeyRecord {
+    private readonly MAX_STATES;
+    private readonly senderKeyStates;
+    constructor(serialized?: SenderKeyStateStructure[]);
+    isEmpty(): boolean;
+    getSenderKeyState(keyId?: number): SenderKeyState | undefined;
+    addSenderKeyState(id: number, iteration: number, chainKey: Uint8Array, signatureKey: Uint8Array): void;
+    setSenderKeyState(id: number, iteration: number, chainKey: Uint8Array, keyPair: {
+        public: Uint8Array;
+        private: Uint8Array;
+    }): void;
+    serialize(): SenderKeyStateStructure[];
+    static deserialize(data: Uint8Array): SenderKeyRecord;
+}
+//# sourceMappingURL=sender-key-record.d.ts.map

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

@@ -1,40 +1,41 @@
 import { BufferJSON } from '../../Utils/generics.js';
 import { SenderKeyState } from './sender-key-state.js';
 export 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));
-      }
+    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));
+            }
+        }
     }
-  }
-  isEmpty() {
-    return this.senderKeyStates.length === 0;
-  }
-  getSenderKeyState(keyId) {
-    if (keyId === undefined && this.senderKeyStates.length) {
-      return this.senderKeyStates[this.senderKeyStates.length - 1];
+    isEmpty() {
+        return this.senderKeyStates.length === 0;
     }
-    return this.senderKeyStates.find(state => state.getKeyId() === keyId);
-  }
-  addSenderKeyState(id, iteration, chainKey, signatureKey) {
-    this.senderKeyStates.push(new SenderKeyState(id, iteration, chainKey, null, signatureKey));
-    if (this.senderKeyStates.length > this.MAX_STATES) {
-      this.senderKeyStates.shift();
+    getSenderKeyState(keyId) {
+        if (keyId === undefined && this.senderKeyStates.length) {
+            return this.senderKeyStates[this.senderKeyStates.length - 1];
+        }
+        return this.senderKeyStates.find(state => state.getKeyId() === keyId);
+    }
+    addSenderKeyState(id, iteration, chainKey, signatureKey) {
+        this.senderKeyStates.push(new 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));
+    }
+    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);
+        return new SenderKeyRecord(parsed);
     }
-  }
-  setSenderKeyState(id, iteration, chainKey, keyPair) {
-    this.senderKeyStates.length = 0;
-    this.senderKeyStates.push(new 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);
-    return new SenderKeyRecord(parsed);
-  }
 }
+//# sourceMappingURL=sender-key-record.js.map

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

@@ -0,0 +1,39 @@
+import { SenderChainKey } from './sender-chain-key.js';
+import { SenderMessageKey } from './sender-message-key.js';
+interface SenderChainKeyStructure {
+    iteration: number;
+    seed: Uint8Array;
+}
+interface SenderSigningKeyStructure {
+    public: Uint8Array;
+    private?: Uint8Array;
+}
+interface SenderMessageKeyStructure {
+    iteration: number;
+    seed: Uint8Array;
+}
+interface SenderKeyStateStructure {
+    senderKeyId: number;
+    senderChainKey: SenderChainKeyStructure;
+    senderSigningKey: SenderSigningKeyStructure;
+    senderMessageKeys: SenderMessageKeyStructure[];
+}
+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);
+    getKeyId(): number;
+    getSenderChainKey(): SenderChainKey;
+    setSenderChainKey(chainKey: SenderChainKey): void;
+    getSigningKeyPublic(): Buffer;
+    getSigningKeyPrivate(): Buffer | undefined;
+    hasSenderMessageKey(iteration: number): boolean;
+    addSenderMessageKey(senderMessageKey: SenderMessageKey): void;
+    removeSenderMessageKey(iteration: number): SenderMessageKey | null;
+    getStructure(): SenderKeyStateStructure;
+}
+export {};
+//# sourceMappingURL=sender-key-state.d.ts.map

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

@@ -1,80 +1,84 @@
 import { SenderChainKey } from './sender-chain-key.js';
 import { SenderMessageKey } from './sender-message-key.js';
 export 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 : []
-      };
-    } else {
-      if (signatureKeyPair) {
-        signatureKeyPublic = signatureKeyPair.public;
-        signatureKeyPrivate = signatureKeyPair.private;
-      }
-      this.senderKeyStateStructure = {
-        senderKeyId: id || 0,
-        senderChainKey: {
-          iteration: iteration || 0,
-          seed: Buffer.from(chainKey || [])
-        },
-        senderSigningKey: {
-          public: Buffer.from(signatureKeyPublic || []),
-          private: Buffer.from(signatureKeyPrivate || [])
-        },
-        senderMessageKeys: []
-      };
+    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
+                    : []
+            };
+        }
+        else {
+            if (signatureKeyPair) {
+                signatureKeyPublic = signatureKeyPair.public;
+                signatureKeyPrivate = signatureKeyPair.private;
+            }
+            this.senderKeyStateStructure = {
+                senderKeyId: id || 0,
+                senderChainKey: {
+                    iteration: iteration || 0,
+                    seed: Buffer.from(chainKey || [])
+                },
+                senderSigningKey: {
+                    public: Buffer.from(signatureKeyPublic || []),
+                    private: Buffer.from(signatureKeyPrivate || [])
+                },
+                senderMessageKeys: []
+            };
+        }
     }
-  }
-  getKeyId() {
-    return this.senderKeyStateStructure.senderKeyId;
-  }
-  getSenderChainKey() {
-    return new SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
-  }
-  setSenderChainKey(chainKey) {
-    this.senderKeyStateStructure.senderChainKey = {
-      iteration: chainKey.getIteration(),
-      seed: chainKey.getSeed()
-    };
-  }
-  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;
+    getKeyId() {
+        return this.senderKeyStateStructure.senderKeyId;
     }
-    return publicKey;
-  }
-  getSigningKeyPrivate() {
-    const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
-    return Buffer.from(privateKey || []);
-  }
-  hasSenderMessageKey(iteration) {
-    return this.senderKeyStateStructure.senderMessageKeys.some(key => key.iteration === iteration);
-  }
-  addSenderMessageKey(senderMessageKey) {
-    this.senderKeyStateStructure.senderMessageKeys.push({
-      iteration: senderMessageKey.getIteration(),
-      seed: senderMessageKey.getSeed()
-    });
-    if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
-      this.senderKeyStateStructure.senderMessageKeys.shift();
+    getSenderChainKey() {
+        return new SenderChainKey(this.senderKeyStateStructure.senderChainKey.iteration, this.senderKeyStateStructure.senderChainKey.seed);
     }
-  }
-  removeSenderMessageKey(iteration) {
-    const index = this.senderKeyStateStructure.senderMessageKeys.findIndex(key => key.iteration === iteration);
-    if (index !== -1) {
-      const messageKey = this.senderKeyStateStructure.senderMessageKeys[index];
-      this.senderKeyStateStructure.senderMessageKeys.splice(index, 1);
-      return new SenderMessageKey(messageKey.iteration, messageKey.seed);
+    setSenderChainKey(chainKey) {
+        this.senderKeyStateStructure.senderChainKey = {
+            iteration: chainKey.getIteration(),
+            seed: chainKey.getSeed()
+        };
+    }
+    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;
+        }
+        return publicKey;
+    }
+    getSigningKeyPrivate() {
+        const privateKey = this.senderKeyStateStructure.senderSigningKey.private;
+        return Buffer.from(privateKey || []);
+    }
+    hasSenderMessageKey(iteration) {
+        return this.senderKeyStateStructure.senderMessageKeys.some(key => key.iteration === iteration);
+    }
+    addSenderMessageKey(senderMessageKey) {
+        this.senderKeyStateStructure.senderMessageKeys.push({
+            iteration: senderMessageKey.getIteration(),
+            seed: senderMessageKey.getSeed()
+        });
+        if (this.senderKeyStateStructure.senderMessageKeys.length > this.MAX_MESSAGE_KEYS) {
+            this.senderKeyStateStructure.senderMessageKeys.shift();
+        }
+    }
+    removeSenderMessageKey(iteration) {
+        const index = this.senderKeyStateStructure.senderMessageKeys.findIndex(key => key.iteration === iteration);
+        if (index !== -1) {
+            const messageKey = this.senderKeyStateStructure.senderMessageKeys[index];
+            this.senderKeyStateStructure.senderMessageKeys.splice(index, 1);
+            return new SenderMessageKey(messageKey.iteration, messageKey.seed);
+        }
+        return null;
+    }
+    getStructure() {
+        return this.senderKeyStateStructure;
     }
-    return null;
-  }
-  getStructure() {
-    return this.senderKeyStateStructure;
-  }
 }
+//# sourceMappingURL=sender-key-state.js.map

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

@@ -0,0 +1,12 @@
+export declare class SenderMessageKey {
+    private readonly iteration;
+    private readonly iv;
+    private readonly cipherKey;
+    private readonly seed;
+    constructor(iteration: number, seed: Uint8Array);
+    getIteration(): number;
+    getIv(): Uint8Array;
+    getCipherKey(): Uint8Array;
+    getSeed(): Uint8Array;
+}
+//# sourceMappingURL=sender-message-key.d.ts.map

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

@@ -1,25 +1,26 @@
 import { deriveSecrets } from 'libsignal/src/crypto.js';
 export class SenderMessageKey {
-  constructor(iteration, seed) {
-    const derivative = 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);
-    this.iv = Buffer.from(derivative[0].slice(0, 16));
-    this.cipherKey = Buffer.from(keys.buffer);
-    this.iteration = iteration;
-    this.seed = seed;
-  }
-  getIteration() {
-    return this.iteration;
-  }
-  getIv() {
-    return this.iv;
-  }
-  getCipherKey() {
-    return this.cipherKey;
-  }
-  getSeed() {
-    return this.seed;
-  }
+    constructor(iteration, seed) {
+        const derivative = 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);
+        this.iv = Buffer.from(derivative[0].slice(0, 16));
+        this.cipherKey = Buffer.from(keys.buffer);
+        this.iteration = iteration;
+        this.seed = seed;
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getIv() {
+        return this.iv;
+    }
+    getCipherKey() {
+        return this.cipherKey;
+    }
+    getSeed() {
+        return this.seed;
+    }
 }
+//# sourceMappingURL=sender-message-key.js.map

package/lib/Signal/libsignal.d.ts

@@ -0,0 +1,5 @@
+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