@signalapp/libsignal-client 0.88.3 → 0.89.1

package/dist/index.js

@@ -8,8 +8,11 @@ import * as Errors from './Errors.js';
 export * from './Errors.js';
 import { Aci, ProtocolAddress, ServiceId } from './Address.js';
 export * from './Address.js';
-import { PrivateKey, PublicKey } from './EcKeys.js';
+import { IdentityKeyPair, PrivateKey, PublicKey } from './EcKeys.js';
 export * from './EcKeys.js';
+import { KEMPublicKey, SignedPreKeyRecord, } from './ProtocolTypes.js';
+export * from './ProtocolTypes.js';
+import { parseUuid } from './uuid.js';
 export * from './uuid.js';
 export * as usernames from './usernames.js';
 export * as io from './io.js';
@@ -42,6 +45,7 @@ export function hkdf(outputLength, keyMaterial, label, salt) {
     return Native.HKDF_DeriveSecrets(outputLength, keyMaterial, label, salt);
 }
 export class ScannableFingerprint {
+    scannable;
     constructor(scannable) {
         this.scannable = scannable;
     }
@@ -56,6 +60,7 @@ export class ScannableFingerprint {
     }
 }
 export class DisplayableFingerprint {
+    display;
     constructor(display) {
         this.display = display;
     }
@@ -67,6 +72,7 @@ export class DisplayableFingerprint {
     }
 }
 export class Fingerprint {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
@@ -88,6 +94,7 @@ export class Fingerprint {
  * this API does not expose a streaming form.
  */
 export class Aes256GcmSiv {
+    _nativeHandle;
     constructor(key) {
         this._nativeHandle = Native.Aes256GcmSiv_New(key);
     }
@@ -119,21 +126,8 @@ export class Aes256GcmSiv {
         return Native.Aes256GcmSiv_Decrypt(this, message, nonce, associatedData);
     }
 }
-export class KEMPublicKey {
-    constructor(handle) {
-        this._nativeHandle = handle;
-    }
-    static _fromNativeHandle(handle) {
-        return new KEMPublicKey(handle);
-    }
-    static deserialize(buf) {
-        return new KEMPublicKey(Native.KyberPublicKey_Deserialize(buf));
-    }
-    serialize() {
-        return Native.KyberPublicKey_Serialize(this);
-    }
-}
 export class KEMSecretKey {
+    _nativeHandle;
     constructor(handle) {
         this._nativeHandle = handle;
     }
@@ -148,6 +142,7 @@ export class KEMSecretKey {
     }
 }
 export class KEMKeyPair {
+    _nativeHandle;
     constructor(handle) {
         this._nativeHandle = handle;
     }
@@ -164,54 +159,8 @@ export class KEMKeyPair {
         return KEMSecretKey._fromNativeHandle(Native.KyberKeyPair_GetSecretKey(this));
     }
 }
-export class PreKeyBundle {
-    constructor(handle) {
-        this._nativeHandle = handle;
-    }
-    static new(registration_id, device_id, prekey_id, prekey, signed_prekey_id, signed_prekey, signed_prekey_signature, identity_key, kyber_prekey_id, kyber_prekey, kyber_prekey_signature) {
-        return new PreKeyBundle(Native.PreKeyBundle_New(registration_id, device_id, prekey_id, prekey, signed_prekey_id, signed_prekey, signed_prekey_signature, identity_key, kyber_prekey_id, kyber_prekey, kyber_prekey_signature));
-    }
-    deviceId() {
-        return Native.PreKeyBundle_GetDeviceId(this);
-    }
-    identityKey() {
-        return PublicKey._fromNativeHandle(Native.PreKeyBundle_GetIdentityKey(this));
-    }
-    preKeyId() {
-        return Native.PreKeyBundle_GetPreKeyId(this);
-    }
-    preKeyPublic() {
-        const handle = Native.PreKeyBundle_GetPreKeyPublic(this);
-        if (handle == null) {
-            return null;
-        }
-        else {
-            return PublicKey._fromNativeHandle(handle);
-        }
-    }
-    registrationId() {
-        return Native.PreKeyBundle_GetRegistrationId(this);
-    }
-    signedPreKeyId() {
-        return Native.PreKeyBundle_GetSignedPreKeyId(this);
-    }
-    signedPreKeyPublic() {
-        return PublicKey._fromNativeHandle(Native.PreKeyBundle_GetSignedPreKeyPublic(this));
-    }
-    signedPreKeySignature() {
-        return Native.PreKeyBundle_GetSignedPreKeySignature(this);
-    }
-    kyberPreKeyId() {
-        return Native.PreKeyBundle_GetKyberPreKeyId(this);
-    }
-    kyberPreKeyPublic() {
-        return KEMPublicKey._fromNativeHandle(Native.PreKeyBundle_GetKyberPreKeyPublic(this));
-    }
-    kyberPreKeySignature() {
-        return Native.PreKeyBundle_GetKyberPreKeySignature(this);
-    }
-}
 export class PreKeyRecord {
+    _nativeHandle;
     constructor(handle) {
         this._nativeHandle = handle;
     }
@@ -237,39 +186,8 @@ export class PreKeyRecord {
         return Native.PreKeyRecord_Serialize(this);
     }
 }
-export class SignedPreKeyRecord {
-    constructor(handle) {
-        this._nativeHandle = handle;
-    }
-    static _fromNativeHandle(nativeHandle) {
-        return new SignedPreKeyRecord(nativeHandle);
-    }
-    static new(id, timestamp, pubKey, privKey, signature) {
-        return new SignedPreKeyRecord(Native.SignedPreKeyRecord_New(id, timestamp, pubKey, privKey, signature));
-    }
-    static deserialize(buffer) {
-        return new SignedPreKeyRecord(Native.SignedPreKeyRecord_Deserialize(buffer));
-    }
-    id() {
-        return Native.SignedPreKeyRecord_GetId(this);
-    }
-    privateKey() {
-        return PrivateKey._fromNativeHandle(Native.SignedPreKeyRecord_GetPrivateKey(this));
-    }
-    publicKey() {
-        return PublicKey._fromNativeHandle(Native.SignedPreKeyRecord_GetPublicKey(this));
-    }
-    serialize() {
-        return Native.SignedPreKeyRecord_Serialize(this);
-    }
-    signature() {
-        return Native.SignedPreKeyRecord_GetSignature(this);
-    }
-    timestamp() {
-        return Native.SignedPreKeyRecord_GetTimestamp(this);
-    }
-}
 export class KyberPreKeyRecord {
+    _nativeHandle;
     constructor(handle) {
         this._nativeHandle = handle;
     }
@@ -305,6 +223,7 @@ export class KyberPreKeyRecord {
     }
 }
 export class SignalMessage {
+    _nativeHandle;
     constructor(handle) {
         this._nativeHandle = handle;
     }
@@ -334,6 +253,7 @@ export class SignalMessage {
     }
 }
 export class PreKeySignalMessage {
+    _nativeHandle;
     constructor(handle) {
         this._nativeHandle = handle;
     }
@@ -360,6 +280,7 @@ export class PreKeySignalMessage {
     }
 }
 export class SessionRecord {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
@@ -394,6 +315,7 @@ export class SessionRecord {
     }
 }
 export class ServerCertificate {
+    _nativeHandle;
     static _fromNativeHandle(nativeHandle) {
         return new ServerCertificate(nativeHandle);
     }
@@ -423,6 +345,7 @@ export class ServerCertificate {
     }
 }
 export class SenderKeyRecord {
+    _nativeHandle;
     static _fromNativeHandle(nativeHandle) {
         return new SenderKeyRecord(nativeHandle);
     }
@@ -437,6 +360,7 @@ export class SenderKeyRecord {
     }
 }
 export class SenderCertificate {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
@@ -524,15 +448,16 @@ function bridgeSenderKeyStore(store) {
     };
 }
 export class SenderKeyDistributionMessage {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
     static async create(sender, distributionId, store) {
-        const handle = await Native.SenderKeyDistributionMessage_Create(sender, uuid.parse(distributionId), bridgeSenderKeyStore(store));
+        const handle = await Native.SenderKeyDistributionMessage_Create(sender, parseUuid(distributionId), bridgeSenderKeyStore(store));
         return new SenderKeyDistributionMessage(handle);
     }
     static _new(messageVersion, distributionId, chainId, iteration, chainKey, pk) {
-        return new SenderKeyDistributionMessage(Native.SenderKeyDistributionMessage_New(messageVersion, uuid.parse(distributionId), chainId, iteration, chainKey, pk));
+        return new SenderKeyDistributionMessage(Native.SenderKeyDistributionMessage_New(messageVersion, parseUuid(distributionId), chainId, iteration, chainKey, pk));
     }
     static deserialize(buffer) {
         return new SenderKeyDistributionMessage(Native.SenderKeyDistributionMessage_Deserialize(buffer));
@@ -557,11 +482,12 @@ export async function processSenderKeyDistributionMessage(sender, message, store
     await Native.SenderKeyDistributionMessage_Process(sender, message, bridgeSenderKeyStore(store));
 }
 export class SenderKeyMessage {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
     static _new(messageVersion, distributionId, chainId, iteration, ciphertext, pk) {
-        return new SenderKeyMessage(Native.SenderKeyMessage_New(messageVersion, uuid.parse(distributionId), chainId, iteration, ciphertext, pk));
+        return new SenderKeyMessage(Native.SenderKeyMessage_New(messageVersion, parseUuid(distributionId), chainId, iteration, ciphertext, pk));
     }
     static deserialize(buffer) {
         return new SenderKeyMessage(Native.SenderKeyMessage_Deserialize(buffer));
@@ -586,6 +512,7 @@ export class SenderKeyMessage {
     }
 }
 export class UnidentifiedSenderMessageContent {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
@@ -626,28 +553,9 @@ export var IdentityChange;
     IdentityChange[IdentityChange["ReplacedExisting"] = 1] = "ReplacedExisting";
 })(IdentityChange || (IdentityChange = {}));
 export class IdentityKeyStore {
-    async _getIdentityKey() {
-        const key = await this.getIdentityKey();
-        return key._nativeHandle;
-    }
-    async _getLocalRegistrationId() {
-        return this.getLocalRegistrationId();
-    }
-    async _saveIdentity(name, key) {
-        return this.saveIdentity(ProtocolAddress._fromNativeHandle(name), PublicKey._fromNativeHandle(key));
-    }
-    async _isTrustedIdentity(name, key, sending) {
-        const direction = sending ? Direction.Sending : Direction.Receiving;
-        return this.isTrustedIdentity(ProtocolAddress._fromNativeHandle(name), PublicKey._fromNativeHandle(key), direction);
-    }
-    async _getIdentity(name) {
-        const key = await this.getIdentity(ProtocolAddress._fromNativeHandle(name));
-        if (key == null) {
-            return Promise.resolve(null);
-        }
-        else {
-            return key._nativeHandle;
-        }
+    async getIdentityKeyPair() {
+        const privKey = await this.getIdentityKey();
+        return new IdentityKeyPair(privKey.getPublicKey(), privKey);
     }
 }
 export class PreKeyStore {
@@ -659,12 +567,13 @@ export class KyberPreKeyStore {
 export class SenderKeyStore {
 }
 export async function groupEncrypt(sender, distributionId, store, message) {
-    return CiphertextMessage._fromNativeHandle(await Native.GroupCipher_EncryptMessage(sender, uuid.parse(distributionId), message, bridgeSenderKeyStore(store)));
+    return CiphertextMessage._fromNativeHandle(await Native.GroupCipher_EncryptMessage(sender, parseUuid(distributionId), message, bridgeSenderKeyStore(store)));
 }
 export async function groupDecrypt(sender, store, message) {
     return Native.GroupCipher_DecryptMessage(sender, message, bridgeSenderKeyStore(store));
 }
 export class SealedSenderDecryptionResult {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
@@ -698,6 +607,7 @@ export class SealedSenderDecryptionResult {
     }
 }
 export class CiphertextMessage {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
@@ -715,6 +625,7 @@ export class CiphertextMessage {
     }
 }
 export class PlaintextContent {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
@@ -735,6 +646,7 @@ export class PlaintextContent {
     }
 }
 export class DecryptionErrorMessage {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
@@ -780,14 +692,38 @@ function bridgeSessionStore(store) {
         },
     };
 }
+function bridgeIdentityKeyStore(store) {
+    return {
+        async getLocalIdentityKeyPair() {
+            const keyPair = await store.getIdentityKeyPair();
+            return [
+                keyPair.privateKey._nativeHandle,
+                keyPair.publicKey._nativeHandle,
+            ];
+        },
+        async getLocalRegistrationId() {
+            return store.getLocalRegistrationId();
+        },
+        async saveIdentityKey(name, key) {
+            return store.saveIdentity(ProtocolAddress._fromNativeHandle(name), PublicKey._fromNativeHandle(key));
+        },
+        async isTrustedIdentity(name, key, direction) {
+            return store.isTrustedIdentity(ProtocolAddress._fromNativeHandle(name), PublicKey._fromNativeHandle(key), direction);
+        },
+        async getIdentityKey(name) {
+            const key = await store.getIdentity(ProtocolAddress._fromNativeHandle(name));
+            return key ? key._nativeHandle : null;
+        },
+    };
+}
 export function processPreKeyBundle(bundle, address, sessionStore, identityStore, now = new Date()) {
-    return Native.SessionBuilder_ProcessPreKeyBundle(bundle, address, bridgeSessionStore(sessionStore), identityStore, now.getTime());
+    return Native.SessionBuilder_ProcessPreKeyBundle(bundle, address, bridgeSessionStore(sessionStore), bridgeIdentityKeyStore(identityStore), now.getTime());
 }
 export async function signalEncrypt(message, address, sessionStore, identityStore, now = new Date()) {
-    return CiphertextMessage._fromNativeHandle(await Native.SessionCipher_EncryptMessage(message, address, bridgeSessionStore(sessionStore), identityStore, now.getTime()));
+    return CiphertextMessage._fromNativeHandle(await Native.SessionCipher_EncryptMessage(message, address, bridgeSessionStore(sessionStore), bridgeIdentityKeyStore(identityStore), now.getTime()));
 }
 export function signalDecrypt(message, address, sessionStore, identityStore) {
-    return Native.SessionCipher_DecryptSignalMessage(message, address, bridgeSessionStore(sessionStore), identityStore);
+    return Native.SessionCipher_DecryptSignalMessage(message, address, bridgeSessionStore(sessionStore), bridgeIdentityKeyStore(identityStore));
 }
 function bridgePreKeyStore(store) {
     return {
@@ -829,7 +765,7 @@ function bridgeKyberPreKeyStore(store) {
     };
 }
 export function signalDecryptPreKey(message, address, sessionStore, identityStore, prekeyStore, signedPrekeyStore, kyberPrekeyStore) {
-    return Native.SessionCipher_DecryptPreKeySignalMessage(message, address, bridgeSessionStore(sessionStore), identityStore, bridgePreKeyStore(prekeyStore), bridgeSignedPreKeyStore(signedPrekeyStore), bridgeKyberPreKeyStore(kyberPrekeyStore));
+    return Native.SessionCipher_DecryptPreKeySignalMessage(message, address, bridgeSessionStore(sessionStore), bridgeIdentityKeyStore(identityStore), bridgePreKeyStore(prekeyStore), bridgeSignedPreKeyStore(signedPrekeyStore), bridgeKyberPreKeyStore(kyberPrekeyStore));
 }
 export async function sealedSenderEncryptMessage(message, address, senderCert, sessionStore, identityStore) {
     const ciphertext = await signalEncrypt(message, address, sessionStore, identityStore);
@@ -837,7 +773,7 @@ export async function sealedSenderEncryptMessage(message, address, senderCert, s
     return await sealedSenderEncrypt(usmc, address, identityStore);
 }
 export function sealedSenderEncrypt(content, address, identityStore) {
-    return Native.SealedSender_Encrypt(address, content, identityStore);
+    return Native.SealedSender_Encrypt(address, content, bridgeIdentityKeyStore(identityStore));
 }
 export async function sealedSenderMultiRecipientEncrypt(contentOrOptions, recipients, identityStore, sessionStore) {
     let excludedRecipients = undefined;
@@ -856,21 +792,22 @@ export async function sealedSenderMultiRecipientEncrypt(contentOrOptions, recipi
         } = contentOrOptions);
     }
     const recipientSessions = await sessionStore.getExistingSessions(recipients);
-    return await Native.SealedSender_MultiRecipientEncrypt(recipients, recipientSessions, ServiceId.toConcatenatedFixedWidthBinary(excludedRecipients ?? []), contentOrOptions, identityStore);
+    return await Native.SealedSender_MultiRecipientEncrypt(recipients, recipientSessions, ServiceId.toConcatenatedFixedWidthBinary(excludedRecipients ?? []), contentOrOptions, bridgeIdentityKeyStore(identityStore));
 }
 // For testing only
 export function sealedSenderMultiRecipientMessageForSingleRecipient(message) {
     return Native.SealedSender_MultiRecipientMessageForSingleRecipient(message);
 }
 export async function sealedSenderDecryptMessage(message, trustRoot, timestamp, localE164, localUuid, localDeviceId, sessionStore, identityStore, prekeyStore, signedPrekeyStore, kyberPrekeyStore) {
-    const ssdr = await Native.SealedSender_DecryptMessage(message, trustRoot, timestamp, localE164, localUuid, localDeviceId, bridgeSessionStore(sessionStore), identityStore, bridgePreKeyStore(prekeyStore), bridgeSignedPreKeyStore(signedPrekeyStore), bridgeKyberPreKeyStore(kyberPrekeyStore));
+    const ssdr = await Native.SealedSender_DecryptMessage(message, trustRoot, timestamp, localE164, localUuid, localDeviceId, bridgeSessionStore(sessionStore), bridgeIdentityKeyStore(identityStore), bridgePreKeyStore(prekeyStore), bridgeSignedPreKeyStore(signedPrekeyStore), bridgeKyberPreKeyStore(kyberPrekeyStore));
     return SealedSenderDecryptionResult._fromNativeHandle(ssdr);
 }
 export async function sealedSenderDecryptToUsmc(message, identityStore) {
-    const usmc = await Native.SealedSender_DecryptToUsmc(message, identityStore);
+    const usmc = await Native.SealedSender_DecryptToUsmc(message, bridgeIdentityKeyStore(identityStore));
     return UnidentifiedSenderMessageContent._fromNativeHandle(usmc);
 }
 export class Cds2Client {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }
@@ -891,6 +828,7 @@ export class Cds2Client {
     }
 }
 export class HsmEnclaveClient {
+    _nativeHandle;
     constructor(nativeHandle) {
         this._nativeHandle = nativeHandle;
     }

package/dist/internal.js

@@ -4,6 +4,7 @@
 //
 import * as Native from './Native.js';
 export class BridgedStringMap {
+    _nativeHandle;
     constructor(input) {
         this._nativeHandle = Native.BridgedStringMap_new(input.size);
         for (const [key, value] of input) {

package/dist/io.d.ts

@@ -3,7 +3,7 @@ import * as Native from './Native.js';
  * An abstract class representing an input stream of bytes.
  */
 export declare abstract class InputStream implements Native.InputStream {
-    _read(amount: number): Promise<Uint8Array>;
+    _read(amount: number): Promise<Uint8Array<ArrayBuffer>>;
     _skip(amount: number): Promise<void>;
     /**
      * Called to indicate the stream's resources should be released.
@@ -21,7 +21,7 @@ export declare abstract class InputStream implements Native.InputStream {
      * @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<Uint8Array>;
+    abstract read(amount: number): Promise<Uint8Array<ArrayBuffer>>;
     /**
      * Skip an amount of bytes in the input stream.
      *

package/dist/net/Chat.d.ts

@@ -7,7 +7,7 @@ export type ChatRequest = Readonly<{
     verb: string;
     path: string;
     headers: ReadonlyArray<[string, string]>;
-    body?: Uint8Array;
+    body?: Uint8Array<ArrayBuffer>;
     timeoutMillis?: number;
 }>;
 export type RequestOptions = {
@@ -38,7 +38,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: Uint8Array, timestamp: number, ack: ChatServerMessageAck) => void;
+    onIncomingMessage: (envelope: Uint8Array<ArrayBuffer>, timestamp: number, ack: ChatServerMessageAck) => void;
     /**
      * Called when the server indicates that there are no further messages in the message queue.
      *
@@ -69,7 +69,7 @@ export interface ProvisioningConnectionListener extends ConnectionEventsListener
      *
      * Once the server receives the `ack` for this message, it will close this connection.
      */
-    onReceivedEnvelope: (envelope: Uint8Array, ack: ChatServerMessageAck) => void;
+    onReceivedEnvelope: (envelope: Uint8Array<ArrayBuffer>, ack: ChatServerMessageAck) => void;
 }
 /**
  * A connection to the Chat Service.

package/dist/net/Chat.js

@@ -8,6 +8,7 @@ import { newNativeHandle } from '../internal.js';
 import { FakeChatRemote } from './FakeChat.js';
 const DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS = 5000;
 export class ChatServerMessageAck {
+    _nativeHandle;
     constructor(_nativeHandle) {
         this._nativeHandle = _nativeHandle;
     }
@@ -16,6 +17,7 @@ export class ChatServerMessageAck {
     }
 }
 class ConnectionInfoImpl {
+    _nativeHandle;
     constructor(_nativeHandle) {
         this._nativeHandle = _nativeHandle;
     }
@@ -38,6 +40,10 @@ class ConnectionInfoImpl {
     }
 }
 export class UnauthenticatedChatConnection {
+    _asyncContext;
+    _chatService;
+    chatListener;
+    env;
     static async connect(asyncContext, connectionManager, listener, env, options) {
         const nativeChatListener = makeNativeChatListener(asyncContext, listener);
         const connect = Native.UnauthenticatedChatConnection_connect(asyncContext, connectionManager, options?.languages ?? []);
@@ -91,6 +97,9 @@ export class UnauthenticatedChatConnection {
     }
 }
 export class AuthenticatedChatConnection {
+    asyncContext;
+    chatService;
+    chatListener;
     static async connect(asyncContext, connectionManager, username, password, receiveStories, listener, options) {
         const nativeChatListener = makeNativeChatListener(asyncContext, listener);
         const connect = Native.AuthenticatedChatConnection_connect(asyncContext, connectionManager, username, password, receiveStories, options?.languages ?? []);
@@ -142,6 +151,9 @@ export class AuthenticatedChatConnection {
  * interesting functionality is in the events delivered to the {@link ProvisioningConnectionListener}.
  */
 export class ProvisioningConnection {
+    asyncContext;
+    chatService;
+    chatListener;
     static async connect(asyncContext, connectionManager, listener, options) {
         const nativeListener = this.makeNativeProvisioningListener(listener);
         const connect = Native.ProvisioningChatConnection_connect(asyncContext, connectionManager);
@@ -213,6 +225,7 @@ export class ProvisioningConnection {
  * stays alive as long as the connection does.
  */
 class WeakListenerWrapper {
+    listener;
     constructor(listener) {
         this.listener = new WeakRef(listener);
     }
@@ -231,6 +244,7 @@ class WeakListenerWrapper {
 }
 /** Like {@link WeakListenerWrapper}, but for {@link ProvisioningConnection}. */
 class WeakProvisioningListenerWrapper {
+    listener;
     constructor(listener) {
         this.listener = new WeakRef(listener);
     }

package/dist/net/FakeChat.d.ts

@@ -8,14 +8,14 @@ export declare class InternalRequest implements Native.Wrapper<Native.HttpReques
     get verb(): string;
     get path(): string;
     get headers(): Map<string, string>;
-    get body(): Uint8Array;
+    get body(): Uint8Array<ArrayBuffer>;
 }
 export type ServerResponse = {
     id: bigint;
     status: number;
     message?: string;
     headers?: string[];
-    body?: Uint8Array;
+    body?: Uint8Array<ArrayBuffer>;
 };
 export declare class FakeChatRemote {
     private asyncContext;
@@ -25,7 +25,7 @@ export declare class FakeChatRemote {
     assertReceiveIncomingRequest(): Promise<InternalRequest>;
     sendReplyTo(request: InternalRequest, response: Omit<ServerResponse, 'id'>): void;
     sendServerResponse(response: ServerResponse): void;
-    sendRawServerResponse(bytes: Uint8Array): void;
-    sendRawServerRequest(bytes: Uint8Array): void;
+    sendRawServerResponse(bytes: Uint8Array<ArrayBuffer>): void;
+    sendRawServerRequest(bytes: Uint8Array<ArrayBuffer>): void;
     injectConnectionInterrupted(): void;
 }

package/dist/net/FakeChat.js

@@ -6,6 +6,8 @@ import * as Native from '../Native.js';
 import { newNativeHandle } from '../internal.js';
 import assert from 'node:assert';
 export class InternalRequest {
+    _nativeHandle;
+    requestId;
     constructor([nativeHandle, requestId]) {
         this._nativeHandle = nativeHandle;
         this.requestId = requestId;
@@ -27,6 +29,8 @@ export class InternalRequest {
     }
 }
 export class FakeChatRemote {
+    asyncContext;
+    _nativeHandle;
     constructor(asyncContext, _nativeHandle) {
         this.asyncContext = asyncContext;
         this._nativeHandle = _nativeHandle;

package/dist/net/KeyTransparency.d.ts

@@ -9,10 +9,10 @@ import { Environment, type TokioAsyncContext } from '../net.js';
  * used by the {@link Client}.
  */
 export interface Store {
-    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>;
+    getLastDistinguishedTreeHead: () => Promise<Uint8Array<ArrayBuffer> | null>;
+    setLastDistinguishedTreeHead: (bytes: Readonly<Uint8Array<ArrayBuffer>> | null) => Promise<void>;
+    getAccountData: (aci: Aci) => Promise<Uint8Array<ArrayBuffer> | null>;
+    setAccountData: (aci: Aci, bytes: Readonly<Uint8Array<ArrayBuffer>>) => Promise<void>;
 }
 /**
  * Options that are accepted by all {@link Client} APIs.
@@ -34,7 +34,7 @@ export type AciInfo = {
  */
 export type E164Info = {
     e164: string;
-    unidentifiedAccessKey: Readonly<Uint8Array>;
+    unidentifiedAccessKey: Readonly<Uint8Array<ArrayBuffer>>;
 };
 /**
  * Key transparency client request
@@ -45,7 +45,7 @@ export type Request = {
     aciInfo: AciInfo;
     /** Unidentified access key associated with the account. Optional. */
     e164Info?: E164Info;
-    usernameHash?: Readonly<Uint8Array>;
+    usernameHash?: Readonly<Uint8Array<ArrayBuffer>>;
 };
 /**
  *  Mode of the monitor operation.
@@ -170,5 +170,5 @@ export declare class ClientImpl implements Client {
     search(request: Request, store: Store, options?: Readonly<Options>): Promise<void>;
     monitor(request: MonitorRequest, store: Store, options?: Readonly<Options>): Promise<void>;
     private updateDistinguished;
-    _getLatestDistinguished(store: Store, options: Readonly<Options>): Promise<Uint8Array>;
+    _getLatestDistinguished(store: Store, options: Readonly<Options>): Promise<Uint8Array<ArrayBuffer>>;
 }

package/dist/net/KeyTransparency.js

@@ -17,6 +17,9 @@ export var MonitorMode;
     MonitorMode[MonitorMode["Other"] = 1] = "Other";
 })(MonitorMode || (MonitorMode = {}));
 export class ClientImpl {
+    asyncContext;
+    chatService;
+    env;
     constructor(asyncContext, chatService, env) {
         this.asyncContext = asyncContext;
         this.chatService = chatService;

package/dist/net/Registration.d.ts

@@ -139,11 +139,11 @@ export declare class RegistrationService {
 export declare class AccountAttributes {
     readonly _nativeHandle: Native.RegistrationAccountAttributes;
     constructor({ recoveryPassword, aciRegistrationId, pniRegistrationId, registrationLock, unidentifiedAccessKey, unrestrictedUnidentifiedAccess, capabilities, discoverableByPhoneNumber, }: {
-        recoveryPassword: Uint8Array;
+        recoveryPassword: Uint8Array<ArrayBuffer>;
         aciRegistrationId: number;
         pniRegistrationId: number;
         registrationLock: string | null;
-        unidentifiedAccessKey: Uint8Array;
+        unidentifiedAccessKey: Uint8Array<ArrayBuffer>;
         unrestrictedUnidentifiedAccess: boolean;
         capabilities: Set<string>;
         discoverableByPhoneNumber: boolean;
@@ -155,8 +155,8 @@ export declare class RegisterAccountResponse {
     get aci(): Aci;
     get pni(): Pni;
     get number(): string;
-    get usernameHash(): Uint8Array | null;
-    get usernameLinkHandle(): Uint8Array | null;
+    get usernameHash(): Uint8Array<ArrayBuffer> | null;
+    get usernameLinkHandle(): Uint8Array<ArrayBuffer> | null;
     get backupEntitlement(): {
         backupLevel: bigint;
         expirationSeconds: bigint;