@freesignal/protocol 0.1.6 → 0.1.7

package/crypto.d.ts

@@ -16,61 +16,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
-export type HashAlgorithms = 'sha224' | 'sha256' | 'sha384' | 'sha512';
-export type HmacAlgorithms = 'kmac128' | 'kmac256';
-interface UUIDv4 {
-    toString(): string;
-    toJSON(): string;
-    toBuffer(): Uint8Array;
-}
-export interface Crypto {
-    hash(message: Uint8Array, algorithm?: HashAlgorithms): Uint8Array;
-    hmac(key: Uint8Array, message: Uint8Array, length?: number, algorithm?: HmacAlgorithms): Uint8Array;
-    hkdf(key: Uint8Array, salt: Uint8Array, info?: Uint8Array | string, length?: number): Uint8Array;
-    readonly KeyPair: typeof Crypto.KeyPair;
-    readonly box: Crypto.box;
-    readonly ECDH: Crypto.ECDH;
-    readonly EdDSA: Crypto.EdDSA;
-    readonly UUID: Crypto.UUID;
-    randomBytes(n: number): Uint8Array;
-    scalarMult(n: Uint8Array, p: Uint8Array): Uint8Array;
-}
-export declare namespace Crypto {
-    type KeyPair = {
-        readonly publicKey: Uint8Array;
-        readonly secretKey: Uint8Array;
-    };
-    namespace KeyPair {
-        function isKeyPair(obj: any): boolean;
-    }
-    interface box {
-        readonly keyLength: number;
-        readonly nonceLength: number;
-        encrypt(msg: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array;
-        decrypt(msg: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array | undefined;
-    }
-    interface ECDH {
-        readonly publicKeyLength: number;
-        readonly secretKeyLength: number;
-        keyPair(secretKey?: Uint8Array): KeyPair;
-        sharedKey(publicKey: Uint8Array, secretKey: Uint8Array): Uint8Array;
-    }
-    interface EdDSA {
-        readonly publicKeyLength: number;
-        readonly secretKeyLength: number;
-        readonly signatureLength: number;
-        readonly seedLength: number;
-        keyPair(secretKey?: Uint8Array): KeyPair;
-        keyPairFromSeed(seed: Uint8Array): KeyPair;
-        sign(msg: Uint8Array, secretKey: Uint8Array): Uint8Array;
-        verify(msg: Uint8Array, sig: Uint8Array, publicKey: Uint8Array): boolean;
-    }
-    interface UUID {
-        generate(): UUIDv4;
-        stringify(arr: Uint8Array, offset?: number): string;
-        parse(uuid: string): Uint8Array;
-    }
-}
+import { Crypto } from './types';
 declare const crypto: Crypto;
 declare namespace crypto {
     type KeyPair = Crypto.KeyPair;

package/crypto.js

@@ -21,14 +21,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Crypto = void 0;
 const js_sha3_1 = require("js-sha3");
 const tweetnacl_1 = __importDefault(require("tweetnacl"));
 const uuid_1 = require("uuid");
 const utils_1 = require("./utils");
-var Crypto;
-(function (Crypto) {
-})(Crypto || (exports.Crypto = Crypto = {}));
 class CryptoConstructor {
     constructor() {
         this.KeyPair = {

package/data.d.ts

@@ -44,7 +44,7 @@ export declare namespace Datagram {
     const version = 1;
     function create(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable): DatagramConstructor;
     function isDatagram(obj: any): boolean;
-    function from(data: Uint8Array): DatagramConstructor;
+    function from(data: Uint8Array | Datagram | string): DatagramConstructor;
 }
 declare class DatagramConstructor implements Encodable, Datagram {
     readonly id: string;

package/data.js

@@ -70,7 +70,12 @@ var Datagram;
     }
     Datagram.isDatagram = isDatagram;
     function from(data) {
-        return new DatagramConstructor(data);
+        if (typeof data === 'string') {
+            const decoded = (0, utils_1.decodeBase64)(data);
+            return new DatagramConstructor(decoded);
+        }
+        else
+            return new DatagramConstructor(data);
     }
     Datagram.from = from;
 })(Datagram || (exports.Datagram = Datagram = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",

package/types.d.ts

@@ -58,4 +58,59 @@ export interface KeyExchangeDataBundle {
     readonly signature: string;
     readonly onetimePreKey: string[];
 }
+interface UUIDv4 {
+    toString(): string;
+    toJSON(): string;
+    toBuffer(): Uint8Array;
+}
+export interface Crypto {
+    hash(message: Uint8Array, algorithm?: Crypto.HashAlgorithms): Uint8Array;
+    hmac(key: Uint8Array, message: Uint8Array, length?: number, algorithm?: Crypto.HmacAlgorithms): Uint8Array;
+    hkdf(key: Uint8Array, salt: Uint8Array, info?: Uint8Array | string, length?: number): Uint8Array;
+    readonly KeyPair: typeof Crypto.KeyPair;
+    readonly box: Crypto.box;
+    readonly ECDH: Crypto.ECDH;
+    readonly EdDSA: Crypto.EdDSA;
+    readonly UUID: Crypto.UUID;
+    randomBytes(n: number): Uint8Array;
+    scalarMult(n: Uint8Array, p: Uint8Array): Uint8Array;
+}
+export declare namespace Crypto {
+    type HashAlgorithms = 'sha224' | 'sha256' | 'sha384' | 'sha512';
+    type HmacAlgorithms = 'kmac128' | 'kmac256';
+    type KeyPair = {
+        readonly publicKey: Uint8Array;
+        readonly secretKey: Uint8Array;
+    };
+    namespace KeyPair {
+        function isKeyPair(obj: any): boolean;
+    }
+    interface box {
+        readonly keyLength: number;
+        readonly nonceLength: number;
+        encrypt(msg: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array;
+        decrypt(msg: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array | undefined;
+    }
+    interface ECDH {
+        readonly publicKeyLength: number;
+        readonly secretKeyLength: number;
+        keyPair(secretKey?: Uint8Array): KeyPair;
+        sharedKey(publicKey: Uint8Array, secretKey: Uint8Array): Uint8Array;
+    }
+    interface EdDSA {
+        readonly publicKeyLength: number;
+        readonly secretKeyLength: number;
+        readonly signatureLength: number;
+        readonly seedLength: number;
+        keyPair(secretKey?: Uint8Array): KeyPair;
+        keyPairFromSeed(seed: Uint8Array): KeyPair;
+        sign(msg: Uint8Array, secretKey: Uint8Array): Uint8Array;
+        verify(msg: Uint8Array, sig: Uint8Array, publicKey: Uint8Array): boolean;
+    }
+    interface UUID {
+        generate(): UUIDv4;
+        stringify(arr: Uint8Array, offset?: number): string;
+        parse(uuid: string): Uint8Array;
+    }
+}
 export {};

package/types.js

@@ -18,7 +18,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Encodable = void 0;
+exports.Crypto = exports.Encodable = void 0;
 var Encodable;
 (function (Encodable) {
     const properties = ['encode', 'toString', 'toJSON'];
@@ -27,3 +27,6 @@ var Encodable;
     }
     Encodable.isEncodable = isEncodable;
 })(Encodable || (exports.Encodable = Encodable = {}));
+var Crypto;
+(function (Crypto) {
+})(Crypto || (exports.Crypto = Crypto = {}));