@signalapp/libsignal-client 0.30.1 → 0.31.0

package/Native.d.ts

@@ -117,8 +117,8 @@ export function GenericServerPublicParams_CheckValidContents(paramsBytes: Buffer
 export function GenericServerSecretParams_CheckValidContents(paramsBytes: Buffer): void;
 export function GenericServerSecretParams_GenerateDeterministic(randomness: Buffer): Buffer;
 export function GenericServerSecretParams_GetPublicParams(paramsBytes: Buffer): Buffer;
-export function GroupCipher_DecryptMessage(sender: Wrapper<ProtocolAddress>, message: Buffer, store: SenderKeyStore, ctx: null): Promise<Buffer>;
-export function GroupCipher_EncryptMessage(sender: Wrapper<ProtocolAddress>, distributionId: Uuid, message: Buffer, store: SenderKeyStore, ctx: null): Promise<CiphertextMessage>;
+export function GroupCipher_DecryptMessage(sender: Wrapper<ProtocolAddress>, message: Buffer, store: SenderKeyStore): Promise<Buffer>;
+export function GroupCipher_EncryptMessage(sender: Wrapper<ProtocolAddress>, distributionId: Uuid, message: Buffer, store: SenderKeyStore): Promise<CiphertextMessage>;
 export function GroupMasterKey_CheckValidContents(buffer: Buffer): void;
 export function GroupPublicParams_CheckValidContents(buffer: Buffer): void;
 export function GroupPublicParams_GetGroupIdentifier(groupPublicParams: Serialized<GroupPublicParams>): Buffer;
@@ -241,9 +241,9 @@ export function SealedSenderDecryptionResult_GetSenderE164(obj: Wrapper<SealedSe
 export function SealedSenderDecryptionResult_GetSenderUuid(obj: Wrapper<SealedSenderDecryptionResult>): string;
 export function SealedSenderDecryptionResult_Message(obj: Wrapper<SealedSenderDecryptionResult>): Buffer;
 export function SealedSender_DecryptMessage(message: Buffer, trustRoot: Wrapper<PublicKey>, timestamp: Timestamp, localE164: string | null, localUuid: string, localDeviceId: number, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore, kyberPrekeyStore: KyberPreKeyStore): Promise<SealedSenderDecryptionResult>;
-export function SealedSender_DecryptToUsmc(ctext: Buffer, identityStore: IdentityKeyStore, ctx: null): Promise<UnidentifiedSenderMessageContent>;
-export function SealedSender_Encrypt(destination: Wrapper<ProtocolAddress>, content: Wrapper<UnidentifiedSenderMessageContent>, identityKeyStore: IdentityKeyStore, ctx: null): Promise<Buffer>;
-export function SealedSender_MultiRecipientEncrypt(recipients: Wrapper<ProtocolAddress>[], recipientSessions: Wrapper<SessionRecord>[], content: Wrapper<UnidentifiedSenderMessageContent>, identityKeyStore: IdentityKeyStore, ctx: null): Promise<Buffer>;
+export function SealedSender_DecryptToUsmc(ctext: Buffer, identityStore: IdentityKeyStore): Promise<UnidentifiedSenderMessageContent>;
+export function SealedSender_Encrypt(destination: Wrapper<ProtocolAddress>, content: Wrapper<UnidentifiedSenderMessageContent>, identityKeyStore: IdentityKeyStore): Promise<Buffer>;
+export function SealedSender_MultiRecipientEncrypt(recipients: Wrapper<ProtocolAddress>[], recipientSessions: Wrapper<SessionRecord>[], content: Wrapper<UnidentifiedSenderMessageContent>, identityKeyStore: IdentityKeyStore): Promise<Buffer>;
 export function SealedSender_MultiRecipientMessageForSingleRecipient(encodedMultiRecipientMessage: Buffer): Buffer;
 export function SenderCertificate_Deserialize(data: Buffer): SenderCertificate;
 export function SenderCertificate_GetCertificate(obj: Wrapper<SenderCertificate>): Buffer;
@@ -257,14 +257,14 @@ export function SenderCertificate_GetServerCertificate(cert: Wrapper<SenderCerti
 export function SenderCertificate_GetSignature(obj: Wrapper<SenderCertificate>): Buffer;
 export function SenderCertificate_New(senderUuid: string, senderE164: string | null, senderDeviceId: number, senderKey: Wrapper<PublicKey>, expiration: Timestamp, signerCert: Wrapper<ServerCertificate>, signerKey: Wrapper<PrivateKey>): SenderCertificate;
 export function SenderCertificate_Validate(cert: Wrapper<SenderCertificate>, key: Wrapper<PublicKey>, time: Timestamp): boolean;
-export function SenderKeyDistributionMessage_Create(sender: Wrapper<ProtocolAddress>, distributionId: Uuid, store: SenderKeyStore, ctx: null): Promise<SenderKeyDistributionMessage>;
+export function SenderKeyDistributionMessage_Create(sender: Wrapper<ProtocolAddress>, distributionId: Uuid, store: SenderKeyStore): Promise<SenderKeyDistributionMessage>;
 export function SenderKeyDistributionMessage_Deserialize(data: Buffer): SenderKeyDistributionMessage;
 export function SenderKeyDistributionMessage_GetChainId(obj: Wrapper<SenderKeyDistributionMessage>): number;
 export function SenderKeyDistributionMessage_GetChainKey(obj: Wrapper<SenderKeyDistributionMessage>): Buffer;
 export function SenderKeyDistributionMessage_GetDistributionId(obj: Wrapper<SenderKeyDistributionMessage>): Uuid;
 export function SenderKeyDistributionMessage_GetIteration(obj: Wrapper<SenderKeyDistributionMessage>): number;
 export function SenderKeyDistributionMessage_New(messageVersion: number, distributionId: Uuid, chainId: number, iteration: number, chainkey: Buffer, pk: Wrapper<PublicKey>): SenderKeyDistributionMessage;
-export function SenderKeyDistributionMessage_Process(sender: Wrapper<ProtocolAddress>, senderKeyDistributionMessage: Wrapper<SenderKeyDistributionMessage>, store: SenderKeyStore, ctx: null): Promise<void>;
+export function SenderKeyDistributionMessage_Process(sender: Wrapper<ProtocolAddress>, senderKeyDistributionMessage: Wrapper<SenderKeyDistributionMessage>, store: SenderKeyStore): Promise<void>;
 export function SenderKeyDistributionMessage_Serialize(obj: Wrapper<SenderKeyDistributionMessage>): Buffer;
 export function SenderKeyMessage_Deserialize(data: Buffer): SenderKeyMessage;
 export function SenderKeyMessage_GetChainId(obj: Wrapper<SenderKeyMessage>): number;
@@ -313,10 +313,10 @@ export function ServiceId_ParseFromServiceIdString(input: string): Buffer;
 export function ServiceId_ServiceIdBinary(value: Buffer): Buffer;
 export function ServiceId_ServiceIdLog(value: Buffer): string;
 export function ServiceId_ServiceIdString(value: Buffer): string;
-export function SessionBuilder_ProcessPreKeyBundle(bundle: Wrapper<PreKeyBundle>, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore, ctx: null): Promise<void>;
-export function SessionCipher_DecryptPreKeySignalMessage(message: Wrapper<PreKeySignalMessage>, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore, kyberPrekeyStore: KyberPreKeyStore, ctx: null): Promise<Buffer>;
-export function SessionCipher_DecryptSignalMessage(message: Wrapper<SignalMessage>, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore, ctx: null): Promise<Buffer>;
-export function SessionCipher_EncryptMessage(ptext: Buffer, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore, ctx: null): Promise<CiphertextMessage>;
+export function SessionBuilder_ProcessPreKeyBundle(bundle: Wrapper<PreKeyBundle>, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore): Promise<void>;
+export function SessionCipher_DecryptPreKeySignalMessage(message: Wrapper<PreKeySignalMessage>, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore, kyberPrekeyStore: KyberPreKeyStore): Promise<Buffer>;
+export function SessionCipher_DecryptSignalMessage(message: Wrapper<SignalMessage>, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore): Promise<Buffer>;
+export function SessionCipher_EncryptMessage(ptext: Buffer, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore): Promise<CiphertextMessage>;
 export function SessionRecord_ArchiveCurrentState(sessionRecord: Wrapper<SessionRecord>): void;
 export function SessionRecord_CurrentRatchetKeyMatches(s: Wrapper<SessionRecord>, key: Wrapper<PublicKey>): boolean;
 export function SessionRecord_Deserialize(data: Buffer): SessionRecord;

package/dist/Address.d.ts

@@ -4,20 +4,18 @@ declare enum ServiceIdKind {
     Aci = 0,
     Pni = 1
 }
-type ThisType<T extends {
-    prototype: unknown;
-}> = T['prototype'];
-export declare class ServiceId extends Object {
+export declare abstract class ServiceId extends Object {
     private readonly serviceIdFixedWidthBinary;
-    protected constructor(serviceIdFixedWidthBinary: Buffer);
-    protected static fromUuidBytesAndKind<T extends typeof ServiceId>(this: T, uuidBytes: ArrayLike<number>, kind: ServiceIdKind): ThisType<T>;
+    constructor(serviceIdFixedWidthBinary: Buffer);
+    protected static fromUuidBytesAndKind<T extends typeof ServiceId>(this: new (serviceIdFixedWidthBinary: Buffer) => InstanceType<T>, uuidBytes: ArrayLike<number>, kind: ServiceIdKind): InstanceType<T>;
     getServiceIdBinary(): Buffer;
     getServiceIdFixedWidthBinary(): Buffer;
     getServiceIdString(): string;
     toString(): string;
-    static parseFromServiceIdFixedWidthBinary<T extends typeof ServiceId>(this: T, serviceIdFixedWidthBinary: Buffer): ThisType<T>;
-    static parseFromServiceIdBinary(serviceIdBinary: Buffer): ServiceId;
-    static parseFromServiceIdString(serviceIdString: string): ServiceId;
+    private downcastTo;
+    static parseFromServiceIdFixedWidthBinary<T extends typeof ServiceId>(this: T, serviceIdFixedWidthBinary: Buffer): InstanceType<T>;
+    static parseFromServiceIdBinary<T extends typeof ServiceId>(this: T, serviceIdBinary: Buffer): InstanceType<T>;
+    static parseFromServiceIdString<T extends typeof ServiceId>(this: T, serviceIdString: string): InstanceType<T>;
     getRawUuid(): string;
     getRawUuidBytes(): Buffer;
     isEqual(other: ServiceId): boolean;

package/dist/Address.js

@@ -14,6 +14,7 @@ var ServiceIdKind;
 })(ServiceIdKind || (ServiceIdKind = {}));
 const SERVICE_ID_FIXED_WIDTH_BINARY_LEN = 17;
 class ServiceId extends Object {
+    // This has to be public for `InstanceType<T>`, which we use below.
     constructor(serviceIdFixedWidthBinary) {
         super();
         if (serviceIdFixedWidthBinary.length != SERVICE_ID_FIXED_WIDTH_BINARY_LEN) {
@@ -39,6 +40,13 @@ class ServiceId extends Object {
     toString() {
         return Native.ServiceId_ServiceIdLog(this.serviceIdFixedWidthBinary);
     }
+    downcastTo(subclass) {
+        // Omitting `as object` results in TypeScript mistakenly assuming the branch is always taken.
+        if (this instanceof subclass) {
+            return this;
+        }
+        throw new TypeError(`expected ${subclass.name}, got ${this.constructor.name}`);
+    }
     static parseFromServiceIdFixedWidthBinary(serviceIdFixedWidthBinary) {
         let result;
         switch (serviceIdFixedWidthBinary[0]) {
@@ -51,16 +59,15 @@ class ServiceId extends Object {
             default:
                 throw new TypeError('unknown type in Service-Id-FixedWidthBinary');
         }
-        if (result instanceof this) {
-            return result;
-        }
-        throw new TypeError(`expected ${this.name}, got ${result.constructor.name}`);
+        return result.downcastTo(this);
     }
     static parseFromServiceIdBinary(serviceIdBinary) {
-        return ServiceId.parseFromServiceIdFixedWidthBinary(Native.ServiceId_ParseFromServiceIdBinary(serviceIdBinary));
+        const result = ServiceId.parseFromServiceIdFixedWidthBinary(Native.ServiceId_ParseFromServiceIdBinary(serviceIdBinary));
+        return result.downcastTo(this);
     }
     static parseFromServiceIdString(serviceIdString) {
-        return ServiceId.parseFromServiceIdFixedWidthBinary(Native.ServiceId_ParseFromServiceIdString(serviceIdString));
+        const result = this.parseFromServiceIdFixedWidthBinary(Native.ServiceId_ParseFromServiceIdString(serviceIdString));
+        return result.downcastTo(this);
     }
     getRawUuid() {
         return uuid.stringify(this.serviceIdFixedWidthBinary, 1);
@@ -78,7 +85,7 @@ class Aci extends ServiceId {
         return this.fromUuidBytes(uuid.parse(uuidString));
     }
     static fromUuidBytes(uuidBytes) {
-        return super.fromUuidBytesAndKind(uuidBytes, ServiceIdKind.Aci);
+        return this.fromUuidBytesAndKind(uuidBytes, ServiceIdKind.Aci);
     }
 }
 exports.Aci = Aci;
@@ -87,7 +94,7 @@ class Pni extends ServiceId {
         return this.fromUuidBytes(uuid.parse(uuidString));
     }
     static fromUuidBytes(uuidBytes) {
-        return super.fromUuidBytesAndKind(uuidBytes, ServiceIdKind.Pni);
+        return this.fromUuidBytesAndKind(uuidBytes, ServiceIdKind.Pni);
     }
 }
 exports.Pni = Pni;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 export * from './Errors';
-import { ProtocolAddress } from './Address';
+import { Aci, ProtocolAddress } from './Address';
 export * from './Address';
 export * as usernames from './usernames';
 export * as io from './io';
@@ -221,7 +221,7 @@ export declare class SenderCertificate {
     readonly _nativeHandle: Native.SenderCertificate;
     private constructor();
     static _fromNativeHandle(nativeHandle: Native.SenderCertificate): SenderCertificate;
-    static new(senderUuid: string, senderE164: string | null, senderDeviceId: number, senderKey: PublicKey, expiration: number, signerCert: ServerCertificate, signerKey: PrivateKey): 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;
@@ -229,6 +229,12 @@ export declare class SenderCertificate {
     key(): PublicKey;
     senderE164(): string | null;
     senderUuid(): string;
+    /**
+     * Returns an ACI if the sender is a valid UUID, `null` otherwise.
+     *
+     * In a future release SenderCertificate will *only* support ACIs.
+     */
+    senderAci(): Aci | null;
     senderDeviceId(): number;
     serverCertificate(): ServerCertificate;
     signature(): Buffer;
@@ -328,6 +334,12 @@ export declare class SealedSenderDecryptionResult {
     message(): Buffer;
     senderE164(): string | null;
     senderUuid(): string;
+    /**
+     * Returns an ACI if the sender is a valid UUID, `null` otherwise.
+     *
+     * In a future release SenderCertificate will *only* support ACIs.
+     */
+    senderAci(): Aci | null;
     deviceId(): number;
 }
 interface CiphertextMessageConvertible {

package/dist/index.js

@@ -544,6 +544,9 @@ class SenderCertificate {
         return new SenderCertificate(nativeHandle);
     }
     static new(senderUuid, senderE164, senderDeviceId, senderKey, expiration, signerCert, signerKey) {
+        if (typeof senderUuid !== 'string') {
+            senderUuid = senderUuid.getServiceIdString();
+        }
         return new SenderCertificate(Native.SenderCertificate_New(senderUuid, senderE164, senderDeviceId, senderKey, expiration, signerCert, signerKey));
     }
     static deserialize(buffer) {
@@ -567,6 +570,19 @@ class SenderCertificate {
     senderUuid() {
         return Native.SenderCertificate_GetSenderUuid(this);
     }
+    /**
+     * Returns an ACI if the sender is a valid UUID, `null` otherwise.
+     *
+     * In a future release SenderCertificate will *only* support ACIs.
+     */
+    senderAci() {
+        try {
+            return Address_1.Aci.parseFromServiceIdString(this.senderUuid());
+        }
+        catch (_a) {
+            return null;
+        }
+    }
     senderDeviceId() {
         return Native.SenderCertificate_GetDeviceId(this);
     }
@@ -587,7 +603,7 @@ class SenderKeyDistributionMessage {
     }
     static create(sender, distributionId, store) {
         return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield Native.SenderKeyDistributionMessage_Create(sender, Buffer.from(uuid.parse(distributionId)), store, null);
+            const handle = yield Native.SenderKeyDistributionMessage_Create(sender, Buffer.from(uuid.parse(distributionId)), store);
             return new SenderKeyDistributionMessage(handle);
         });
     }
@@ -616,7 +632,7 @@ class SenderKeyDistributionMessage {
 exports.SenderKeyDistributionMessage = SenderKeyDistributionMessage;
 function processSenderKeyDistributionMessage(sender, message, store) {
     return __awaiter(this, void 0, void 0, function* () {
-        yield Native.SenderKeyDistributionMessage_Process(sender, message, store, null);
+        yield Native.SenderKeyDistributionMessage_Process(sender, message, store);
     });
 }
 exports.processSenderKeyDistributionMessage = processSenderKeyDistributionMessage;
@@ -811,13 +827,13 @@ class SenderKeyStore {
 exports.SenderKeyStore = SenderKeyStore;
 function groupEncrypt(sender, distributionId, store, message) {
     return __awaiter(this, void 0, void 0, function* () {
-        return CiphertextMessage._fromNativeHandle(yield Native.GroupCipher_EncryptMessage(sender, Buffer.from(uuid.parse(distributionId)), message, store, null));
+        return CiphertextMessage._fromNativeHandle(yield Native.GroupCipher_EncryptMessage(sender, Buffer.from(uuid.parse(distributionId)), message, store));
     });
 }
 exports.groupEncrypt = groupEncrypt;
 function groupDecrypt(sender, store, message) {
     return __awaiter(this, void 0, void 0, function* () {
-        return Native.GroupCipher_DecryptMessage(sender, message, store, null);
+        return Native.GroupCipher_DecryptMessage(sender, message, store);
     });
 }
 exports.groupDecrypt = groupDecrypt;
@@ -837,6 +853,19 @@ class SealedSenderDecryptionResult {
     senderUuid() {
         return Native.SealedSenderDecryptionResult_GetSenderUuid(this);
     }
+    /**
+     * Returns an ACI if the sender is a valid UUID, `null` otherwise.
+     *
+     * In a future release SenderCertificate will *only* support ACIs.
+     */
+    senderAci() {
+        try {
+            return Address_1.Aci.parseFromServiceIdString(this.senderUuid());
+        }
+        catch (_a) {
+            return null;
+        }
+    }
     deviceId() {
         return Native.SealedSenderDecryptionResult_GetDeviceId(this);
     }
@@ -918,21 +947,21 @@ class DecryptionErrorMessage {
 }
 exports.DecryptionErrorMessage = DecryptionErrorMessage;
 function processPreKeyBundle(bundle, address, sessionStore, identityStore) {
-    return Native.SessionBuilder_ProcessPreKeyBundle(bundle, address, sessionStore, identityStore, null);
+    return Native.SessionBuilder_ProcessPreKeyBundle(bundle, address, sessionStore, identityStore);
 }
 exports.processPreKeyBundle = processPreKeyBundle;
 function signalEncrypt(message, address, sessionStore, identityStore) {
     return __awaiter(this, void 0, void 0, function* () {
-        return CiphertextMessage._fromNativeHandle(yield Native.SessionCipher_EncryptMessage(message, address, sessionStore, identityStore, null));
+        return CiphertextMessage._fromNativeHandle(yield Native.SessionCipher_EncryptMessage(message, address, sessionStore, identityStore));
     });
 }
 exports.signalEncrypt = signalEncrypt;
 function signalDecrypt(message, address, sessionStore, identityStore) {
-    return Native.SessionCipher_DecryptSignalMessage(message, address, sessionStore, identityStore, null);
+    return Native.SessionCipher_DecryptSignalMessage(message, address, sessionStore, identityStore);
 }
 exports.signalDecrypt = signalDecrypt;
 function signalDecryptPreKey(message, address, sessionStore, identityStore, prekeyStore, signedPrekeyStore, kyberPrekeyStore) {
-    return Native.SessionCipher_DecryptPreKeySignalMessage(message, address, sessionStore, identityStore, prekeyStore, signedPrekeyStore, kyberPrekeyStore, null);
+    return Native.SessionCipher_DecryptPreKeySignalMessage(message, address, sessionStore, identityStore, prekeyStore, signedPrekeyStore, kyberPrekeyStore);
 }
 exports.signalDecryptPreKey = signalDecryptPreKey;
 function sealedSenderEncryptMessage(message, address, senderCert, sessionStore, identityStore) {
@@ -944,13 +973,13 @@ function sealedSenderEncryptMessage(message, address, senderCert, sessionStore,
 }
 exports.sealedSenderEncryptMessage = sealedSenderEncryptMessage;
 function sealedSenderEncrypt(content, address, identityStore) {
-    return Native.SealedSender_Encrypt(address, content, identityStore, null);
+    return Native.SealedSender_Encrypt(address, content, identityStore);
 }
 exports.sealedSenderEncrypt = sealedSenderEncrypt;
 function sealedSenderMultiRecipientEncrypt(content, recipients, identityStore, sessionStore) {
     return __awaiter(this, void 0, void 0, function* () {
         const recipientSessions = yield sessionStore.getExistingSessions(recipients);
-        return yield Native.SealedSender_MultiRecipientEncrypt(recipients, recipientSessions, content, identityStore, null);
+        return yield Native.SealedSender_MultiRecipientEncrypt(recipients, recipientSessions, content, identityStore);
     });
 }
 exports.sealedSenderMultiRecipientEncrypt = sealedSenderMultiRecipientEncrypt;
@@ -968,7 +997,7 @@ function sealedSenderDecryptMessage(message, trustRoot, timestamp, localE164, lo
 exports.sealedSenderDecryptMessage = sealedSenderDecryptMessage;
 function sealedSenderDecryptToUsmc(message, identityStore) {
     return __awaiter(this, void 0, void 0, function* () {
-        const usmc = yield Native.SealedSender_DecryptToUsmc(message, identityStore, null);
+        const usmc = yield Native.SealedSender_DecryptToUsmc(message, identityStore);
         return UnidentifiedSenderMessageContent._fromNativeHandle(usmc);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/libsignal-client",
-  "version": "0.30.1",
+  "version": "0.31.0",
   "license": "AGPL-3.0-only",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",