@hiveio/dhive 1.2.5 → 1.2.6

package/lib/chain/deserializer.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="node" />
 import * as ByteBuffer from 'bytebuffer';
 export declare type Deserializer = (buffer: ByteBuffer) => void;
 export declare const types: {
-    EncryptedMemoD: (buf: Buffer | ByteBuffer) => {};
+    EncryptedMemoD: any;
 };

package/lib/chain/serializer.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 /**
  * @file Hive protocol serialization.
  * @author Johan Nordberg <code@johan-nordberg.com>
@@ -33,6 +32,7 @@
  * You acknowledge that this software is not designed, licensed or intended for use
  * in the design, construction, operation or maintenance of any military facility.
  */
+/// <reference types="node" />
 import * as ByteBuffer from 'bytebuffer';
 import { PublicKey } from '../crypto';
 import { Asset } from './asset';
@@ -74,5 +74,5 @@ export declare const Types: {
     UInt32: (buffer: ByteBuffer, data: number) => void;
     UInt64: (buffer: ByteBuffer, data: number) => void;
     UInt8: (buffer: ByteBuffer, data: number) => void;
-    Void: () => never;
+    Void: (buffer: ByteBuffer) => never;
 };

package/lib/chain/serializer.js

@@ -1,9 +1,43 @@
 "use strict";
+/**
+ * @file Hive protocol serialization.
+ * @author Johan Nordberg <code@johan-nordberg.com>
+ * @license
+ * Copyright (c) 2017 Johan Nordberg. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *  1. Redistribution of source code must retain the above copyright notice, this
+ *     list of conditions and the following disclaimer.
+ *
+ *  2. Redistribution in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *
+ *  3. Neither the name of the copyright holder nor the names of its contributors
+ *     may be used to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * You acknowledge that this software is not designed, licensed or intended for use
+ * in the design, construction, operation or maintenance of any military facility.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = require("../crypto");
 const asset_1 = require("./asset");
 const misc_1 = require("./misc");
-const VoidSerializer = () => {
+const VoidSerializer = (buffer) => {
     throw new Error('Void can not be serialized');
 };
 const StringSerializer = (buffer, data) => {
@@ -144,13 +178,6 @@ const ChainPropertiesSerializer = ObjectSerializer([
     ['maximum_block_size', UInt32Serializer],
     ['hbd_interest_rate', UInt16Serializer]
 ]);
-const EncryptedMemoSerializer = ObjectSerializer([
-    ['from', PublicKeySerializer],
-    ['to', PublicKeySerializer],
-    ['nonce', UInt64Serializer],
-    ['check', UInt32Serializer],
-    ['encrypted', BinarySerializer()]
-]);
 const OperationDataSerializer = (operationId, definitions) => {
     const objectSerializer = ObjectSerializer(definitions);
     return (buffer, data) => {
@@ -503,6 +530,13 @@ const TransactionSerializer = ObjectSerializer([
     ['operations', ArraySerializer(OperationSerializer)],
     ['extensions', ArraySerializer(StringSerializer)]
 ]);
+const EncryptedMemoSerializer = ObjectSerializer([
+    ['from', PublicKeySerializer],
+    ['to', PublicKeySerializer],
+    ['nonce', UInt64Serializer],
+    ['check', UInt32Serializer],
+    ['encrypted', BinarySerializer()]
+]);
 exports.Types = {
     Array: ArraySerializer,
     Asset: AssetSerializer,

package/lib/client.d.ts

@@ -154,11 +154,11 @@ export declare class Client {
      * Address prefix for current network.
      */
     readonly addressPrefix: string;
-    currentAddress: string;
     private timeout;
     private backoff;
     private failoverThreshold;
     private consoleOnFailover;
+    currentAddress: string;
     /**
      * @param address The address to the Hive RPC server,
      * e.g. `https://api.hive.blog`. or [`https://api.hive.blog`, `https://another.api.com`]

package/lib/crypto.js

@@ -35,10 +35,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert = require("assert");
+const crypto_1 = require("crypto");
 const bigInteger = require("bigi");
 const bs58 = require("bs58");
 const ByteBuffer = require("bytebuffer");
-const crypto_1 = require("crypto");
 const ecurve = require("ecurve");
 const Ripemd160 = require("ripemd160");
 const secp256k1 = require("secp256k1");

package/lib/helpers/aes.d.ts

@@ -1,26 +1,4 @@
+/// <reference types="node" />
 import { PrivateKey, PublicKey } from '../crypto';
-/**
- * Spec: http://peakd.com/steem/@dantheman/how-to-encrypt-a-memo-when-transferring-steem
- * @throws {Error|TypeError} - "Invalid Key, ..."
- * @param {PrivateKey} private_key - required and used for decryption
- * @param {PublicKey} public_key - required and used to calcualte the shared secret
- * @param message - message to be encrypted
- * @param {string} [nonce = uniqueNonce()] - assigned a random unique uint64
- *
- * @return {object}
- * @property {string} nonce - random or unique uint64, provides entropy when re-using the same private/public keys.
- * @property {Buffer} message - Plain text message
- * @property {number} checksum - shared secret checksum
- */
-export declare function encrypt(private_key: PrivateKey, public_key: PublicKey, message: any, nonce: any): any;
-/**
- * Spec: http://peakd.com/steem/@dantheman/how-to-encrypt-a-memo-when-transferring-steem
- * @arg {PrivateKey} private_key - required and used for decryption
- * @arg {PublicKey} public_key - required and used to calcualte the shared secret
- * @arg {string} nonce - random or unique uint64, provides entropy when re-using the same private/public keys.
- * @arg {Buffer} message - Encrypted or plain text message
- * @arg {number} checksum - shared secret checksum
- *  @throws {Error|TypeError} - "Invalid Key, ..."
- *  @return {Buffer} - message
- */
-export declare function decrypt(private_key: PrivateKey, public_key: PublicKey, nonce: any, message: any, checksum: number): string;
+export declare const encrypt: (private_key: PrivateKey, public_key: PublicKey, message: Buffer, nonce?: string) => any;
+export declare const decrypt: (private_key: PrivateKey, public_key: PublicKey, nonce: any, message: any, checksum: number) => any;

package/lib/helpers/aes.js

@@ -4,113 +4,79 @@ const assert = require("assert");
 const crypto_1 = require("crypto");
 const ByteBuffer = require('bytebuffer');
 const Long = ByteBuffer.Long;
-/**
- * Spec: http://peakd.com/steem/@dantheman/how-to-encrypt-a-memo-when-transferring-steem
- * @throws {Error|TypeError} - "Invalid Key, ..."
- * @param {PrivateKey} private_key - required and used for decryption
- * @param {PublicKey} public_key - required and used to calcualte the shared secret
- * @param message - message to be encrypted
- * @param {string} [nonce = uniqueNonce()] - assigned a random unique uint64
- *
- * @return {object}
- * @property {string} nonce - random or unique uint64, provides entropy when re-using the same private/public keys.
- * @property {Buffer} message - Plain text message
- * @property {number} checksum - shared secret checksum
- */
-function encrypt(private_key, public_key, message, nonce) {
-    // Change message to varint32 prefixed encoded string
-    const mbuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-    mbuf.writeVString(message);
-    message = Buffer.from(mbuf.flip().toBinary());
-    return crypt(private_key, public_key, uniqueNonce(), message);
-}
-exports.encrypt = encrypt;
-/**
- * Spec: http://peakd.com/steem/@dantheman/how-to-encrypt-a-memo-when-transferring-steem
- * @arg {PrivateKey} private_key - required and used for decryption
- * @arg {PublicKey} public_key - required and used to calcualte the shared secret
- * @arg {string} nonce - random or unique uint64, provides entropy when re-using the same private/public keys.
- * @arg {Buffer} message - Encrypted or plain text message
- * @arg {number} checksum - shared secret checksum
- *  @throws {Error|TypeError} - "Invalid Key, ..."
- *  @return {Buffer} - message
- */
-function decrypt(private_key, public_key, nonce, message, checksum) {
-    return crypt(private_key, public_key, nonce, message, checksum).message;
-}
-exports.decrypt = decrypt;
+exports.encrypt = (private_key, public_key, message, nonce = uniqueNonce()) => crypt(private_key, public_key, nonce, message);
+exports.decrypt = (private_key, public_key, nonce, message, checksum) => crypt(private_key, public_key, nonce, message, checksum).message;
 /**
  * @arg {Buffer} message - Encrypted or plain text message (see checksum)
  * @arg {number} checksum - shared secret checksum (null to encrypt, non-null to decrypt)
  */
-function crypt(private_key, public_key, nonce, message, checksum) {
-    nonce = toLongObj(nonce);
-    // Appending nonce to buffer "ebuf" and rehash with sha512
+const crypt = (private_key, public_key, nonce, message, checksum) => {
+    const nonceL = toLongObj(nonce);
+    //   const bufferMessage = Buffer.from(messageString, 'binary')
     const S = private_key.get_shared_secret(public_key);
     let ebuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-    ebuf.writeUint64(nonce);
+    ebuf.writeUint64(nonceL);
     ebuf.append(S.toString('binary'), 'binary');
     ebuf = Buffer.from(ebuf.copy(0, ebuf.offset).toBinary(), 'binary');
     const encryption_key = crypto_1.createHash('sha512').update(ebuf).digest();
     const iv = encryption_key.slice(32, 48);
     const tag = encryption_key.slice(0, 32);
     // check if first 64 bit of sha256 hash treated as uint64_t truncated to 32 bits.
-    let check = crypto_1.createHash('sha256').update(encryption_key).digest();
-    check = check.slice(0, 4);
-    const cbuf = ByteBuffer.fromBinary(check.toString('binary'), ByteBuffer.LITTLE_ENDIAN);
-    check = cbuf.readUint32();
+    const check = crypto_1.createHash('sha256').update(encryption_key).digest().slice(0, 4);
+    const cbuf = ByteBuffer.fromBinary(check.toString('binary'), ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    ByteBuffer.fromBinary(check.toString('binary'), ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    const check32 = cbuf.readUint32();
     if (checksum) {
-        if (check !== checksum) {
-            throw new Error('Invalid nonce');
+        if (check32 !== checksum) {
+            throw new Error('Invalid key');
         }
         message = cryptoJsDecrypt(message, tag, iv);
     }
     else {
         message = cryptoJsEncrypt(message, tag, iv);
     }
-    return { nonce, message, checksum: check };
-}
+    return { nonce: nonceL, message, checksum: check32 };
+};
 /**
  * This method does not use a checksum, the returned data must be validated some other way.
  * @arg {string|Buffer} ciphertext - binary format
  * @return {Buffer} the decrypted message
  */
-function cryptoJsDecrypt(message, tag, iv) {
+const cryptoJsDecrypt = (message, tag, iv) => {
     assert(message, 'Missing cipher text');
-    message = toBinaryBuffer(message);
+    let messageBuffer = message;
     const decipher = crypto_1.createDecipheriv('aes-256-cbc', tag, iv);
-    message = Buffer.concat([decipher.update(message), decipher.final()]);
-    return message;
-}
+    messageBuffer = Buffer.concat([decipher.update(messageBuffer), decipher.final()]);
+    return messageBuffer;
+};
 /**
  * This method does not use a checksum, the returned data must be validated some other way.
  * @arg {string|Buffer} plaintext - binary format
  * @return {Buffer} binary
  */
-function cryptoJsEncrypt(message, tag, iv) {
+const cryptoJsEncrypt = (message, tag, iv) => {
     assert(message, 'Missing plain text');
-    message = toBinaryBuffer(message);
+    let messageBuffer = message;
     const cipher = crypto_1.createCipheriv('aes-256-cbc', tag, iv);
-    message = Buffer.concat([cipher.update(message), cipher.final()]);
-    return message;
-}
+    messageBuffer = Buffer.concat([cipher.update(messageBuffer), cipher.final()]);
+    return messageBuffer;
+};
 /** @return {string} unique 64 bit unsigned number string.  Being time based,
  * this is careful to never choose the same nonce twice.  This value could
  * clsbe recorded in the blockchain for a long time.
  */
 let unique_nonce_entropy = null;
-function uniqueNonce() {
+const uniqueNonce = () => {
     if (unique_nonce_entropy === null) {
         const uint8randomArr = new Uint8Array(2);
         for (let i = 0; i < 2; ++i) {
             uint8randomArr[i] = crypto_1.randomBytes(2).readUInt8(i);
         }
-        unique_nonce_entropy = uint8randomArr[0] << 8 | uint8randomArr[1];
+        unique_nonce_entropy = Math.round((uint8randomArr[0] << 8) | uint8randomArr[1]);
     }
     let long = Long.fromNumber(Date.now());
-    const entropy = ++unique_nonce_entropy % 0xFFFF;
+    const entropy = ++unique_nonce_entropy % 0xffff;
     long = long.shiftLeft(16).or(Long.fromNumber(entropy));
     return long.toString();
-}
-const toLongObj = o => (o ? Long.isLong(o) ? o : Long.fromString(o) : o);
-const toBinaryBuffer = o => (o ? Buffer.isBuffer(o) ? o : Buffer.from(o, 'binary') : o);
+};
+const toLongObj = (o) => (o ? (Long.isLong(o) ? o : Long.fromString(o)) : o);

package/lib/index.d.ts

@@ -46,7 +46,6 @@ export * from './chain/comment';
 export * from './chain/misc';
 export * from './chain/operation';
 export * from './chain/serializer';
-export * from './chain/deserializer';
 export * from './chain/transaction';
 export * from './chain/hivemind';
 export * from './client';

package/lib/index.js

@@ -48,7 +48,6 @@ __export(require("./chain/account"));
 __export(require("./chain/asset"));
 __export(require("./chain/misc"));
 __export(require("./chain/serializer"));
-__export(require("./chain/deserializer"));
 __export(require("./client"));
 __export(require("./crypto"));
 __export(require("./memo"));

package/lib/memo.d.ts

@@ -1,20 +1,5 @@
 import { PrivateKey, PublicKey } from './crypto';
-/**
- * Memo/Any message encoding using AES (aes-cbc algorithm)
- * @param {Buffer|String} private_key Privatekey of sender
- * @param {Buffer|String}public_key publickey of recipient
- * @param {String}memo message to be encrypted
- * @param {Number}testNonce nonce with high entropy
- */
-declare function encode(private_key: PrivateKey | string, public_key: PublicKey | string, memo: string, testNonce?: number): string;
-/**
- * Encrypted memo/message decryption
- * @param {Buffer|string}private_key Privatekey of recipient
- * @param {any}memo Encrypted message/memo
- */
-declare function decode(private_key: PrivateKey | string, memo: any): any;
 export declare const Memo: {
-    decode: typeof decode;
-    encode: typeof encode;
+    decode: (private_key: string | PrivateKey, memo: string) => string;
+    encode: (private_key: string | PrivateKey, public_key: string | PublicKey, memo: string, testNonce?: string | undefined) => string;
 };
-export {};

package/lib/memo.js

@@ -8,51 +8,56 @@ const crypto_1 = require("./crypto");
 const Aes = require("./helpers/aes");
 /**
  * Memo/Any message encoding using AES (aes-cbc algorithm)
- * @param {Buffer|String} private_key Privatekey of sender
- * @param {Buffer|String}public_key publickey of recipient
- * @param {String}memo message to be encrypted
- * @param {Number}testNonce nonce with high entropy
+ * @param {Buffer|string} private_key Private memo key of sender
+ * @param {Buffer|string} public_key public memo key of recipient
+ * @param {string} memo message to be encrypted
+ * @param {number} testNonce nonce with high entropy
  */
-function encode(private_key, public_key, memo, testNonce) {
+const encode = (private_key, public_key, memo, testNonce) => {
     if (!memo.startsWith('#')) {
         return memo;
     }
     memo = memo.substring(1);
+    checkEncryption();
     private_key = toPrivateObj(private_key);
     public_key = toPublicObj(public_key);
-    const { nonce, message, checksum } = Aes.encrypt(private_key, public_key, memo, testNonce);
     const mbuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
-    serializer_1.Types.EncryptedMemo(mbuf, {
+    mbuf.writeVString(memo);
+    const memoBuffer = Buffer.from(mbuf.copy(0, mbuf.offset).toBinary(), 'binary');
+    const { nonce, message, checksum } = Aes.encrypt(private_key, public_key, memoBuffer, testNonce);
+    const mbuf2 = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    serializer_1.Types.EncryptedMemo(mbuf2, {
         check: checksum,
         encrypted: message,
         from: private_key.createPublic(),
         nonce,
         to: public_key
     });
-    mbuf.flip();
-    const data = Buffer.from(mbuf.toBuffer());
+    mbuf2.flip();
+    const data = Buffer.from(mbuf2.toBuffer());
     return '#' + bs58.encode(data);
-}
+};
 /**
  * Encrypted memo/message decryption
- * @param {Buffer|string}private_key Privatekey of recipient
- * @param {any}memo Encrypted message/memo
+ * @param {PrivateKey|string} private_key Private memo key of recipient
+ * @param {string}memo Encrypted message/memo
  */
-function decode(private_key, memo) {
+const decode = (private_key, memo) => {
     if (!memo.startsWith('#')) {
         return memo;
     }
     memo = memo.substring(1);
-    // checkEncryption()
+    checkEncryption();
     private_key = toPrivateObj(private_key);
     memo = bs58.decode(memo);
-    memo = deserializer_1.types.EncryptedMemoD(Buffer.from(memo, 'binary'));
-    const { from, to, nonce, check, encrypted } = memo;
+    let memoBuffer = deserializer_1.types.EncryptedMemoD(Buffer.from(memo, 'binary'));
+    const { from, to, nonce, check, encrypted } = memoBuffer;
     const pubkey = private_key.createPublic().toString();
-    const otherpub = pubkey === new crypto_1.PublicKey(from.key).toString() ? new crypto_1.PublicKey(to.key) : new crypto_1.PublicKey(from.key);
-    memo = Aes.decrypt(private_key, otherpub, nonce, encrypted, check);
-    // remove varint length prefix
-    const mbuf = ByteBuffer.fromBinary(memo.toString('binary'), ByteBuffer.LITTLE_ENDIAN);
+    const otherpub = pubkey === new crypto_1.PublicKey(from.key).toString()
+        ? new crypto_1.PublicKey(to.key)
+        : new crypto_1.PublicKey(from.key);
+    memoBuffer = Aes.decrypt(private_key, otherpub, nonce, encrypted, check);
+    const mbuf = ByteBuffer.fromBinary(memoBuffer.toString('binary'), ByteBuffer.LITTLE_ENDIAN);
     try {
         mbuf.mark();
         return '#' + mbuf.readVString();
@@ -63,9 +68,31 @@ function decode(private_key, memo) {
         memo = Buffer.from(mbuf.toString('binary'), 'binary').toString('utf-8');
         return '#' + memo;
     }
-}
-const toPrivateObj = (o) => (o ? o.key ? o : crypto_1.PrivateKey.fromString(o) : o /* null or undefined*/);
-const toPublicObj = (o) => (o ? o.key ? o : crypto_1.PublicKey.fromString(o) : o /* null or undefined*/);
+};
+let encodeTest;
+const checkEncryption = () => {
+    if (encodeTest === undefined) {
+        let plaintext;
+        encodeTest = true; // prevent infinate looping
+        try {
+            const wif = '5JdeC9P7Pbd1uGdFVEsJ41EkEnADbbHGq6p1BwFxm6txNBsQnsw';
+            const pubkey = 'STM8m5UgaFAAYQRuaNejYdS8FVLVp9Ss3K1qAVk5de6F8s3HnVbvA';
+            const cyphertext = encode(wif, pubkey, '#memo爱');
+            plaintext = decode(wif, cyphertext);
+        }
+        catch (e) {
+            throw new Error(e);
+        }
+        finally {
+            encodeTest = plaintext === '#memo爱';
+        }
+    }
+    if (encodeTest === false) {
+        throw new Error('This environment does not support encryption.');
+    }
+};
+const toPrivateObj = (o) => o ? (o.key ? o : crypto_1.PrivateKey.fromString(o)) : o; /* null or undefined*/
+const toPublicObj = (o) => o ? (o.key ? o : crypto_1.PublicKey.fromString(o)) : o; /* null or undefined*/
 exports.Memo = {
     decode,
     encode

package/lib/version.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = '1.2.5';
+exports.default = '1.2.6';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiveio/dhive",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "Hive blockchain RPC client library",
   "author": "hive-network",
   "license": "BSD-3-Clause-No-Military-License",