@signalapp/libsignal-client 0.74.0 → 0.75.0

package/dist/incremental_mac.d.ts

@@ -13,16 +13,16 @@ export declare function everyNthByte(n: number): ChunkSizeChoice;
 export declare function inferChunkSize(dataSize: number): ChunkSizeChoice;
 export declare class DigestingPassThrough extends stream.Transform {
     private digester;
-    constructor(key: Buffer, sizeChoice: ChunkSizeChoice);
-    getFinalDigest(): Buffer;
-    _transform(data: Buffer, enc: BufferEncoding, callback: CallbackType): void;
+    constructor(key: Uint8Array, sizeChoice: ChunkSizeChoice);
+    getFinalDigest(): Uint8Array;
+    _transform(data: Uint8Array, enc: BufferEncoding, callback: CallbackType): void;
     _final(callback: CallbackType): void;
 }
 export declare class ValidatingPassThrough extends stream.Transform {
     private validator;
     private buffer;
-    constructor(key: Buffer, sizeChoice: ChunkSizeChoice, digest: Buffer);
-    _transform(data: Buffer, enc: BufferEncoding, callback: CallbackType): void;
+    constructor(key: Uint8Array, sizeChoice: ChunkSizeChoice, digest: Uint8Array);
+    _transform(data: Uint8Array, enc: BufferEncoding, callback: CallbackType): void;
     _final(callback: CallbackType): void;
 }
 export declare function chunkSizeInBytes(sizeChoice: ChunkSizeChoice): number;

package/dist/incremental_mac.js

@@ -23,7 +23,9 @@ class DigestingWritable extends stream.Writable {
         this._nativeHandle = Native.IncrementalMac_Initialize(key, chunkSizeInBytes(sizeChoice));
     }
     getFinalDigest() {
-        return Buffer.concat(this._digests);
+        // Use Buffer.concat for convenience, but return a proper Uint8Array, both for the correct type
+        // and to make an independent copy of a possibly-reused buffer.
+        return new Uint8Array(Buffer.concat(this._digests));
     }
     _write(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export * from './Errors';
 import { Aci, ProtocolAddress, ServiceId } from './Address';
 export * from './Address';
@@ -30,13 +29,13 @@ export declare enum UsePQRatchet {
     No = 1
 }
 export type Uuid = string;
-export declare function hkdf(outputLength: number, keyMaterial: Buffer, label: Buffer, salt: Buffer | null): Buffer;
+export declare function hkdf(outputLength: number, keyMaterial: Uint8Array, label: Uint8Array, salt: Uint8Array | null): Uint8Array;
 export declare class ScannableFingerprint {
     private readonly scannable;
     private constructor();
-    static _fromBuffer(scannable: Buffer): ScannableFingerprint;
+    static _fromBuffer(scannable: Uint8Array): ScannableFingerprint;
     compare(other: ScannableFingerprint): boolean;
-    toBuffer(): Buffer;
+    toBuffer(): Uint8Array;
 }
 export declare class DisplayableFingerprint {
     private readonly display;
@@ -47,30 +46,30 @@ export declare class DisplayableFingerprint {
 export declare class Fingerprint {
     readonly _nativeHandle: Native.Fingerprint;
     private constructor();
-    static new(iterations: number, version: number, localIdentifier: Buffer, localKey: PublicKey, remoteIdentifier: Buffer, remoteKey: PublicKey): Fingerprint;
+    static new(iterations: number, version: number, localIdentifier: Uint8Array, localKey: PublicKey, remoteIdentifier: Uint8Array, remoteKey: PublicKey): Fingerprint;
     displayableFingerprint(): DisplayableFingerprint;
     scannableFingerprint(): ScannableFingerprint;
 }
 export declare class Aes256GcmSiv {
     readonly _nativeHandle: Native.Aes256GcmSiv;
     private constructor();
-    static new(key: Buffer): Aes256GcmSiv;
-    encrypt(message: Buffer, nonce: Buffer, associated_data: Buffer): Buffer;
-    decrypt(message: Buffer, nonce: Buffer, associated_data: Buffer): Buffer;
+    static new(key: Uint8Array): Aes256GcmSiv;
+    encrypt(message: Uint8Array, nonce: Uint8Array, associated_data: Uint8Array): Uint8Array;
+    decrypt(message: Uint8Array, nonce: Uint8Array, associated_data: Uint8Array): Uint8Array;
 }
 export declare class KEMPublicKey {
     readonly _nativeHandle: Native.KyberPublicKey;
     private constructor();
     static _fromNativeHandle(handle: Native.KyberPublicKey): KEMPublicKey;
-    static deserialize(buf: Buffer): KEMPublicKey;
-    serialize(): Buffer;
+    static deserialize(buf: Uint8Array): KEMPublicKey;
+    serialize(): Uint8Array;
 }
 export declare class KEMSecretKey {
     readonly _nativeHandle: Native.KyberSecretKey;
     private constructor();
     static _fromNativeHandle(handle: Native.KyberSecretKey): KEMSecretKey;
-    static deserialize(buf: Buffer): KEMSecretKey;
-    serialize(): Buffer;
+    static deserialize(buf: Uint8Array): KEMSecretKey;
+    serialize(): Uint8Array;
 }
 export declare class KEMKeyPair {
     readonly _nativeHandle: Native.KyberKeyPair;
@@ -84,18 +83,18 @@ export declare class KEMKeyPair {
 export type SignedPublicPreKey = {
     id(): number;
     publicKey(): PublicKey;
-    signature(): Buffer;
+    signature(): Uint8Array;
 };
 /** The public information contained in a {@link KyberPreKeyRecord} */
 export type SignedKyberPublicPreKey = {
     id(): number;
     publicKey(): KEMPublicKey;
-    signature(): Buffer;
+    signature(): Uint8Array;
 };
 export declare class PreKeyBundle {
     readonly _nativeHandle: Native.PreKeyBundle;
     private constructor();
-    static new(registration_id: number, device_id: number, prekey_id: number | null, prekey: PublicKey | null, signed_prekey_id: number, signed_prekey: PublicKey, signed_prekey_signature: Buffer, identity_key: PublicKey, kyber_prekey_id: number, kyber_prekey: KEMPublicKey, kyber_prekey_signature: Buffer): PreKeyBundle;
+    static new(registration_id: number, device_id: number, prekey_id: number | null, prekey: PublicKey | null, signed_prekey_id: number, signed_prekey: PublicKey, signed_prekey_signature: Uint8Array, identity_key: PublicKey, kyber_prekey_id: number, kyber_prekey: KEMPublicKey, kyber_prekey_signature: Uint8Array): PreKeyBundle;
     deviceId(): number;
     identityKey(): PublicKey;
     preKeyId(): number | null;
@@ -103,78 +102,78 @@ export declare class PreKeyBundle {
     registrationId(): number;
     signedPreKeyId(): number;
     signedPreKeyPublic(): PublicKey;
-    signedPreKeySignature(): Buffer;
+    signedPreKeySignature(): Uint8Array;
     kyberPreKeyId(): number;
     kyberPreKeyPublic(): KEMPublicKey;
-    kyberPreKeySignature(): Buffer;
+    kyberPreKeySignature(): Uint8Array;
 }
 export declare class PreKeyRecord {
     readonly _nativeHandle: Native.PreKeyRecord;
     private constructor();
     static _fromNativeHandle(nativeHandle: Native.PreKeyRecord): PreKeyRecord;
     static new(id: number, pubKey: PublicKey, privKey: PrivateKey): PreKeyRecord;
-    static deserialize(buffer: Buffer): PreKeyRecord;
+    static deserialize(buffer: Uint8Array): PreKeyRecord;
     id(): number;
     privateKey(): PrivateKey;
     publicKey(): PublicKey;
-    serialize(): Buffer;
+    serialize(): Uint8Array;
 }
 export declare class SignedPreKeyRecord implements SignedPublicPreKey {
     readonly _nativeHandle: Native.SignedPreKeyRecord;
     private constructor();
     static _fromNativeHandle(nativeHandle: Native.SignedPreKeyRecord): SignedPreKeyRecord;
-    static new(id: number, timestamp: number, pubKey: PublicKey, privKey: PrivateKey, signature: Buffer): SignedPreKeyRecord;
-    static deserialize(buffer: Buffer): SignedPreKeyRecord;
+    static new(id: number, timestamp: number, pubKey: PublicKey, privKey: PrivateKey, signature: Uint8Array): SignedPreKeyRecord;
+    static deserialize(buffer: Uint8Array): SignedPreKeyRecord;
     id(): number;
     privateKey(): PrivateKey;
     publicKey(): PublicKey;
-    serialize(): Buffer;
-    signature(): Buffer;
+    serialize(): Uint8Array;
+    signature(): Uint8Array;
     timestamp(): number;
 }
 export declare class KyberPreKeyRecord implements SignedKyberPublicPreKey {
     readonly _nativeHandle: Native.KyberPreKeyRecord;
     private constructor();
     static _fromNativeHandle(nativeHandle: Native.KyberPreKeyRecord): KyberPreKeyRecord;
-    static new(id: number, timestamp: number, keyPair: KEMKeyPair, signature: Buffer): KyberPreKeyRecord;
-    serialize(): Buffer;
-    static deserialize(buffer: Buffer): KyberPreKeyRecord;
+    static new(id: number, timestamp: number, keyPair: KEMKeyPair, signature: Uint8Array): KyberPreKeyRecord;
+    serialize(): Uint8Array;
+    static deserialize(buffer: Uint8Array): KyberPreKeyRecord;
     id(): number;
     keyPair(): KEMKeyPair;
     publicKey(): KEMPublicKey;
     secretKey(): KEMSecretKey;
-    signature(): Buffer;
+    signature(): Uint8Array;
     timestamp(): number;
 }
 export declare class SignalMessage {
     readonly _nativeHandle: Native.SignalMessage;
     private constructor();
-    static _new(messageVersion: number, macKey: Buffer, senderRatchetKey: PublicKey, counter: number, previousCounter: number, ciphertext: Buffer, senderIdentityKey: PublicKey, receiverIdentityKey: PublicKey, pqRatchet: Buffer): SignalMessage;
-    static deserialize(buffer: Buffer): SignalMessage;
-    body(): Buffer;
-    pqRatchet(): Buffer;
+    static _new(messageVersion: number, macKey: Uint8Array, senderRatchetKey: PublicKey, counter: number, previousCounter: number, ciphertext: Uint8Array, senderIdentityKey: PublicKey, receiverIdentityKey: PublicKey, pqRatchet: Uint8Array): SignalMessage;
+    static deserialize(buffer: Uint8Array): SignalMessage;
+    body(): Uint8Array;
+    pqRatchet(): Uint8Array;
     counter(): number;
     messageVersion(): number;
-    serialize(): Buffer;
-    verifyMac(senderIdentityKey: PublicKey, recevierIdentityKey: PublicKey, macKey: Buffer): boolean;
+    serialize(): Uint8Array;
+    verifyMac(senderIdentityKey: PublicKey, recevierIdentityKey: PublicKey, macKey: Uint8Array): boolean;
 }
 export declare class PreKeySignalMessage {
     readonly _nativeHandle: Native.PreKeySignalMessage;
     private constructor();
     static _new(messageVersion: number, registrationId: number, preKeyId: number | null, signedPreKeyId: number, baseKey: PublicKey, identityKey: PublicKey, signalMessage: SignalMessage): PreKeySignalMessage;
-    static deserialize(buffer: Buffer): PreKeySignalMessage;
+    static deserialize(buffer: Uint8Array): PreKeySignalMessage;
     preKeyId(): number | null;
     registrationId(): number;
     signedPreKeyId(): number;
     version(): number;
-    serialize(): Buffer;
+    serialize(): Uint8Array;
 }
 export declare class SessionRecord {
     readonly _nativeHandle: Native.SessionRecord;
     private constructor();
     static _fromNativeHandle(nativeHandle: Native.SessionRecord): SessionRecord;
-    static deserialize(buffer: Buffer): SessionRecord;
-    serialize(): Buffer;
+    static deserialize(buffer: Uint8Array): SessionRecord;
+    serialize(): Uint8Array;
     archiveCurrentState(): void;
     localRegistrationId(): number;
     remoteRegistrationId(): number;
@@ -191,28 +190,28 @@ export declare class ServerCertificate {
     static _fromNativeHandle(nativeHandle: Native.ServerCertificate): ServerCertificate;
     private constructor();
     static new(keyId: number, serverKey: PublicKey, trustRoot: PrivateKey): ServerCertificate;
-    static deserialize(buffer: Buffer): ServerCertificate;
-    certificateData(): Buffer;
+    static deserialize(buffer: Uint8Array): ServerCertificate;
+    certificateData(): Uint8Array;
     key(): PublicKey;
     keyId(): number;
-    serialize(): Buffer;
-    signature(): Buffer;
+    serialize(): Uint8Array;
+    signature(): Uint8Array;
 }
 export declare class SenderKeyRecord {
     readonly _nativeHandle: Native.SenderKeyRecord;
     static _fromNativeHandle(nativeHandle: Native.SenderKeyRecord): SenderKeyRecord;
     private constructor();
-    static deserialize(buffer: Buffer): SenderKeyRecord;
-    serialize(): Buffer;
+    static deserialize(buffer: Uint8Array): SenderKeyRecord;
+    serialize(): Uint8Array;
 }
 export declare class SenderCertificate {
     readonly _nativeHandle: Native.SenderCertificate;
     private constructor();
     static _fromNativeHandle(nativeHandle: Native.SenderCertificate): SenderCertificate;
     static new(senderUuid: string | Aci, senderE164: string | null, senderDeviceId: number, senderKey: PublicKey, expiration: number, signerCert: ServerCertificate, signerKey: PrivateKey): SenderCertificate;
-    static deserialize(buffer: Buffer): SenderCertificate;
-    serialize(): Buffer;
-    certificate(): Buffer;
+    static deserialize(buffer: Uint8Array): SenderCertificate;
+    serialize(): Uint8Array;
+    certificate(): Uint8Array;
     expiration(): number;
     key(): PublicKey;
     senderE164(): string | null;
@@ -225,17 +224,17 @@ export declare class SenderCertificate {
     senderAci(): Aci | null;
     senderDeviceId(): number;
     serverCertificate(): ServerCertificate;
-    signature(): Buffer;
+    signature(): Uint8Array;
     validate(trustRoot: PublicKey, time: number): boolean;
 }
 export declare class SenderKeyDistributionMessage {
     readonly _nativeHandle: Native.SenderKeyDistributionMessage;
     private constructor();
     static create(sender: ProtocolAddress, distributionId: Uuid, store: SenderKeyStore): Promise<SenderKeyDistributionMessage>;
-    static _new(messageVersion: number, distributionId: Uuid, chainId: number, iteration: number, chainKey: Buffer, pk: PublicKey): SenderKeyDistributionMessage;
-    static deserialize(buffer: Buffer): SenderKeyDistributionMessage;
-    serialize(): Buffer;
-    chainKey(): Buffer;
+    static _new(messageVersion: number, distributionId: Uuid, chainId: number, iteration: number, chainKey: Uint8Array, pk: PublicKey): SenderKeyDistributionMessage;
+    static deserialize(buffer: Uint8Array): SenderKeyDistributionMessage;
+    serialize(): Uint8Array;
+    chainKey(): Uint8Array;
     iteration(): number;
     chainId(): number;
     distributionId(): Uuid;
@@ -244,10 +243,10 @@ export declare function processSenderKeyDistributionMessage(sender: ProtocolAddr
 export declare class SenderKeyMessage {
     readonly _nativeHandle: Native.SenderKeyMessage;
     private constructor();
-    static _new(messageVersion: number, distributionId: Uuid, chainId: number, iteration: number, ciphertext: Buffer, pk: PrivateKey): SenderKeyMessage;
-    static deserialize(buffer: Buffer): SenderKeyMessage;
-    serialize(): Buffer;
-    ciphertext(): Buffer;
+    static _new(messageVersion: number, distributionId: Uuid, chainId: number, iteration: number, ciphertext: Uint8Array, pk: PrivateKey): SenderKeyMessage;
+    static deserialize(buffer: Uint8Array): SenderKeyMessage;
+    serialize(): Uint8Array;
+    ciphertext(): Uint8Array;
     iteration(): number;
     chainId(): number;
     distributionId(): Uuid;
@@ -257,14 +256,14 @@ export declare class UnidentifiedSenderMessageContent {
     readonly _nativeHandle: Native.UnidentifiedSenderMessageContent;
     private constructor();
     static _fromNativeHandle(nativeHandle: Native.UnidentifiedSenderMessageContent): UnidentifiedSenderMessageContent;
-    static new(message: CiphertextMessage, sender: SenderCertificate, contentHint: number, groupId: Buffer | null): UnidentifiedSenderMessageContent;
-    static deserialize(buffer: Buffer): UnidentifiedSenderMessageContent;
-    serialize(): Buffer;
-    contents(): Buffer;
+    static new(message: CiphertextMessage, sender: SenderCertificate, contentHint: number, groupId: Uint8Array | null): UnidentifiedSenderMessageContent;
+    static deserialize(buffer: Uint8Array): UnidentifiedSenderMessageContent;
+    serialize(): Uint8Array;
+    contents(): Uint8Array;
     msgType(): number;
     senderCertificate(): SenderCertificate;
     contentHint(): number;
-    groupId(): Buffer | null;
+    groupId(): Uint8Array | null;
 }
 export declare abstract class SessionStore implements Native.SessionStore {
     _saveSession(name: Native.ProtocolAddress, record: Native.SessionRecord): Promise<void>;
@@ -317,13 +316,13 @@ export declare abstract class SenderKeyStore implements Native.SenderKeyStore {
     abstract saveSenderKey(sender: ProtocolAddress, distributionId: Uuid, record: SenderKeyRecord): Promise<void>;
     abstract getSenderKey(sender: ProtocolAddress, distributionId: Uuid): Promise<SenderKeyRecord | null>;
 }
-export declare function groupEncrypt(sender: ProtocolAddress, distributionId: Uuid, store: SenderKeyStore, message: Buffer): Promise<CiphertextMessage>;
-export declare function groupDecrypt(sender: ProtocolAddress, store: SenderKeyStore, message: Buffer): Promise<Buffer>;
+export declare function groupEncrypt(sender: ProtocolAddress, distributionId: Uuid, store: SenderKeyStore, message: Uint8Array): Promise<CiphertextMessage>;
+export declare function groupDecrypt(sender: ProtocolAddress, store: SenderKeyStore, message: Uint8Array): Promise<Uint8Array>;
 export declare class SealedSenderDecryptionResult {
     readonly _nativeHandle: Native.SealedSenderDecryptionResult;
     private constructor();
     static _fromNativeHandle(nativeHandle: Native.SealedSenderDecryptionResult): SealedSenderDecryptionResult;
-    message(): Buffer;
+    message(): Uint8Array;
     senderE164(): string | null;
     senderUuid(): string;
     /**
@@ -342,36 +341,36 @@ export declare class CiphertextMessage {
     private constructor();
     static _fromNativeHandle(nativeHandle: Native.CiphertextMessage): CiphertextMessage;
     static from(message: CiphertextMessageConvertible): CiphertextMessage;
-    serialize(): Buffer;
+    serialize(): Uint8Array;
     type(): number;
 }
 export declare class PlaintextContent implements CiphertextMessageConvertible {
     readonly _nativeHandle: Native.PlaintextContent;
     private constructor();
-    static deserialize(buffer: Buffer): PlaintextContent;
+    static deserialize(buffer: Uint8Array): PlaintextContent;
     static from(message: DecryptionErrorMessage): PlaintextContent;
-    serialize(): Buffer;
-    body(): Buffer;
+    serialize(): Uint8Array;
+    body(): Uint8Array;
     asCiphertextMessage(): CiphertextMessage;
 }
 export declare class DecryptionErrorMessage {
     readonly _nativeHandle: Native.DecryptionErrorMessage;
     private constructor();
     static _fromNativeHandle(nativeHandle: Native.DecryptionErrorMessage): DecryptionErrorMessage;
-    static forOriginal(bytes: Buffer, type: CiphertextMessageType, timestamp: number, originalSenderDeviceId: number): DecryptionErrorMessage;
-    static deserialize(buffer: Buffer): DecryptionErrorMessage;
-    static extractFromSerializedBody(buffer: Buffer): DecryptionErrorMessage;
-    serialize(): Buffer;
+    static forOriginal(bytes: Uint8Array, type: CiphertextMessageType, timestamp: number, originalSenderDeviceId: number): DecryptionErrorMessage;
+    static deserialize(buffer: Uint8Array): DecryptionErrorMessage;
+    static extractFromSerializedBody(buffer: Uint8Array): DecryptionErrorMessage;
+    serialize(): Uint8Array;
     timestamp(): number;
     deviceId(): number;
     ratchetKey(): PublicKey | undefined;
 }
 export declare function processPreKeyBundle(bundle: PreKeyBundle, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore, usePqRatchet: UsePQRatchet, now?: Date): Promise<void>;
-export declare function signalEncrypt(message: Buffer, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore, now?: Date): Promise<CiphertextMessage>;
-export declare function signalDecrypt(message: SignalMessage, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<Buffer>;
-export declare function signalDecryptPreKey(message: PreKeySignalMessage, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore, kyberPrekeyStore: KyberPreKeyStore, usePqRatchet: UsePQRatchet): Promise<Buffer>;
-export declare function sealedSenderEncryptMessage(message: Buffer, address: ProtocolAddress, senderCert: SenderCertificate, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<Buffer>;
-export declare function sealedSenderEncrypt(content: UnidentifiedSenderMessageContent, address: ProtocolAddress, identityStore: IdentityKeyStore): Promise<Buffer>;
+export declare function signalEncrypt(message: Uint8Array, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore, now?: Date): Promise<CiphertextMessage>;
+export declare function signalDecrypt(message: SignalMessage, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<Uint8Array>;
+export declare function signalDecryptPreKey(message: PreKeySignalMessage, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore, kyberPrekeyStore: KyberPreKeyStore, usePqRatchet: UsePQRatchet): Promise<Uint8Array>;
+export declare function sealedSenderEncryptMessage(message: Uint8Array, address: ProtocolAddress, senderCert: SenderCertificate, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<Uint8Array>;
+export declare function sealedSenderEncrypt(content: UnidentifiedSenderMessageContent, address: ProtocolAddress, identityStore: IdentityKeyStore): Promise<Uint8Array>;
 export type SealedSenderMultiRecipientEncryptOptions = {
     content: UnidentifiedSenderMessageContent;
     recipients: ProtocolAddress[];
@@ -379,28 +378,28 @@ export type SealedSenderMultiRecipientEncryptOptions = {
     identityStore: IdentityKeyStore;
     sessionStore: SessionStore;
 };
-export declare function sealedSenderMultiRecipientEncrypt(options: SealedSenderMultiRecipientEncryptOptions): Promise<Buffer>;
-export declare function sealedSenderMultiRecipientEncrypt(content: UnidentifiedSenderMessageContent, recipients: ProtocolAddress[], identityStore: IdentityKeyStore, sessionStore: SessionStore): Promise<Buffer>;
-export declare function sealedSenderMultiRecipientMessageForSingleRecipient(message: Buffer): Buffer;
-export declare function sealedSenderDecryptMessage(message: Buffer, trustRoot: PublicKey, timestamp: number, localE164: string | null, localUuid: string, localDeviceId: number, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore, kyberPrekeyStore: KyberPreKeyStore, usePqRatchet: UsePQRatchet): Promise<SealedSenderDecryptionResult>;
-export declare function sealedSenderDecryptToUsmc(message: Buffer, identityStore: IdentityKeyStore): Promise<UnidentifiedSenderMessageContent>;
+export declare function sealedSenderMultiRecipientEncrypt(options: SealedSenderMultiRecipientEncryptOptions): Promise<Uint8Array>;
+export declare function sealedSenderMultiRecipientEncrypt(content: UnidentifiedSenderMessageContent, recipients: ProtocolAddress[], identityStore: IdentityKeyStore, sessionStore: SessionStore): Promise<Uint8Array>;
+export declare function sealedSenderMultiRecipientMessageForSingleRecipient(message: Uint8Array): Uint8Array;
+export declare function sealedSenderDecryptMessage(message: Uint8Array, trustRoot: PublicKey, timestamp: number, localE164: string | null, localUuid: string, localDeviceId: number, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore, kyberPrekeyStore: KyberPreKeyStore, usePqRatchet: UsePQRatchet): Promise<SealedSenderDecryptionResult>;
+export declare function sealedSenderDecryptToUsmc(message: Uint8Array, identityStore: IdentityKeyStore): Promise<UnidentifiedSenderMessageContent>;
 export declare class Cds2Client {
     readonly _nativeHandle: Native.SgxClientState;
     private constructor();
-    static new(mrenclave: Buffer, attestationMsg: Buffer, currentTimestamp: Date): Cds2Client;
-    initialRequest(): Buffer;
-    completeHandshake(buffer: Buffer): void;
-    establishedSend(buffer: Buffer): Buffer;
-    establishedRecv(buffer: Buffer): Buffer;
+    static new(mrenclave: Uint8Array, attestationMsg: Uint8Array, currentTimestamp: Date): Cds2Client;
+    initialRequest(): Uint8Array;
+    completeHandshake(buffer: Uint8Array): void;
+    establishedSend(buffer: Uint8Array): Uint8Array;
+    establishedRecv(buffer: Uint8Array): Uint8Array;
 }
 export declare class HsmEnclaveClient {
     readonly _nativeHandle: Native.HsmEnclaveClient;
     private constructor();
-    static new(public_key: Buffer, code_hashes: Buffer[]): HsmEnclaveClient;
-    initialRequest(): Buffer;
-    completeHandshake(buffer: Buffer): void;
-    establishedSend(buffer: Buffer): Buffer;
-    establishedRecv(buffer: Buffer): Buffer;
+    static new(public_key: Uint8Array, code_hashes: Uint8Array[]): HsmEnclaveClient;
+    initialRequest(): Uint8Array;
+    completeHandshake(buffer: Uint8Array): void;
+    establishedSend(buffer: Uint8Array): Uint8Array;
+    establishedRecv(buffer: Uint8Array): Uint8Array;
 }
 export declare enum LogLevel {
     Error = 1,

package/dist/index.js

@@ -515,11 +515,11 @@ class SenderKeyDistributionMessage {
         this._nativeHandle = nativeHandle;
     }
     static async create(sender, distributionId, store) {
-        const handle = await Native.SenderKeyDistributionMessage_Create(sender, Buffer.from(uuid.parse(distributionId)), store);
+        const handle = await Native.SenderKeyDistributionMessage_Create(sender, uuid.parse(distributionId), store);
         return new SenderKeyDistributionMessage(handle);
     }
     static _new(messageVersion, distributionId, chainId, iteration, chainKey, pk) {
-        return new SenderKeyDistributionMessage(Native.SenderKeyDistributionMessage_New(messageVersion, Buffer.from(uuid.parse(distributionId)), chainId, iteration, chainKey, pk));
+        return new SenderKeyDistributionMessage(Native.SenderKeyDistributionMessage_New(messageVersion, uuid.parse(distributionId), chainId, iteration, chainKey, pk));
     }
     static deserialize(buffer) {
         return new SenderKeyDistributionMessage(Native.SenderKeyDistributionMessage_Deserialize(buffer));
@@ -550,7 +550,7 @@ class SenderKeyMessage {
         this._nativeHandle = nativeHandle;
     }
     static _new(messageVersion, distributionId, chainId, iteration, ciphertext, pk) {
-        return new SenderKeyMessage(Native.SenderKeyMessage_New(messageVersion, Buffer.from(uuid.parse(distributionId)), chainId, iteration, ciphertext, pk));
+        return new SenderKeyMessage(Native.SenderKeyMessage_New(messageVersion, uuid.parse(distributionId), chainId, iteration, ciphertext, pk));
     }
     static deserialize(buffer) {
         return new SenderKeyMessage(Native.SenderKeyMessage_Deserialize(buffer));
@@ -707,7 +707,7 @@ class SenderKeyStore {
 }
 exports.SenderKeyStore = SenderKeyStore;
 async function groupEncrypt(sender, distributionId, store, message) {
-    return CiphertextMessage._fromNativeHandle(await Native.GroupCipher_EncryptMessage(sender, Buffer.from(uuid.parse(distributionId)), message, store));
+    return CiphertextMessage._fromNativeHandle(await Native.GroupCipher_EncryptMessage(sender, uuid.parse(distributionId), message, store));
 }
 exports.groupEncrypt = groupEncrypt;
 async function groupDecrypt(sender, store, message) {

package/dist/io.d.ts

@@ -1,11 +1,9 @@
-/// <reference types="node" />
 import * as Native from '../Native';
-import type { Buffer } from 'node:buffer';
 /**
  * An abstract class representing an input stream of bytes.
  */
 export declare abstract class InputStream implements Native.InputStream {
-    _read(amount: number): Promise<Buffer>;
+    _read(amount: number): Promise<Uint8Array>;
     _skip(amount: number): Promise<void>;
     /**
      * Called to indicate the stream's resources should be released.
@@ -20,10 +18,10 @@ export declare abstract class InputStream implements Native.InputStream {
      * however, returning zero bytes always indicates that the end of the stream has been reached.
      *
      * @param amount The amount of bytes to read.
-     * @returns A promise yielding a {@link Buffer} containing the read bytes.
+     * @returns A promise yielding a {@link Uint8Array} containing the read bytes.
      * @throws {IoError} If an I/O error occurred while reading from the input.
      */
-    abstract read(amount: number): Promise<Buffer>;
+    abstract read(amount: number): Promise<Uint8Array>;
     /**
      * Skip an amount of bytes in the input stream.
      *

package/dist/net/Chat.d.ts

@@ -1,8 +1,6 @@
-/// <reference types="node" />
 import * as Native from '../../Native';
 import { LibSignalError } from '../Errors';
 import { Wrapper } from '../../Native';
-import { Buffer } from 'node:buffer';
 import { TokioAsyncContext, Environment } from '../net';
 import * as KT from './KeyTransparency';
 export type ChatRequest = Readonly<{
@@ -37,7 +35,7 @@ export interface ChatServiceListener extends ConnectionEventsListener {
      * If `ack`'s `send` method is not called, the server will leave this message in the message
      * queue and attempt to deliver it again in the future.
      */
-    onIncomingMessage(envelope: Buffer, timestamp: number, ack: ChatServerMessageAck): void;
+    onIncomingMessage(envelope: Uint8Array, timestamp: number, ack: ChatServerMessageAck): void;
     /**
      * Called when the server indicates that there are no further messages in the message queue.
      *

package/dist/net/Chat.js

@@ -6,7 +6,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildHttpRequest = exports.AuthenticatedChatConnection = exports.UnauthenticatedChatConnection = exports.ChatServerMessageAck = void 0;
 const Native = require("../../Native");
-const node_buffer_1 = require("node:buffer");
 const KT = require("./KeyTransparency");
 const internal_1 = require("../internal");
 const DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS = 5000;
@@ -209,9 +208,8 @@ function makeNativeChatListener(asyncContext, listener) {
 }
 function buildHttpRequest(chatRequest) {
     const { verb, path, body, headers } = chatRequest;
-    const bodyBuffer = body !== undefined ? node_buffer_1.Buffer.from(body) : null;
     const httpRequest = {
-        _nativeHandle: Native.HttpRequest_new(verb, path, bodyBuffer),
+        _nativeHandle: Native.HttpRequest_new(verb, path, body ?? null),
     };
     headers.forEach((header) => {
         const [name, value] = header;

package/dist/net/KeyTransparency.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import * as Native from '../../Native';
 import { Aci } from '../Address';
 import { PublicKey } from '../EcKeys';
@@ -10,10 +9,10 @@ import { Environment, type TokioAsyncContext } from '../net';
  * used by the {@link Client}.
  */
 export interface Store {
-    getLastDistinguishedTreeHead(): Promise<Buffer | null>;
-    setLastDistinguishedTreeHead(bytes: Readonly<Buffer> | null): Promise<void>;
-    getAccountData(aci: Aci): Promise<Buffer | null>;
-    setAccountData(aci: Aci, bytes: Readonly<Buffer>): Promise<void>;
+    getLastDistinguishedTreeHead(): Promise<Uint8Array | null>;
+    setLastDistinguishedTreeHead(bytes: Readonly<Uint8Array> | null): Promise<void>;
+    getAccountData(aci: Aci): Promise<Uint8Array | null>;
+    setAccountData(aci: Aci, bytes: Readonly<Uint8Array>): Promise<void>;
 }
 /**
  * Options that are accepted by all {@link Client} APIs.
@@ -35,7 +34,7 @@ export type AciInfo = {
  */
 export type E164Info = {
     e164: string;
-    unidentifiedAccessKey: Readonly<Buffer>;
+    unidentifiedAccessKey: Readonly<Uint8Array>;
 };
 /**
  * Key transparency client request
@@ -46,7 +45,7 @@ export type Request = {
     aciInfo: AciInfo;
     /** Unidentified access key associated with the account. Optional. */
     e164Info?: E164Info;
-    usernameHash?: Readonly<Buffer>;
+    usernameHash?: Readonly<Uint8Array>;
 };
 /**
  * Typed API to access the key transparency subsystem using an existing

package/dist/net/Registration.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { ReadonlyDeep } from 'type-fest';
 import * as Native from '../../Native';
 import { type TokioAsyncContext } from '../net';
@@ -145,8 +144,8 @@ export declare class RegisterAccountResponse {
     get aci(): Aci;
     get pni(): Pni;
     get number(): string;
-    get usernameHash(): Buffer | null;
-    get usernameLinkHandle(): Buffer | null;
+    get usernameHash(): Uint8Array | null;
+    get usernameLinkHandle(): Uint8Array | null;
     get backupEntitlement(): {
         backupLevel: bigint;
         expirationSeconds: bigint;

package/dist/net/Registration.js

@@ -141,7 +141,7 @@ function toBridgedPublicPreKey(key) {
 class AccountAttributes {
     constructor({ recoveryPassword, aciRegistrationId, pniRegistrationId, registrationLock, unidentifiedAccessKey, unrestrictedUnidentifiedAccess, capabilities, discoverableByPhoneNumber, }) {
         const capabilitiesArray = Array.from(capabilities);
-        this._nativeHandle = Native.RegistrationAccountAttributes_Create(Buffer.from(recoveryPassword), aciRegistrationId, pniRegistrationId, registrationLock, Buffer.from(unidentifiedAccessKey), unrestrictedUnidentifiedAccess, capabilitiesArray, discoverableByPhoneNumber);
+        this._nativeHandle = Native.RegistrationAccountAttributes_Create(recoveryPassword, aciRegistrationId, pniRegistrationId, registrationLock, unidentifiedAccessKey, unrestrictedUnidentifiedAccess, capabilitiesArray, discoverableByPhoneNumber);
     }
 }
 exports.AccountAttributes = AccountAttributes;

package/dist/net.d.ts

@@ -1,7 +1,5 @@
-/// <reference types="node" />
 import type { ReadonlyDeep } from 'type-fest';
 import * as Native from '../Native';
-import { Buffer } from 'node:buffer';
 import { CDSRequestOptionsType, CDSResponseType } from './net/CDSI';
 import { ConnectionEventsListener, UnauthenticatedChatConnection, AuthenticatedChatConnection, ChatServiceListener } from './net/Chat';
 import { RegistrationService } from './net/Registration';
@@ -41,7 +39,7 @@ export type NetConstructorOptions = Readonly<{
     TESTING_localServer_chatPort: number;
     TESTING_localServer_cdsiPort: number;
     TESTING_localServer_svr2Port: number;
-    TESTING_localServer_rootCertificateDer: Buffer;
+    TESTING_localServer_rootCertificateDer: Uint8Array;
 }>;
 /** See {@link Net.setProxy()}. */
 export type ProxyOptions = {

package/dist/usernames.d.ts

@@ -1,16 +1,15 @@
-/// <reference types="node" />
 export type UsernameLink = {
-    entropy: Buffer;
-    encryptedUsername: Buffer;
+    entropy: Uint8Array;
+    encryptedUsername: Uint8Array;
 };
 export declare function generateCandidates(nickname: string, minNicknameLength: number, maxNicknameLength: number): string[];
 export declare function fromParts(nickname: string, discriminator: string, minNicknameLength: number, maxNicknameLength: number): {
     username: string;
-    hash: Buffer;
+    hash: Uint8Array;
 };
-export declare function hash(username: string): Buffer;
-export declare function generateProof(username: string): Buffer;
-export declare function generateProofWithRandom(username: string, random: Buffer): Buffer;
+export declare function hash(username: string): Uint8Array;
+export declare function generateProof(username: string): Uint8Array;
+export declare function generateProofWithRandom(username: string, random: Uint8Array): Uint8Array;
 export declare function decryptUsernameLink(usernameLink: UsernameLink): string;
-export declare function createUsernameLink(username: string, previousEntropy?: Buffer): UsernameLink;
-export declare function verifyProof(proof: Buffer, hash: Buffer): void;
+export declare function createUsernameLink(username: string, previousEntropy?: Uint8Array): UsernameLink;
+export declare function verifyProof(proof: Uint8Array, hash: Uint8Array): void;