@unknownncat/swt-libsignal 1.0.7 → 1.1.0

package/dist/session/storage/index.d.ts

@@ -1,19 +1,19 @@
 export * from './types';
+export * from './runtime';
 export * from './in-memory';
 export * from './migrations';
 export * from './adapter';
-import { StorageAdapter } from './types';
-export declare class StorageManager {
-    adapter: StorageAdapter;
-    constructor(adapter: StorageAdapter);
-    get<T = any>(key: string): Promise<T | undefined>;
-    set<T = any>(key: string, value: T): Promise<void>;
-    delete(key: string): Promise<void>;
-    batch(ops: Array<{
-        type: 'put' | 'del';
-        key: string;
-        value?: any;
-    }>): Promise<void>;
-    close(): Promise<void>;
+export * from './sqlite-async';
+import type { BatchDeleteEntry, BatchGetOptions, BatchSetEntry, MaybePromise, StorageAdapter } from './types';
+export declare class StorageManager<TValue = Uint8Array> {
+    readonly adapter: StorageAdapter<TValue>;
+    constructor(adapter: StorageAdapter<TValue>);
+    get(key: string): MaybePromise<TValue | undefined>;
+    set(key: string, value: TValue): MaybePromise<void>;
+    delete(key: string): MaybePromise<void>;
+    getMany(keys: readonly string[], options?: BatchGetOptions): MaybePromise<readonly (TValue | undefined)[]>;
+    setMany(entries: readonly BatchSetEntry<TValue>[]): MaybePromise<void>;
+    deleteMany(entries: readonly BatchDeleteEntry[]): MaybePromise<void>;
+    close(): MaybePromise<void>;
 }
-export declare function createStorageManager(adapter: StorageAdapter): StorageManager;
+export declare function createStorageManager<TValue = Uint8Array>(adapter: StorageAdapter<TValue>): StorageManager<TValue>;

package/dist/session/storage/index.js

@@ -1,27 +1,35 @@
 export * from './types';
+export * from './runtime';
 export * from './in-memory';
 export * from './migrations';
 export * from './adapter';
+export * from './sqlite-async';
+import { deleteMany, deleteValue, getMany, getValue, setMany, setValue } from './runtime';
 export class StorageManager {
     adapter;
     constructor(adapter) {
         this.adapter = adapter;
     }
     get(key) {
-        return this.adapter.get(key);
+        return getValue(this.adapter, key);
     }
     set(key, value) {
-        return this.adapter.set(key, value);
+        return setValue(this.adapter, key, value);
     }
     delete(key) {
-        return this.adapter.delete(key);
+        return deleteValue(this.adapter, key);
     }
-    batch(ops) {
-        return this.adapter.batch(ops);
+    getMany(keys, options) {
+        return getMany(this.adapter, keys, options);
     }
-    async close() {
-        if (this.adapter.close)
-            return this.adapter.close();
+    setMany(entries) {
+        return setMany(this.adapter, entries);
+    }
+    deleteMany(entries) {
+        return deleteMany(this.adapter, entries);
+    }
+    close() {
+        return this.adapter.close?.();
     }
 }
 export function createStorageManager(adapter) {

package/dist/session/storage/migrations.d.ts

@@ -1,2 +1,2 @@
-import { StorageAdapter } from './types';
+import type { StorageAdapter } from './types';
 export declare function runMigrations(adapter: StorageAdapter, fromVersion: number, toVersion: number): Promise<void>;

package/dist/session/storage/migrations.js

@@ -1,6 +1,8 @@
+function hasMigrate(adapter) {
+    return typeof adapter.migrate === 'function';
+}
 export async function runMigrations(adapter, fromVersion, toVersion) {
-    if (adapter.migrate) {
-        await adapter.migrate(fromVersion, toVersion);
+    if (!hasMigrate(adapter))
         return;
-    }
+    await adapter.migrate(fromVersion, toVersion);
 }

package/dist/session/storage/runtime.d.ts

@@ -0,0 +1,7 @@
+import type { BatchDeleteEntry, BatchGetOptions, BatchSetEntry, MaybePromise, StorageAdapter } from './types';
+export declare function getValue<TValue>(adapter: StorageAdapter<TValue>, key: string): MaybePromise<TValue | undefined>;
+export declare function setValue<TValue>(adapter: StorageAdapter<TValue>, key: string, value: TValue): MaybePromise<void>;
+export declare function deleteValue<TValue>(adapter: StorageAdapter<TValue>, key: string): MaybePromise<void>;
+export declare function getMany<TValue>(adapter: StorageAdapter<TValue>, keys: readonly string[], options?: BatchGetOptions): MaybePromise<readonly (TValue | undefined)[]>;
+export declare function setMany<TValue>(adapter: StorageAdapter<TValue>, entries: readonly BatchSetEntry<TValue>[]): MaybePromise<void>;
+export declare function deleteMany<TValue>(adapter: StorageAdapter<TValue>, entries: readonly BatchDeleteEntry[]): MaybePromise<void>;

package/dist/session/storage/runtime.js

@@ -0,0 +1,45 @@
+function isPromiseLike(value) {
+    return typeof value?.then === 'function';
+}
+export function getValue(adapter, key) {
+    return adapter.get(key);
+}
+export function setValue(adapter, key, value) {
+    return adapter.set(key, value);
+}
+export function deleteValue(adapter, key) {
+    return adapter.delete(key);
+}
+export function getMany(adapter, keys, options) {
+    if (adapter.getMany)
+        return adapter.getMany(keys, options);
+    const out = new Array(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+        const value = adapter.get(keys[i]);
+        if (isPromiseLike(value)) {
+            return Promise.all(keys.map((key) => Promise.resolve(adapter.get(key))));
+        }
+        out[i] = value;
+    }
+    return out;
+}
+export function setMany(adapter, entries) {
+    if (adapter.setMany)
+        return adapter.setMany(entries);
+    for (let i = 0; i < entries.length; i++) {
+        const r = adapter.set(entries[i].key, entries[i].value);
+        if (isPromiseLike(r)) {
+            return Promise.all(entries.map((e) => Promise.resolve(adapter.set(e.key, e.value)))).then(() => undefined);
+        }
+    }
+}
+export function deleteMany(adapter, entries) {
+    if (adapter.deleteMany)
+        return adapter.deleteMany(entries);
+    for (let i = 0; i < entries.length; i++) {
+        const r = adapter.delete(entries[i].key);
+        if (isPromiseLike(r)) {
+            return Promise.all(entries.map((e) => Promise.resolve(adapter.delete(e.key)))).then(() => undefined);
+        }
+    }
+}

package/dist/session/storage/sqlite-async.d.ts

@@ -0,0 +1,26 @@
+import type { AsyncStorageAdapter, BatchDeleteEntry, BatchGetOptions, BatchSetEntry } from './types';
+export interface FileStorageAdapterOptions {
+    readonly flushEveryWrites?: number;
+}
+export declare class FileAsyncStorageAdapter implements AsyncStorageAdapter<Uint8Array> {
+    readonly name = "file-async";
+    private readonly map;
+    private readonly path;
+    private readonly flushEveryWrites;
+    private pendingWrites;
+    private initialized;
+    constructor(path: string, options?: FileStorageAdapterOptions);
+    private init;
+    private flushIfNeeded;
+    get(key: string): Promise<Uint8Array | undefined>;
+    set(key: string, value: Uint8Array): Promise<void>;
+    delete(key: string): Promise<void>;
+    getMany(keys: readonly string[], _options?: BatchGetOptions): Promise<readonly (Uint8Array | undefined)[]>;
+    setMany(entries: readonly BatchSetEntry<Uint8Array>[]): Promise<void>;
+    deleteMany(entries: readonly BatchDeleteEntry[]): Promise<void>;
+    zeroize(key: string): Promise<void>;
+    clear(options?: {
+        readonly secure?: boolean;
+    }): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/session/storage/sqlite-async.js

@@ -0,0 +1,95 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+export class FileAsyncStorageAdapter {
+    name = 'file-async';
+    map = new Map();
+    path;
+    flushEveryWrites;
+    pendingWrites = 0;
+    initialized = false;
+    constructor(path, options = {}) {
+        this.path = path;
+        this.flushEveryWrites = options.flushEveryWrites ?? 64;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        try {
+            const raw = await readFile(this.path, 'utf8');
+            const parsed = JSON.parse(raw);
+            for (const [k, v] of Object.entries(parsed)) {
+                this.map.set(k, Uint8Array.from(Buffer.from(v, 'base64')));
+            }
+        }
+        catch {
+        }
+    }
+    async flushIfNeeded(force = false) {
+        if (!force && this.pendingWrites < this.flushEveryWrites)
+            return;
+        this.pendingWrites = 0;
+        const out = {};
+        for (const [k, v] of this.map.entries()) {
+            out[k] = Buffer.from(v).toString('base64');
+        }
+        await mkdir(dirname(this.path), { recursive: true });
+        await writeFile(this.path, JSON.stringify(out), 'utf8');
+    }
+    async get(key) {
+        await this.init();
+        const value = this.map.get(key);
+        return value?.slice();
+    }
+    async set(key, value) {
+        await this.init();
+        this.map.set(key, value.slice());
+        this.pendingWrites++;
+        await this.flushIfNeeded();
+    }
+    async delete(key) {
+        await this.init();
+        this.map.delete(key);
+        this.pendingWrites++;
+        await this.flushIfNeeded();
+    }
+    async getMany(keys, _options) {
+        await this.init();
+        const out = new Array(keys.length);
+        for (let i = 0; i < keys.length; i++)
+            out[i] = this.map.get(keys[i])?.slice();
+        return out;
+    }
+    async setMany(entries) {
+        await this.init();
+        for (let i = 0; i < entries.length; i++) {
+            this.map.set(entries[i].key, entries[i].value.slice());
+        }
+        this.pendingWrites += entries.length;
+        await this.flushIfNeeded();
+    }
+    async deleteMany(entries) {
+        await this.init();
+        for (let i = 0; i < entries.length; i++)
+            this.map.delete(entries[i].key);
+        this.pendingWrites += entries.length;
+        await this.flushIfNeeded();
+    }
+    async zeroize(key) {
+        await this.init();
+        this.map.get(key)?.fill(0);
+    }
+    async clear(options) {
+        await this.init();
+        if (options?.secure) {
+            for (const value of this.map.values())
+                value.fill(0);
+        }
+        this.map.clear();
+        this.pendingWrites++;
+        await this.flushIfNeeded(true);
+    }
+    async close() {
+        await this.flushIfNeeded(true);
+    }
+}

package/dist/session/storage/types.d.ts

@@ -1,18 +1,58 @@
-export type BatchOp = {
-    type: 'put' | 'del';
-    key: string;
-    value?: any;
+export type MaybePromise<T> = T | Promise<T>;
+export interface BatchGetOptions {
+    readonly prefetch?: boolean;
+    readonly cacheHint?: 'none' | 'hot' | 'ephemeral';
+}
+export interface BatchSetEntry<TValue = Uint8Array> {
+    readonly key: string;
+    readonly value: TValue;
+}
+export interface BatchDeleteEntry {
+    readonly key: string;
+}
+export type BatchOperation<TValue = Uint8Array> = {
+    readonly type: 'set';
+    readonly key: string;
+    readonly value: TValue;
+} | {
+    readonly type: 'delete';
+    readonly key: string;
 };
-export interface StorageAdapter {
-    get<T = any>(key: string): Promise<T | undefined>;
-    set<T = any>(key: string, value: T): Promise<void>;
+export interface SecureStorageControls {
+    zeroize?(key: string): MaybePromise<void>;
+    clear?(options?: {
+        readonly secure?: boolean;
+    }): MaybePromise<void>;
+    close?(): MaybePromise<void>;
+}
+export interface BaseStorageAdapter<TValue = Uint8Array> extends SecureStorageControls {
+    readonly name?: string;
+    get(key: string): TValue | undefined;
+    set(key: string, value: TValue): void;
+    delete(key: string): void;
+    getMany?(keys: readonly string[], options?: BatchGetOptions): readonly (TValue | undefined)[];
+    setMany?(entries: readonly BatchSetEntry<TValue>[]): void;
+    deleteMany?(entries: readonly BatchDeleteEntry[]): void;
+    prefetch?(keys: readonly string[]): void;
+    cacheHint?(key: string, hint: NonNullable<BatchGetOptions['cacheHint']>): void;
+}
+export interface TransactionalStorageAdapter<TValue = Uint8Array> {
+    transaction<T>(run: (tx: BaseStorageAdapter<TValue>) => MaybePromise<T>): MaybePromise<T>;
+}
+export interface AsyncStorageAdapter<TValue = Uint8Array> extends SecureStorageControls {
+    readonly name?: string;
+    get(key: string): Promise<TValue | undefined>;
+    set(key: string, value: TValue): Promise<void>;
     delete(key: string): Promise<void>;
-    batch(ops: BatchOp[]): Promise<void>;
-    clear?(): Promise<void>;
-    close?(): Promise<void>;
-    name?: string;
+    getMany?(keys: readonly string[], options?: BatchGetOptions): Promise<readonly (TValue | undefined)[]>;
+    setMany?(entries: readonly BatchSetEntry<TValue>[]): Promise<void>;
+    deleteMany?(entries: readonly BatchDeleteEntry[]): Promise<void>;
+    prefetch?(keys: readonly string[]): Promise<void>;
+    cacheHint?(key: string, hint: NonNullable<BatchGetOptions['cacheHint']>): Promise<void>;
     migrate?(fromVersion: number, toVersion: number): Promise<void>;
 }
-export interface StorageManagerOptions {
-    adapter: StorageAdapter;
+export type StorageAdapter<TValue = Uint8Array> = BaseStorageAdapter<TValue> | AsyncStorageAdapter<TValue>;
+export interface StorageManagerOptions<TValue = Uint8Array> {
+    readonly adapter: StorageAdapter<TValue>;
 }
+export type BatchOp = BatchOperation<unknown>;

package/dist/session/utils.js

@@ -1,7 +1,7 @@
 export function assertUint8(value) {
     if (!(value instanceof Uint8Array)) {
-        const name = (value instanceof Object)
-            ? value.constructor.name
+        const name = (value !== null && typeof value === 'object' && 'constructor' in value)
+            ? value.constructor.name ?? 'Object'
             : typeof value;
         throw new TypeError(`Expected Uint8Array instead of: ${name}`);
     }

package/dist/transport/index.d.ts

@@ -0,0 +1 @@
+export { WhisperMessageEncoder } from '../session/cipher/encoding';

package/dist/transport/index.js

@@ -0,0 +1 @@
+export { WhisperMessageEncoder } from '../session/cipher/encoding';

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { assertUint8, toBase64, fromBase64, u8 } from '../session/utils';
+export { enqueue } from '../job_queue';

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+export { assertUint8, toBase64, fromBase64, u8 } from '../session/utils';
+export { enqueue } from '../job_queue';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unknownncat/swt-libsignal",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "Libsignal reimplementation using libsodium",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,11 +33,9 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@protobuf-ts/runtime": "^2.11.1",
     "libsodium-wrappers": "^0.8.2"
   },
   "devDependencies": {
-    "@protobuf-ts/plugin": "^2.11.1",
     "@types/node": "^20.19.33",
     "@vitest/coverage-v8": "^2.0.0",
     "cpy-cli": "^7.0.0",

package/dist/generated/WhisperTextProtocol.d.ts

@@ -1,49 +0,0 @@
-import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from "@protobuf-ts/runtime";
-import type { PartialMessage } from "@protobuf-ts/runtime";
-import { MessageType } from "@protobuf-ts/runtime";
-export interface WhisperMessage {
-    ephemeralKey?: Uint8Array;
-    counter?: number;
-    previousCounter?: number;
-    ciphertext?: Uint8Array;
-}
-export interface PreKeyWhisperMessage {
-    registrationId?: number;
-    preKeyId?: number;
-    signedPreKeyId?: number;
-    baseKey?: Uint8Array;
-    identityKey?: Uint8Array;
-    message?: Uint8Array;
-}
-export interface KeyExchangeMessage {
-    id?: number;
-    baseKey?: Uint8Array;
-    ephemeralKey?: Uint8Array;
-    identityKey?: Uint8Array;
-    baseKeySignature?: Uint8Array;
-}
-declare class WhisperMessage$Type extends MessageType<WhisperMessage> {
-    constructor();
-    create(value?: PartialMessage<WhisperMessage>): WhisperMessage;
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WhisperMessage): WhisperMessage;
-    internalBinaryWrite(message: WhisperMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
-}
-export declare const WhisperMessage: WhisperMessage$Type;
-declare class PreKeyWhisperMessage$Type extends MessageType<PreKeyWhisperMessage> {
-    constructor();
-    create(value?: PartialMessage<PreKeyWhisperMessage>): PreKeyWhisperMessage;
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PreKeyWhisperMessage): PreKeyWhisperMessage;
-    internalBinaryWrite(message: PreKeyWhisperMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
-}
-export declare const PreKeyWhisperMessage: PreKeyWhisperMessage$Type;
-declare class KeyExchangeMessage$Type extends MessageType<KeyExchangeMessage> {
-    constructor();
-    create(value?: PartialMessage<KeyExchangeMessage>): KeyExchangeMessage;
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: KeyExchangeMessage): KeyExchangeMessage;
-    internalBinaryWrite(message: KeyExchangeMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
-}
-export declare const KeyExchangeMessage: KeyExchangeMessage$Type;
-export {};

package/dist/generated/WhisperTextProtocol.js

@@ -1,199 +0,0 @@
-import { WireType } from "@protobuf-ts/runtime";
-import { UnknownFieldHandler } from "@protobuf-ts/runtime";
-import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MessageType } from "@protobuf-ts/runtime";
-class WhisperMessage$Type extends MessageType {
-    constructor() {
-        super("textsecure.WhisperMessage", [
-            { no: 1, name: "ephemeral_key", kind: "scalar", opt: true, T: 12 },
-            { no: 2, name: "counter", kind: "scalar", opt: true, T: 13 },
-            { no: 3, name: "previous_counter", kind: "scalar", opt: true, T: 13 },
-            { no: 4, name: "ciphertext", kind: "scalar", opt: true, T: 12 }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case 1:
-                    message.ephemeralKey = reader.bytes();
-                    break;
-                case 2:
-                    message.counter = reader.uint32();
-                    break;
-                case 3:
-                    message.previousCounter = reader.uint32();
-                    break;
-                case 4:
-                    message.ciphertext = reader.bytes();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        if (message.ephemeralKey !== undefined)
-            writer.tag(1, WireType.LengthDelimited).bytes(message.ephemeralKey);
-        if (message.counter !== undefined)
-            writer.tag(2, WireType.Varint).uint32(message.counter);
-        if (message.previousCounter !== undefined)
-            writer.tag(3, WireType.Varint).uint32(message.previousCounter);
-        if (message.ciphertext !== undefined)
-            writer.tag(4, WireType.LengthDelimited).bytes(message.ciphertext);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-export const WhisperMessage = new WhisperMessage$Type();
-class PreKeyWhisperMessage$Type extends MessageType {
-    constructor() {
-        super("textsecure.PreKeyWhisperMessage", [
-            { no: 5, name: "registration_id", kind: "scalar", opt: true, T: 13 },
-            { no: 1, name: "pre_key_id", kind: "scalar", opt: true, T: 13 },
-            { no: 6, name: "signed_pre_key_id", kind: "scalar", opt: true, T: 13 },
-            { no: 2, name: "base_key", kind: "scalar", opt: true, T: 12 },
-            { no: 3, name: "identity_key", kind: "scalar", opt: true, T: 12 },
-            { no: 4, name: "message", kind: "scalar", opt: true, T: 12 }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case 5:
-                    message.registrationId = reader.uint32();
-                    break;
-                case 1:
-                    message.preKeyId = reader.uint32();
-                    break;
-                case 6:
-                    message.signedPreKeyId = reader.uint32();
-                    break;
-                case 2:
-                    message.baseKey = reader.bytes();
-                    break;
-                case 3:
-                    message.identityKey = reader.bytes();
-                    break;
-                case 4:
-                    message.message = reader.bytes();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        if (message.preKeyId !== undefined)
-            writer.tag(1, WireType.Varint).uint32(message.preKeyId);
-        if (message.baseKey !== undefined)
-            writer.tag(2, WireType.LengthDelimited).bytes(message.baseKey);
-        if (message.identityKey !== undefined)
-            writer.tag(3, WireType.LengthDelimited).bytes(message.identityKey);
-        if (message.message !== undefined)
-            writer.tag(4, WireType.LengthDelimited).bytes(message.message);
-        if (message.registrationId !== undefined)
-            writer.tag(5, WireType.Varint).uint32(message.registrationId);
-        if (message.signedPreKeyId !== undefined)
-            writer.tag(6, WireType.Varint).uint32(message.signedPreKeyId);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-export const PreKeyWhisperMessage = new PreKeyWhisperMessage$Type();
-class KeyExchangeMessage$Type extends MessageType {
-    constructor() {
-        super("textsecure.KeyExchangeMessage", [
-            { no: 1, name: "id", kind: "scalar", opt: true, T: 13 },
-            { no: 2, name: "base_key", kind: "scalar", opt: true, T: 12 },
-            { no: 3, name: "ephemeral_key", kind: "scalar", opt: true, T: 12 },
-            { no: 4, name: "identity_key", kind: "scalar", opt: true, T: 12 },
-            { no: 5, name: "base_key_signature", kind: "scalar", opt: true, T: 12 }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case 1:
-                    message.id = reader.uint32();
-                    break;
-                case 2:
-                    message.baseKey = reader.bytes();
-                    break;
-                case 3:
-                    message.ephemeralKey = reader.bytes();
-                    break;
-                case 4:
-                    message.identityKey = reader.bytes();
-                    break;
-                case 5:
-                    message.baseKeySignature = reader.bytes();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        if (message.id !== undefined)
-            writer.tag(1, WireType.Varint).uint32(message.id);
-        if (message.baseKey !== undefined)
-            writer.tag(2, WireType.LengthDelimited).bytes(message.baseKey);
-        if (message.ephemeralKey !== undefined)
-            writer.tag(3, WireType.LengthDelimited).bytes(message.ephemeralKey);
-        if (message.identityKey !== undefined)
-            writer.tag(4, WireType.LengthDelimited).bytes(message.identityKey);
-        if (message.baseKeySignature !== undefined)
-            writer.tag(5, WireType.LengthDelimited).bytes(message.baseKeySignature);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-export const KeyExchangeMessage = new KeyExchangeMessage$Type();