@mrlegendbot/baileys 1.2.5 → 1.2.7

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

@@ -1,25 +1,26 @@
 import { calculateMAC } from 'libsignal/src/crypto.js';
 import { SenderMessageKey } from './sender-message-key.js';
 export class SenderChainKey {
-  constructor(iteration, chainKey) {
-    this.MESSAGE_KEY_SEED = Buffer.from([0x01]);
-    this.CHAIN_KEY_SEED = Buffer.from([0x02]);
-    this.iteration = iteration;
-    this.chainKey = Buffer.from(chainKey);
-  }
-  getIteration() {
-    return this.iteration;
-  }
-  getSenderMessageKey() {
-    return new SenderMessageKey(this.iteration, this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey));
-  }
-  getNext() {
-    return new SenderChainKey(this.iteration + 1, this.getDerivative(this.CHAIN_KEY_SEED, this.chainKey));
-  }
-  getSeed() {
-    return this.chainKey;
-  }
-  getDerivative(seed, key) {
-    return calculateMAC(key, seed);
-  }
+    constructor(iteration, chainKey) {
+        this.MESSAGE_KEY_SEED = Buffer.from([0x01]);
+        this.CHAIN_KEY_SEED = Buffer.from([0x02]);
+        this.iteration = iteration;
+        this.chainKey = Buffer.from(chainKey);
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getSenderMessageKey() {
+        return new SenderMessageKey(this.iteration, this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey));
+    }
+    getNext() {
+        return new SenderChainKey(this.iteration + 1, this.getDerivative(this.CHAIN_KEY_SEED, this.chainKey));
+    }
+    getSeed() {
+        return this.chainKey;
+    }
+    getDerivative(seed, key) {
+        return calculateMAC(key, seed);
+    }
 }
+//# sourceMappingURL=sender-chain-key.js.map

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

@@ -0,0 +1,17 @@
+import { CiphertextMessage } from './ciphertext-message.js';
+export declare class SenderKeyDistributionMessage extends CiphertextMessage {
+    private readonly id;
+    private readonly iteration;
+    private readonly chainKey;
+    private readonly signatureKey;
+    private readonly serialized;
+    constructor(id?: number | null, iteration?: number | null, chainKey?: Uint8Array | null, signatureKey?: Uint8Array | null, serialized?: Uint8Array | null);
+    private intsToByteHighAndLow;
+    serialize(): Uint8Array;
+    getType(): number;
+    getIteration(): number;
+    getChainKey(): Uint8Array;
+    getSignatureKey(): Uint8Array;
+    getId(): number;
+}
+//# sourceMappingURL=sender-key-distribution-message.d.ts.map

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

@@ -1,54 +1,63 @@
-import { proto } from '../../../WAProto/compiler.js';
+import { proto } from '../../../WAProto/index.js';
 import { CiphertextMessage } from './ciphertext-message.js';
 export class SenderKeyDistributionMessage extends CiphertextMessage {
-  constructor(id, iteration, chainKey, signatureKey, serialized) {
-    super();
-    if (serialized) {
-      try {
-        const message = serialized.slice(1);
-        const distributionMessage = proto.SenderKeyDistributionMessage.decode(message).toJSON();
-        this.serialized = serialized;
-        this.id = distributionMessage.id;
-        this.iteration = distributionMessage.iteration;
-        this.chainKey = typeof distributionMessage.chainKey === 'string' ? Buffer.from(distributionMessage.chainKey, 'base64') : distributionMessage.chainKey;
-        this.signatureKey = typeof distributionMessage.signingKey === 'string' ? Buffer.from(distributionMessage.signingKey, 'base64') : distributionMessage.signingKey;
-      } catch (e) {
-        throw new Error(String(e));
-      }
-    } else {
-      const version = this.intsToByteHighAndLow(this.CURRENT_VERSION, this.CURRENT_VERSION);
-      this.id = id;
-      this.iteration = iteration;
-      this.chainKey = chainKey;
-      this.signatureKey = signatureKey;
-      const message = proto.SenderKeyDistributionMessage.encode(proto.SenderKeyDistributionMessage.create({
-        id,
-        iteration,
-        chainKey,
-        signingKey: this.signatureKey
-      })).finish();
-      this.serialized = Buffer.concat([Buffer.from([version]), message]);
-    }
-  }
-  intsToByteHighAndLow(highValue, lowValue) {
-    return ((highValue << 4 | lowValue) & 0xff) % 256;
-  }
-  serialize() {
-    return this.serialized;
-  }
-  getType() {
-    return this.SENDERKEY_DISTRIBUTION_TYPE;
-  }
-  getIteration() {
-    return this.iteration;
-  }
-  getChainKey() {
-    return this.chainKey;
-  }
-  getSignatureKey() {
-    return this.signatureKey;
-  }
-  getId() {
-    return this.id;
-  }
+    constructor(id, iteration, chainKey, signatureKey, serialized) {
+        super();
+        if (serialized) {
+            try {
+                const message = serialized.slice(1);
+                const distributionMessage = proto.SenderKeyDistributionMessage.decode(message).toJSON();
+                this.serialized = serialized;
+                this.id = distributionMessage.id;
+                this.iteration = distributionMessage.iteration;
+                this.chainKey =
+                    typeof distributionMessage.chainKey === 'string'
+                        ? Buffer.from(distributionMessage.chainKey, 'base64')
+                        : distributionMessage.chainKey;
+                this.signatureKey =
+                    typeof distributionMessage.signingKey === 'string'
+                        ? Buffer.from(distributionMessage.signingKey, 'base64')
+                        : distributionMessage.signingKey;
+            }
+            catch (e) {
+                throw new Error(String(e));
+            }
+        }
+        else {
+            const version = this.intsToByteHighAndLow(this.CURRENT_VERSION, this.CURRENT_VERSION);
+            this.id = id;
+            this.iteration = iteration;
+            this.chainKey = chainKey;
+            this.signatureKey = signatureKey;
+            const message = proto.SenderKeyDistributionMessage.encode(proto.SenderKeyDistributionMessage.create({
+                id,
+                iteration,
+                chainKey,
+                signingKey: this.signatureKey
+            })).finish();
+            this.serialized = Buffer.concat([Buffer.from([version]), message]);
+        }
+    }
+    intsToByteHighAndLow(highValue, lowValue) {
+        return (((highValue << 4) | lowValue) & 0xff) % 256;
+    }
+    serialize() {
+        return this.serialized;
+    }
+    getType() {
+        return this.SENDERKEY_DISTRIBUTION_TYPE;
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getChainKey() {
+        return this.chainKey;
+    }
+    getSignatureKey() {
+        return this.signatureKey;
+    }
+    getId() {
+        return this.id;
+    }
 }
+//# sourceMappingURL=sender-key-distribution-message.js.map

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

@@ -0,0 +1,19 @@
+import { CiphertextMessage } from './ciphertext-message.js';
+export declare class SenderKeyMessage extends CiphertextMessage {
+    private readonly SIGNATURE_LENGTH;
+    private readonly messageVersion;
+    private readonly keyId;
+    private readonly iteration;
+    private readonly ciphertext;
+    private readonly signature;
+    private readonly serialized;
+    constructor(keyId?: number | null, iteration?: number | null, ciphertext?: Uint8Array | null, signatureKey?: Uint8Array | null, serialized?: Uint8Array | null);
+    getKeyId(): number;
+    getIteration(): number;
+    getCipherText(): Uint8Array;
+    verifySignature(signatureKey: Uint8Array): void;
+    private getSignature;
+    serialize(): Uint8Array;
+    getType(): number;
+}
+//# sourceMappingURL=sender-key-message.d.ts.map

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

@@ -1,60 +1,66 @@
 import { calculateSignature, verifySignature } from 'libsignal/src/curve.js';
-import { proto } from '../../../WAProto/compiler.js';
+import { proto } from '../../../WAProto/index.js';
 import { CiphertextMessage } from './ciphertext-message.js';
 export class SenderKeyMessage extends CiphertextMessage {
-  constructor(keyId, iteration, ciphertext, signatureKey, serialized) {
-    super();
-    this.SIGNATURE_LENGTH = 64;
-    if (serialized) {
-      const version = serialized[0];
-      const message = serialized.slice(1, serialized.length - this.SIGNATURE_LENGTH);
-      const signature = serialized.slice(-1 * this.SIGNATURE_LENGTH);
-      const senderKeyMessage = proto.SenderKeyMessage.decode(message).toJSON();
-      this.serialized = serialized;
-      this.messageVersion = (version & 0xff) >> 4;
-      this.keyId = senderKeyMessage.id;
-      this.iteration = senderKeyMessage.iteration;
-      this.ciphertext = typeof senderKeyMessage.ciphertext === 'string' ? Buffer.from(senderKeyMessage.ciphertext, 'base64') : senderKeyMessage.ciphertext;
-      this.signature = signature;
-    } else {
-      const version = ((this.CURRENT_VERSION << 4 | this.CURRENT_VERSION) & 0xff) % 256;
-      const ciphertextBuffer = Buffer.from(ciphertext);
-      const message = proto.SenderKeyMessage.encode(proto.SenderKeyMessage.create({
-        id: keyId,
-        iteration: iteration,
-        ciphertext: ciphertextBuffer
-      })).finish();
-      const signature = this.getSignature(signatureKey, Buffer.concat([Buffer.from([version]), message]));
-      this.serialized = Buffer.concat([Buffer.from([version]), message, Buffer.from(signature)]);
-      this.messageVersion = this.CURRENT_VERSION;
-      this.keyId = keyId;
-      this.iteration = iteration;
-      this.ciphertext = ciphertextBuffer;
-      this.signature = signature;
-    }
-  }
-  getKeyId() {
-    return this.keyId;
-  }
-  getIteration() {
-    return this.iteration;
-  }
-  getCipherText() {
-    return this.ciphertext;
-  }
-  verifySignature(signatureKey) {
-    const part1 = this.serialized.slice(0, this.serialized.length - this.SIGNATURE_LENGTH);
-    const part2 = this.serialized.slice(-1 * this.SIGNATURE_LENGTH);
-    const res = verifySignature(signatureKey, part1, part2);
-    if (!res) throw new Error('Invalid signature!');
-  }
-  getSignature(signatureKey, serialized) {
-    return Buffer.from(calculateSignature(signatureKey, serialized));
-  }
-  serialize() {
-    return this.serialized;
-  }
-  getType() {
-    return 4;
-  }
+    constructor(keyId, iteration, ciphertext, signatureKey, serialized) {
+        super();
+        this.SIGNATURE_LENGTH = 64;
+        if (serialized) {
+            const version = serialized[0];
+            const message = serialized.slice(1, serialized.length - this.SIGNATURE_LENGTH);
+            const signature = serialized.slice(-1 * this.SIGNATURE_LENGTH);
+            const senderKeyMessage = proto.SenderKeyMessage.decode(message).toJSON();
+            this.serialized = serialized;
+            this.messageVersion = (version & 0xff) >> 4;
+            this.keyId = senderKeyMessage.id;
+            this.iteration = senderKeyMessage.iteration;
+            this.ciphertext =
+                typeof senderKeyMessage.ciphertext === 'string'
+                    ? Buffer.from(senderKeyMessage.ciphertext, 'base64')
+                    : senderKeyMessage.ciphertext;
+            this.signature = signature;
+        }
+        else {
+            const version = (((this.CURRENT_VERSION << 4) | this.CURRENT_VERSION) & 0xff) % 256;
+            const ciphertextBuffer = Buffer.from(ciphertext);
+            const message = proto.SenderKeyMessage.encode(proto.SenderKeyMessage.create({
+                id: keyId,
+                iteration: iteration,
+                ciphertext: ciphertextBuffer
+            })).finish();
+            const signature = this.getSignature(signatureKey, Buffer.concat([Buffer.from([version]), message]));
+            this.serialized = Buffer.concat([Buffer.from([version]), message, Buffer.from(signature)]);
+            this.messageVersion = this.CURRENT_VERSION;
+            this.keyId = keyId;
+            this.iteration = iteration;
+            this.ciphertext = ciphertextBuffer;
+            this.signature = signature;
+        }
+    }
+    getKeyId() {
+        return this.keyId;
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getCipherText() {
+        return this.ciphertext;
+    }
+    verifySignature(signatureKey) {
+        const part1 = this.serialized.slice(0, this.serialized.length - this.SIGNATURE_LENGTH);
+        const part2 = this.serialized.slice(-1 * this.SIGNATURE_LENGTH);
+        const res = verifySignature(signatureKey, part1, part2);
+        if (!res)
+            throw new Error('Invalid signature!');
+    }
+    getSignature(signatureKey, serialized) {
+        return Buffer.from(calculateSignature(signatureKey, serialized));
+    }
+    serialize() {
+        return this.serialized;
+    }
+    getType() {
+        return 4;
+    }
 }
+//# sourceMappingURL=sender-key-message.js.map

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