@hiveio/dhive 1.2.4 → 1.2.5

package/lib/chain/deserializer.d.ts

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

package/lib/chain/deserializer.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ByteBuffer = require("bytebuffer");
+const crypto_1 = require("../crypto");
+const PublicKeyDeserializer = (buf) => {
+    const c = fixed_buf(buf, 33);
+    return crypto_1.PublicKey.fromBuffer(c);
+};
+const UInt64Deserializer = (b) => b.readUint64();
+const UInt32Deserializer = (b) => b.readUint32();
+const BinaryDeserializer = (b) => {
+    const len = b.readVarint32();
+    const b_copy = b.copy(b.offset, b.offset + len);
+    b.skip(len);
+    return Buffer.from(b_copy.toBinary(), 'binary');
+};
+const BufferDeserializer = (keyDeserializers) => (buf) => {
+    const obj = {};
+    for (const [key, deserializer] of keyDeserializers) {
+        try {
+            // Decodes a binary encoded string to a ByteBuffer.
+            buf = ByteBuffer.fromBinary(buf.toString('binary'), ByteBuffer.LITTLE_ENDIAN);
+            obj[key] = deserializer(buf);
+        }
+        catch (error) {
+            error.message = `${key}: ${error.message}`;
+            throw error;
+        }
+    }
+    return obj;
+};
+function fixed_buf(b, len) {
+    if (!b) {
+        throw Error('No buffer found on first parameter');
+    }
+    else {
+        const b_copy = b.copy(b.offset, b.offset + len);
+        b.skip(len);
+        return Buffer.from(b_copy.toBinary(), 'binary');
+    }
+}
+const EncryptedMemoDeserializer = BufferDeserializer([
+    ['from', PublicKeyDeserializer],
+    ['to', PublicKeyDeserializer],
+    ['nonce', UInt64Deserializer],
+    ['check', UInt32Deserializer],
+    ['encrypted', BinaryDeserializer]
+]);
+exports.types = {
+    EncryptedMemoD: EncryptedMemoDeserializer
+};

package/lib/chain/serializer.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 /**
  * @file Hive protocol serialization.
  * @author Johan Nordberg <code@johan-nordberg.com>
@@ -32,7 +33,6 @@
  * 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';
@@ -48,6 +48,9 @@ export declare const Types: {
     Binary: (size?: number | undefined) => (buffer: ByteBuffer, data: Buffer | HexBuffer) => void;
     Boolean: (buffer: ByteBuffer, data: boolean) => void;
     Date: (buffer: ByteBuffer, data: string) => void;
+    EncryptedMemo: (buffer: ByteBuffer, data: {
+        [key: string]: any;
+    }) => void;
     FlatMap: (keySerializer: Serializer, valueSerializer: Serializer) => (buffer: ByteBuffer, data: [any, any][]) => void;
     Int16: (buffer: ByteBuffer, data: number) => void;
     Int32: (buffer: ByteBuffer, data: number) => void;
@@ -71,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: (buffer: ByteBuffer) => never;
+    Void: () => never;
 };

package/lib/chain/serializer.js

@@ -1,43 +1,9 @@
 "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 = (buffer) => {
+const VoidSerializer = () => {
     throw new Error('Void can not be serialized');
 };
 const StringSerializer = (buffer, data) => {
@@ -178,6 +144,13 @@ 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) => {
@@ -537,6 +510,7 @@ exports.Types = {
     Binary: BinarySerializer,
     Boolean: BooleanSerializer,
     Date: DateSerializer,
+    EncryptedMemo: EncryptedMemoSerializer,
     FlatMap: FlatMapSerializer,
     Int16: Int16Serializer,
     Int32: Int32Serializer,

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.d.ts

@@ -33,6 +33,7 @@
  * in the design, construction, operation or maintenance of any military facility.
  */
 /// <reference types="node" />
+import * as ByteBuffer from 'bytebuffer';
 import { SignedTransaction, Transaction } from './chain/transaction';
 /**
  * Network id used in WIF-encoding.
@@ -74,9 +75,13 @@ declare function isWif(privWif: string | Buffer): boolean;
  * ECDSA (secp256k1) public key.
  */
 export declare class PublicKey {
-    readonly key: Buffer;
+    readonly key: any;
     readonly prefix: string;
-    constructor(key: Buffer, prefix?: string);
+    readonly uncompressed: Buffer;
+    constructor(key: any, prefix?: string);
+    static fromBuffer(key: ByteBuffer): {
+        key: ByteBuffer;
+    };
     /**
      * Create a new instance from a WIF-encoded key.
      */
@@ -110,6 +115,7 @@ export declare type KeyRole = 'owner' | 'active' | 'posting' | 'memo';
  */
 export declare class PrivateKey {
     private key;
+    secret: Buffer;
     constructor(key: Buffer);
     /**
      * Convenience to create a new instance from WIF string or buffer.
@@ -127,6 +133,7 @@ export declare class PrivateKey {
      * Create key from username and password.
      */
     static fromLogin(username: string, password: string, role?: KeyRole): PrivateKey;
+    multiply(pub: any): Buffer;
     /**
      * Sign message.
      * @param message 32-byte message.
@@ -145,6 +152,10 @@ export declare class PrivateKey {
      * to get the full encoded key you need to explicitly call {@link toString}.
      */
     inspect(): string;
+    /**
+     * Get shared secret for memo cryptography
+     */
+    get_shared_secret(public_key: PublicKey): Buffer;
 }
 /**
  * ECDSA (secp256k1) signature.

package/lib/crypto.js

@@ -35,15 +35,21 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const assert = require("assert");
+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");
 const verror_1 = require("verror");
 const serializer_1 = require("./chain/serializer");
 const client_1 = require("./client");
 const utils_1 = require("./utils");
+/**
+ * secp256k1 ecurve
+ */
+const secp256k1Curve = ecurve.getCurveByName('secp256k1');
 /**
  * Network id used in WIF-encoding.
  */
@@ -64,6 +70,14 @@ function sha256(input) {
         .update(input)
         .digest();
 }
+/**
+ * Return sha512 hash of input
+ */
+function sha512(input) {
+    return crypto_1.createHash('sha512')
+        .update(input)
+        .digest();
+}
 /**
  * Return 2-round sha256 hash of input.
  */
@@ -145,6 +159,11 @@ class PublicKey {
         this.key = key;
         this.prefix = prefix;
         assert(secp256k1.publicKeyVerify(key), 'invalid public key');
+        this.uncompressed = Buffer.from(secp256k1.publicKeyConvert(key, false));
+    }
+    static fromBuffer(key) {
+        assert(secp256k1.publicKeyVerify(key), 'invalid buffer as public key');
+        return { key };
     }
     /**
      * Create a new instance from a WIF-encoded key.
@@ -230,6 +249,9 @@ class PrivateKey {
         const seed = username + role + password;
         return PrivateKey.fromSeed(seed);
     }
+    multiply(pub) {
+        return Buffer.from(secp256k1.publicKeyTweakMul(pub.key, this.secret, false));
+    }
     /**
      * Sign message.
      * @param message 32-byte message.
@@ -265,6 +287,15 @@ class PrivateKey {
         const key = this.toString();
         return `PrivateKey: ${key.slice(0, 6)}...${key.slice(-6)}`;
     }
+    /**
+     * Get shared secret for memo cryptography
+     */
+    get_shared_secret(public_key) {
+        const KBP = ecurve.Point.fromAffine(secp256k1Curve, bigInteger.fromBuffer(public_key.uncompressed.slice(1, 33)), bigInteger.fromBuffer(public_key.uncompressed.slice(33, 65)));
+        const P = KBP.multiply(bigInteger.fromBuffer(this.key));
+        const S = P.affineX.toBuffer({ size: 32 });
+        return sha512(S);
+    }
 }
 exports.PrivateKey = PrivateKey;
 /**

package/lib/helpers/aes.d.ts

@@ -0,0 +1,26 @@
+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;

package/lib/helpers/aes.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+/**
+ * @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 S = private_key.get_shared_secret(public_key);
+    let ebuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    ebuf.writeUint64(nonce);
+    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();
+    if (checksum) {
+        if (check !== checksum) {
+            throw new Error('Invalid nonce');
+        }
+        message = cryptoJsDecrypt(message, tag, iv);
+    }
+    else {
+        message = cryptoJsEncrypt(message, tag, iv);
+    }
+    return { nonce, message, checksum: check };
+}
+/**
+ * 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) {
+    assert(message, 'Missing cipher text');
+    message = toBinaryBuffer(message);
+    const decipher = crypto_1.createDecipheriv('aes-256-cbc', tag, iv);
+    message = Buffer.concat([decipher.update(message), decipher.final()]);
+    return message;
+}
+/**
+ * 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) {
+    assert(message, 'Missing plain text');
+    message = toBinaryBuffer(message);
+    const cipher = crypto_1.createCipheriv('aes-256-cbc', tag, iv);
+    message = Buffer.concat([cipher.update(message), cipher.final()]);
+    return message;
+}
+/** @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() {
+    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];
+    }
+    let long = Long.fromNumber(Date.now());
+    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);

package/lib/index.d.ts

@@ -46,6 +46,9 @@ 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';
 export * from './crypto';
+export * from './memo';

package/lib/index.js

@@ -48,5 +48,7 @@ __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

@@ -0,0 +1,20 @@
+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;
+};
+export {};

package/lib/memo.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bs58 = require("bs58");
+const ByteBuffer = require("bytebuffer");
+const deserializer_1 = require("./chain/deserializer");
+const serializer_1 = require("./chain/serializer");
+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
+ */
+function encode(private_key, public_key, memo, testNonce) {
+    if (!memo.startsWith('#')) {
+        return memo;
+    }
+    memo = memo.substring(1);
+    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, {
+        check: checksum,
+        encrypted: message,
+        from: private_key.createPublic(),
+        nonce,
+        to: public_key
+    });
+    mbuf.flip();
+    const data = Buffer.from(mbuf.toBuffer());
+    return '#' + bs58.encode(data);
+}
+/**
+ * Encrypted memo/message decryption
+ * @param {Buffer|string}private_key Privatekey of recipient
+ * @param {any}memo Encrypted message/memo
+ */
+function decode(private_key, memo) {
+    if (!memo.startsWith('#')) {
+        return memo;
+    }
+    memo = memo.substring(1);
+    // 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;
+    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);
+    try {
+        mbuf.mark();
+        return '#' + mbuf.readVString();
+    }
+    catch (e) {
+        mbuf.reset();
+        // Sender did not length-prefix the 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*/);
+exports.Memo = {
+    decode,
+    encode
+};

package/lib/utils.d.ts

@@ -71,7 +71,7 @@ export interface WitnessProps {
     hbd_interest_rate?: number;
     url?: string;
 }
-export declare function buildWitnessUpdateOp(owner: string, props: WitnessProps): WitnessSetPropertiesOperation;
+export declare const buildWitnessUpdateOp: (owner: string, props: WitnessProps) => WitnessSetPropertiesOperation;
 export declare const operationOrders: {
     vote: number;
     comment: number;

package/lib/utils.js

@@ -182,15 +182,15 @@ const failover = (url, urls, currentAddress, consoleOnFailover) => {
 // Can hopefully be removed when hived's JSON representation is fixed
 const ByteBuffer = require("bytebuffer");
 const serializer_1 = require("./chain/serializer");
-function serialize(serializer, data) {
+const serialize = (serializer, data) => {
     const buffer = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
     serializer(buffer, data);
     buffer.flip();
     // `props` values must be hex
     return buffer.toString('hex');
     // return Buffer.from(buffer.toBuffer());
-}
-function buildWitnessUpdateOp(owner, props) {
+};
+exports.buildWitnessUpdateOp = (owner, props) => {
     const data = {
         extensions: [],
         owner,
@@ -227,8 +227,7 @@ function buildWitnessUpdateOp(owner, props) {
     }
     data.props.sort((a, b) => a[0].localeCompare(b[0]));
     return ['witness_set_properties', data];
-}
-exports.buildWitnessUpdateOp = buildWitnessUpdateOp;
+};
 const JSBI = require('jsbi');
 exports.operationOrders = {
     vote: 0,

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiveio/dhive",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "Hive blockchain RPC client library",
   "author": "hive-network",
   "license": "BSD-3-Clause-No-Military-License",
@@ -32,10 +32,12 @@
     "dhive"
   ],
   "dependencies": {
+    "bigi": "^1.4.2",
     "bs58": "^4.0.1",
     "bytebuffer": "^5.0.1",
     "core-js": "^3.6.4",
     "cross-fetch": "^3.0.4",
+    "ecurve": "^1.0.6",
     "https": "^1.0.0",
     "jsbi": "^3.1.4",
     "node-fetch": "^2.6.0",