@freesignal/protocol 0.2.9 → 0.2.11

package/test.js

@@ -1,30 +1,25 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require(".");
-const crypto_1 = __importDefault(require("@freesignal/crypto"));
 const utils_1 = require("@freesignal/utils");
-const bob = (0, _1.createKeyExchange)(crypto_1.default.EdDSA.keyPair().secretKey, crypto_1.default.ECDH.keyPair().secretKey);
-const alice = (0, _1.createKeyExchange)(crypto_1.default.EdDSA.keyPair().secretKey, crypto_1.default.ECDH.keyPair().secretKey);
-const bobmessage = bob.generateData();
-const { session: alicesession, message: aliceack } = alice.digestData(bobmessage);
-bob.digestMessage(aliceack).then(({ session: bobsession, identityKeys }) => {
-    var _a;
-    if (bobsession && identityKeys) {
-        console.log("Session established successfully between Alice and Bob.");
-        const datagram = _1.Datagram.create(bob.signatureKey, alice.signatureKey, _1.Protocols.MESSAGE, (_a = bobsession.encrypt((0, utils_1.encodeUTF8)("Hi Alice!"))) === null || _a === void 0 ? void 0 : _a.encode());
-        //console.log(datagram.payload);
-        const msg = datagram.encode();
-        console.log((0, utils_1.decodeUTF8)(alicesession.decrypt(_1.Datagram.from(msg).payload)));
-        if (alicesession.handshaked && bobsession.handshaked)
-            console.log("Successfully handshaked");
-        else
-            console.log("Error during handshake");
-        const longmsg = _1.Datagram.create(alice.signatureKey, bob.signatureKey, _1.Protocols.MESSAGE, alicesession.encrypt(new Uint8Array(1000000).fill(33).map(val => val + Math.floor(Math.random() * 93))));
-        console.log(longmsg.encode().length);
-    }
-    else
-        console.log("Error");
-});
+const _1 = require(".");
+const node_1 = require("./node");
+const bob = new node_1.FreeSignalNode({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap() });
+const alice = new node_1.FreeSignalNode({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap() });
+setImmediate(() => __awaiter(void 0, void 0, void 0, function* () {
+    const aliceHandshake = yield alice.sendHandshake(yield bob.generateKeyData());
+    yield bob.receive(aliceHandshake);
+    console.log("Session established successfully between Alice and Bob.");
+    const data = (yield bob.encrypt(alice.userId.toString(), _1.Protocols.MESSAGE, (0, utils_1.encodeData)("Hi Alice!"))).toBytes();
+    console.log((0, utils_1.decodeData)(yield alice.receive(data)));
+    const longmsg = yield alice.sendData(bob.userId.toString(), new Uint8Array(1000000).fill(33).map(val => val + Math.floor(Math.random() * 93)));
+    console.log(longmsg.toBytes().length);
+}));

package/types.d.ts

@@ -16,43 +16,47 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
-import { Encodable } from "@freesignal/interfaces";
-export type UserId = string;
-export declare namespace UserId {
-    class UserIdConstructor {
-        private readonly array;
-        constructor(array: Uint8Array);
-        toString(): string;
-        toJSON(): string;
-        toUint8Array(): Uint8Array;
-    }
-    export function getUserId(publicKey: string | Uint8Array): UserIdConstructor;
-    export function from(userId: string | Uint8Array): UserIdConstructor;
-    export {};
+import { LocalStorage, Encodable } from "@freesignal/interfaces";
+export declare class UserId {
+    private readonly array;
+    private constructor();
+    toString(): string;
+    toJSON(): string;
+    toUint8Array(): Uint8Array;
+    static fromKey(identityKey: string | Uint8Array | IdentityKey): UserId;
+    static from(userId: string | Uint8Array | UserId): UserId;
+}
+export interface IdentityKey extends Encodable {
+    readonly info: number;
+    readonly signatureKey: Uint8Array;
+    readonly exchangeKey: Uint8Array;
+}
+export declare namespace IdentityKey {
+    const keyLength: number;
+    const version = 1;
+    function isIdentityKeys(obj: any): boolean;
+    function from(identityKey: IdentityKey | Uint8Array | string): IdentityKey;
+    function from(signatureKey: Uint8Array | string, exchangeKey: Uint8Array | string): IdentityKey;
 }
-export interface IdentityKeys {
-    readonly publicKey: string;
-    readonly identityKey: string;
+export interface PrivateIdentityKey {
+    readonly info: number;
+    readonly signatureKey: Uint8Array;
+    readonly exchangeKey: Uint8Array;
+    readonly identityKey: IdentityKey;
 }
-export declare namespace IdentityKeys {
-    export const keyLength: number;
-    class IdentityKeysConstructor implements IdentityKeys, Encodable {
-        readonly publicKey: string;
-        readonly identityKey: string;
-        constructor(identityKeys: IdentityKeys | Uint8Array | string);
-        encode(): Uint8Array;
-        toString(): string;
-        toJSON(): string;
-    }
-    export function isIdentityKeys(obj: any): boolean;
-    export function from(identityKeys: IdentityKeys): IdentityKeysConstructor;
-    export {};
+export declare namespace PrivateIdentityKey {
+    const keyLength: number;
+    const version = 1;
+    function isIdentityKeys(obj: any): boolean;
+    function from(identityKey: PrivateIdentityKey | Uint8Array | string): PrivateIdentityKey;
+    function from(signatureKey: Uint8Array | string, exchangeKey: Uint8Array | string): PrivateIdentityKey;
 }
 export declare enum Protocols {
     NULL = "",
     MESSAGE = "/freesignal/message",
     RELAY = "/freesignal/relay",
-    HANDSHAKE = "/freesignal/handshake"
+    HANDSHAKE = "/freesignal/handshake",
+    DISCOVER = "/freesignal/discover"
 }
 export declare namespace Protocols {
     function isProtocol(protocol: any): boolean;
@@ -61,44 +65,31 @@ export declare namespace Protocols {
     function encode(protocol: Protocols, length?: number): Uint8Array;
     function decode(array: Uint8Array): Protocols;
 }
-export interface Datagram {
-    readonly id: string;
-    readonly version: number;
+export declare class Datagram implements Encodable {
+    static version: number;
+    private _id;
+    private _version;
     readonly sender: string;
     readonly receiver: string;
     readonly protocol: Protocols;
-    readonly createdAt: number;
-    payload?: Uint8Array;
-    readonly signature?: string;
-}
-export declare namespace Datagram {
-    export const version = 1;
-    class DatagramConstructor implements Encodable, Datagram {
-        readonly id: string;
-        readonly version: number;
-        readonly sender: UserId;
-        readonly receiver: UserId;
-        readonly protocol: Protocols;
-        readonly createdAt: number;
-        _payload?: Uint8Array;
-        _signature?: Uint8Array;
-        private secretKey?;
-        private static headerOffset;
-        constructor(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable);
-        constructor(data: Uint8Array | Datagram);
-        get signed(): boolean;
-        get signature(): string | undefined;
-        set payload(data: Uint8Array);
-        get payload(): Uint8Array | undefined;
-        encode(): Uint8Array;
-        sign(secretKey: Uint8Array): this;
-        toString(): string;
-        toJSON(): string;
-    }
-    export function create(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable): DatagramConstructor;
-    export function isDatagram(obj: any): boolean;
-    export function from(data: Uint8Array | Datagram | string): DatagramConstructor;
-    export {};
+    private _createdAt;
+    private _payload?;
+    private _signature?;
+    private secretKey?;
+    private static headerOffset;
+    constructor(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable);
+    get id(): string;
+    get version(): number;
+    get createdAt(): number;
+    get signed(): boolean;
+    get signature(): string | undefined;
+    set payload(data: Uint8Array);
+    get payload(): Uint8Array | undefined;
+    toBytes(): Uint8Array;
+    sign(secretKey: Uint8Array): this;
+    toString(): string;
+    toJSON(): string;
+    static from(data: Uint8Array | Datagram | string): Datagram;
 }
 /**
  * Interface representing an encrypted payload.
@@ -136,7 +127,7 @@ export interface EncryptedData extends Encodable {
     /**
      * Serializes the payload into a Uint8Array for transport.
      */
-    encode(): Uint8Array;
+    toBytes(): Uint8Array;
     /**
      * Returns the payload as a Base64 string.
      */
@@ -162,74 +153,13 @@ export declare class EncryptedData {
      */
     static from(array: Uint8Array | EncryptedData): EncryptedData;
 }
-export declare class EncryptedDataConstructor implements EncryptedData {
-    static readonly secretKeyLength: number;
-    static readonly publicKeyLength: number;
-    static readonly keyLength: number;
-    static readonly nonceLength: number;
-    static readonly maxCount = 65536;
-    static readonly countLength = 2;
-    private raw;
-    constructor(count: number | Uint8Array, previous: number | Uint8Array, publicKey: Uint8Array, nonce: Uint8Array, ciphertext: Uint8Array, version?: number | Uint8Array);
-    constructor(encrypted: Uint8Array | EncryptedData);
-    get length(): number;
-    get version(): number;
-    get count(): number;
-    get previous(): number;
-    get publicKey(): Uint8Array;
-    get nonce(): Uint8Array;
-    get ciphertext(): Uint8Array;
-    encode(): Uint8Array;
-    toString(): string;
-    toJSON(): {
-        version: number;
-        count: number;
-        previous: number;
-        publicKey: string;
-        nonce: string;
-        ciphertext: string;
-    };
-}
-declare enum DataType {
-    UKNOWN = -1,
-    RAW = 0,
-    NUMBER = 1,
-    STRING = 2,
-    ARRAY = 3,
-    OBJECT = 4
-}
-declare namespace DataType {
-    function getType(type: string): DataType;
-    function getName(type: DataType): string;
-    function from(data: any): DataType;
-}
-export declare class DataEncoder<T> implements Encodable {
-    readonly data: T;
-    readonly type: string;
-    constructor(data: T);
-    protected get _type(): DataType;
-    encode(): Uint8Array;
-    toString(): string;
-    toJSON(): T;
-    static from<T = any>(array: Uint8Array): DataEncoder<T>;
-}
-export declare namespace XFreeSignal {
-    export const MIME = "application/x-freesignal";
-    export const version = 1;
-    export function encodeBody(type: 'data' | 'error', data: any, compressed?: boolean): BodyInit;
-    export function decodeBody<T = any>(body: Uint8Array): Body<T>;
-    class Body<T> implements Encodable {
-        readonly type: 'data' | 'error';
-        readonly data: T;
-        constructor(type: 'data' | 'error', data: T);
-        encode(compressed?: boolean): Uint8Array;
-        toString(): string;
-        toJSON(): {
-            type: "data" | "error";
-            data: T;
-        };
-        static from<T = any>(array: Uint8Array): Body<T>;
-    }
-    export {};
+export declare class AsyncMap<K, V> implements LocalStorage<K, V> {
+    private readonly map;
+    constructor(iterable?: Iterable<readonly [K, V]>);
+    set(key: K, value: V): Promise<void>;
+    get(key: K): Promise<V | undefined>;
+    has(key: K): Promise<boolean>;
+    delete(key: K): Promise<boolean>;
+    clear(): Promise<void>;
+    entries(): ArrayIterator<[K, V]>;
 }
-export {};