@xbibzlibrary/whatsbibz 1.3.0

package/lib/Signal/Group/ciphertext-message.d.ts

@@ -0,0 +1,9 @@
+export declare class CiphertextMessage {
+    readonly UNSUPPORTED_VERSION: number;
+    readonly CURRENT_VERSION: number;
+    readonly WHISPER_TYPE: number;
+    readonly PREKEY_TYPE: number;
+    readonly SENDERKEY_TYPE: number;
+    readonly SENDERKEY_DISTRIBUTION_TYPE: number;
+    readonly ENCRYPTED_MESSAGE_OVERHEAD: number;
+}

package/lib/Signal/Group/ciphertext-message.js

@@ -0,0 +1,11 @@
+export class CiphertextMessage {
+    constructor() {
+        this.UNSUPPORTED_VERSION = 1;
+        this.CURRENT_VERSION = 3;
+        this.WHISPER_TYPE = 2;
+        this.PREKEY_TYPE = 3;
+        this.SENDERKEY_TYPE = 4;
+        this.SENDERKEY_DISTRIBUTION_TYPE = 5;
+        this.ENCRYPTED_MESSAGE_OVERHEAD = 53;
+    }
+}

package/lib/Signal/Group/group-session-builder.d.ts

@@ -0,0 +1,14 @@
+import { SenderKeyDistributionMessage } from './sender-key-distribution-message.js';
+import { SenderKeyName } from './sender-key-name.js';
+import { SenderKeyRecord } from './sender-key-record.js';
+interface SenderKeyStore {
+    loadSenderKey(senderKeyName: SenderKeyName): Promise<SenderKeyRecord>;
+    storeSenderKey(senderKeyName: SenderKeyName, record: SenderKeyRecord): Promise<void>;
+}
+export declare class GroupSessionBuilder {
+    private readonly senderKeyStore;
+    constructor(senderKeyStore: SenderKeyStore);
+    process(senderKeyName: SenderKeyName, senderKeyDistributionMessage: SenderKeyDistributionMessage): Promise<void>;
+    create(senderKeyName: SenderKeyName): Promise<SenderKeyDistributionMessage>;
+}
+export {};

package/lib/Signal/Group/group-session-builder.js

@@ -0,0 +1,29 @@
+import * as keyhelper from './keyhelper.js';
+import { SenderKeyDistributionMessage } from './sender-key-distribution-message.js';
+import { SenderKeyName } from './sender-key-name.js';
+import { SenderKeyRecord } from './sender-key-record.js';
+export class GroupSessionBuilder {
+    constructor(senderKeyStore) {
+        this.senderKeyStore = senderKeyStore;
+    }
+    async process(senderKeyName, senderKeyDistributionMessage) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        senderKeyRecord.addSenderKeyState(senderKeyDistributionMessage.getId(), senderKeyDistributionMessage.getIteration(), senderKeyDistributionMessage.getChainKey(), senderKeyDistributionMessage.getSignatureKey());
+        await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+    }
+    async create(senderKeyName) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        if (senderKeyRecord.isEmpty()) {
+            const keyId = keyhelper.generateSenderKeyId();
+            const senderKey = keyhelper.generateSenderKey();
+            const signingKey = keyhelper.generateSenderSigningKey();
+            senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey);
+            await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+        }
+        const state = senderKeyRecord.getSenderKeyState();
+        if (!state) {
+            throw new Error('No session state available');
+        }
+        return new SenderKeyDistributionMessage(state.getKeyId(), state.getSenderChainKey().getIteration(), state.getSenderChainKey().getSeed(), state.getSigningKeyPublic());
+    }
+}

package/lib/Signal/Group/group_cipher.d.ts

@@ -0,0 +1,16 @@
+import { SenderKeyName } from './sender-key-name.js';
+import { SenderKeyRecord } from './sender-key-record.js';
+export interface SenderKeyStore {
+    loadSenderKey(senderKeyName: SenderKeyName): Promise<SenderKeyRecord>;
+    storeSenderKey(senderKeyName: SenderKeyName, record: SenderKeyRecord): Promise<void>;
+}
+export declare class GroupCipher {
+    private readonly senderKeyStore;
+    private readonly senderKeyName;
+    constructor(senderKeyStore: SenderKeyStore, senderKeyName: SenderKeyName);
+    encrypt(paddedPlaintext: Uint8Array): Promise<Uint8Array>;
+    decrypt(senderKeyMessageBytes: Uint8Array): Promise<Uint8Array>;
+    private getSenderKey;
+    private getPlainText;
+    private getCipherText;
+}

package/lib/Signal/Group/group_cipher.js

@@ -0,0 +1,81 @@
+import { decrypt, encrypt } from 'libsignal/src/crypto.js';
+import { SenderKeyMessage } from './sender-key-message.js';
+import { SenderKeyName } from './sender-key-name.js';
+import { SenderKeyRecord } from './sender-key-record.js';
+import { SenderKeyState } from './sender-key-state.js';
+export class GroupCipher {
+    constructor(senderKeyStore, senderKeyName) {
+        this.senderKeyStore = senderKeyStore;
+        this.senderKeyName = senderKeyName;
+    }
+    async encrypt(paddedPlaintext) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        if (!record) {
+            throw new Error('No SenderKeyRecord found for encryption');
+        }
+        const senderKeyState = record.getSenderKeyState();
+        if (!senderKeyState) {
+            throw new Error('No session to encrypt message');
+        }
+        const iteration = senderKeyState.getSenderChainKey().getIteration();
+        const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
+        const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
+        const senderKeyMessage = new SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+        return senderKeyMessage.serialize();
+    }
+    async decrypt(senderKeyMessageBytes) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        if (!record) {
+            throw new Error('No SenderKeyRecord found for decryption');
+        }
+        const senderKeyMessage = new SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+        if (!senderKeyState) {
+            throw new Error('No session found to decrypt message');
+        }
+        senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+        const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+        const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+        return plaintext;
+    }
+    getSenderKey(senderKeyState, iteration) {
+        let senderChainKey = senderKeyState.getSenderChainKey();
+        if (senderChainKey.getIteration() > iteration) {
+            if (senderKeyState.hasSenderMessageKey(iteration)) {
+                const messageKey = senderKeyState.removeSenderMessageKey(iteration);
+                if (!messageKey) {
+                    throw new Error('No sender message key found for iteration');
+                }
+                return messageKey;
+            }
+            throw new Error(`Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`);
+        }
+        if (iteration - senderChainKey.getIteration() > 2000) {
+            throw new Error('Over 2000 messages into the future!');
+        }
+        while (senderChainKey.getIteration() < iteration) {
+            senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
+            senderChainKey = senderChainKey.getNext();
+        }
+        senderKeyState.setSenderChainKey(senderChainKey.getNext());
+        return senderChainKey.getSenderMessageKey();
+    }
+    async getPlainText(iv, key, ciphertext) {
+        try {
+            return decrypt(key, ciphertext, iv);
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
+    }
+    async getCipherText(iv, key, plaintext) {
+        try {
+            return encrypt(key, plaintext, iv);
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
+    }
+}

package/lib/Signal/Group/index.d.ts

@@ -0,0 +1,11 @@
+export { GroupSessionBuilder } from './group-session-builder.js';
+export { SenderKeyDistributionMessage } from './sender-key-distribution-message.js';
+export { SenderKeyRecord } from './sender-key-record.js';
+export { SenderKeyName } from './sender-key-name.js';
+export { GroupCipher } from './group_cipher.js';
+export { SenderKeyState } from './sender-key-state.js';
+export { SenderKeyMessage } from './sender-key-message.js';
+export { SenderMessageKey } from './sender-message-key.js';
+export { SenderChainKey } from './sender-chain-key.js';
+export { CiphertextMessage } from './ciphertext-message.js';
+export * as keyhelper from './keyhelper.js';

package/lib/Signal/Group/index.js

@@ -0,0 +1,11 @@
+export { GroupSessionBuilder } from './group-session-builder.js';
+export { SenderKeyDistributionMessage } from './sender-key-distribution-message.js';
+export { SenderKeyRecord } from './sender-key-record.js';
+export { SenderKeyName } from './sender-key-name.js';
+export { GroupCipher } from './group_cipher.js';
+export { SenderKeyState } from './sender-key-state.js';
+export { SenderKeyMessage } from './sender-key-message.js';
+export { SenderMessageKey } from './sender-message-key.js';
+export { SenderChainKey } from './sender-chain-key.js';
+export { CiphertextMessage } from './ciphertext-message.js';
+export * as keyhelper from './keyhelper.js';

package/lib/Signal/Group/keyhelper.d.ts

@@ -0,0 +1,10 @@
+import { generateKeyPair } from 'libsignal/src/curve.js';
+type KeyPairType = ReturnType<typeof generateKeyPair>;
+export declare function generateSenderKey(): Buffer;
+export declare function generateSenderKeyId(): number;
+export interface SigningKeyPair {
+    public: Buffer;
+    private: Buffer;
+}
+export declare function generateSenderSigningKey(key?: KeyPairType): SigningKeyPair;
+export {};

package/lib/Signal/Group/keyhelper.js

@@ -0,0 +1,17 @@
+import * as nodeCrypto from 'crypto';
+import { generateKeyPair } from 'libsignal/src/curve.js';
+export function generateSenderKey() {
+    return nodeCrypto.randomBytes(32);
+}
+export function generateSenderKeyId() {
+    return nodeCrypto.randomInt(2147483647);
+}
+export function generateSenderSigningKey(key) {
+    if (!key) {
+        key = generateKeyPair();
+    }
+    return {
+        public: Buffer.from(key.pubKey),
+        private: Buffer.from(key.privKey)
+    };
+}

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

@@ -0,0 +1,13 @@
+import { SenderMessageKey } from './sender-message-key.js';
+export declare class SenderChainKey {
+    private readonly MESSAGE_KEY_SEED;
+    private readonly CHAIN_KEY_SEED;
+    private readonly iteration;
+    private readonly chainKey;
+    constructor(iteration: number, chainKey: Uint8Array | Buffer);
+    getIteration(): number;
+    getSenderMessageKey(): SenderMessageKey;
+    getNext(): SenderChainKey;
+    getSeed(): Uint8Array;
+    private getDerivative;
+}

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

@@ -0,0 +1,25 @@
+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);
+    }
+}

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

@@ -0,0 +1,16 @@
+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;
+}

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

@@ -0,0 +1,62 @@
+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;
+    }
+}

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

@@ -0,0 +1,18 @@
+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;
+}

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

@@ -0,0 +1,65 @@
+import { calculateSignature, verifySignature } from 'libsignal/src/curve.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;
+    }
+}

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

@@ -0,0 +1,17 @@
+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 {};

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

@@ -0,0 +1,47 @@
+function isNull(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;
+}
+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;
+}
+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());
+    }
+}

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

@@ -0,0 +1,30 @@
+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;
+}

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

@@ -0,0 +1,40 @@
+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));
+            }
+        }
+    }
+    isEmpty() {
+        return this.senderKeyStates.length === 0;
+    }
+    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);
+    }
+}

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

@@ -0,0 +1,38 @@
+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 {};