@wishknish/knishio-client-js 0.5.2 → 0.6.1

package/src/libraries/Decimal.js

@@ -1,18 +1,17 @@
 // Value determines by min sql decimal precision
-const multiplier = 10 ** 18;
+const multiplier = 10 ** 18
 
 export default class Decimal {
-
   /**
    * @param {number} value
    * @return {number}
    */
-  static val ( value ) {
-    if ( Math.abs( value * multiplier ) < 1 ) {
-      return 0.0;
+  static val (value) {
+    if (Math.abs(value * multiplier) < 1) {
+      return 0.0
     }
 
-    return value;
+    return value
   }
 
   /**
@@ -21,19 +20,17 @@ export default class Decimal {
    * @param {boolean} debug
    * @return {number}
    */
-  static cmp ( value1, value2, debug = false ) {
-
-    const val1 = Decimal.val( value1 ) * multiplier,
-      val2 = Decimal.val( value2 ) * multiplier;
+  static cmp (value1, value2, debug = false) {
+    const val1 = Decimal.val(value1) * multiplier
+    const val2 = Decimal.val(value2) * multiplier
 
     // Equal
-    if ( Math.abs( val1 - val2 ) < 1 ) {
-      return 0;
+    if (Math.abs(val1 - val2) < 1) {
+      return 0
     }
 
     // Greater or smaller
-    return ( val1 > val2 ) ? 1 : -1;
-
+    return (val1 > val2) ? 1 : -1
   }
 
   /**
@@ -41,8 +38,7 @@ export default class Decimal {
    * @param {number} value2
    * @return {boolean}
    */
-  static equal ( value1, value2 ) {
-    return ( Decimal.cmp( value1, value2 ) === 0 );
+  static equal (value1, value2) {
+    return (Decimal.cmp(value1, value2) === 0)
   }
-
 }

package/src/libraries/Dot.js

@@ -1,81 +1,107 @@
 /**
- *
+ * Utility class for accessing nested object properties using dot notation
  */
 export default class Dot {
-
   /**
-   * @param {object|array} obj
-   * @param {string} keys
+   * Initialize the Dot utility with the given object and key path
+   * @param {object|array} obj - The object or array to traverse
+   * @param {string} keys - The dot-notated string of keys
    * @private
    */
-  static __init ( obj, keys ) {
-
-    this.arr = [];
-    this.key = null;
-
-    this.arr = String( keys ).split( '.' );
-    this.key = this.arr.shift();
-
-    const numberKey = Number( this.key );
-
-    if ( Number.isInteger( numberKey ) ) {
-      this.key = numberKey;
+  static __init (obj, keys) {
+    this.arr = String(keys).split('.')
+    this.key = this.arr.shift()
+
+    // Convert to number if the key is a valid integer
+    const numberKey = Number(this.key)
+    if (Number.isInteger(numberKey)) {
+      this.key = numberKey
     }
 
-    this.__nextKey = this.arr.length;
-    this.__next = this.__tic( obj );
+    this.__nextKey = this.arr.length
+    this.__next = this.__tic(obj)
   }
 
   /**
-   * @param {object|array} obj
-   * @return {boolean}
+   * Check if the current key exists in the object
+   * @param {object|array} obj - The object or array to check
+   * @return {boolean} - Whether the key exists
    * @private
    */
-  static __tic ( obj ) {
-
-    if ( !Array.isArray( obj ) && !( obj instanceof Object ) ) {
-      return false;
+  static __tic (obj) {
+    if (!Array.isArray(obj) && !(obj instanceof Object)) {
+      return false
     }
 
-    return typeof obj[ this.key ] !== 'undefined';
+    return typeof obj[this.key] !== 'undefined'
   }
 
   /**
-   * @param {object|array} obj
-   * @param {string} keys
-   * @return {boolean}
+   * Check if a nested property exists in an object using dot notation
+   * @param {object|array} obj - The object or array to search
+   * @param {string} keys - The path to the property, using dot notation
+   * @return {boolean} - True if the property exists, false otherwise
    */
-  static has ( obj, keys ) {
+  static has (obj, keys) {
+    this.__init(obj, keys)
 
-    this.__init( obj, keys );
-
-    if ( !this.__next ) {
-      return false;
+    if (!this.__next) {
+      return false
     }
-    if ( this.__nextKey === 0 ) {
-      return true;
+    if (this.__nextKey === 0) {
+      return true
     }
 
-    return this.has( obj[ this.key ], this.arr.join( '.' ) );
+    return this.has(obj[this.key], this.arr.join('.'))
   }
 
   /**
-   * @param {object|array} obj
-   * @param {string} keys
-   * @param {*} def
-   * @return {*}
+   * Get a nested property from an object using dot notation
+   * @param {object|array} obj - The object or array to search
+   * @param {string} keys - The path to the property, using dot notation
+   * @param {*} [def=null] - The default value to return if the property is not found
+   * @return {*} - The value of the property, or the default value if not found
    */
-  static get ( obj, keys, def = null ) {
-
-    this.__init( obj, keys );
+  static get (obj, keys, def = null) {
+    this.__init(obj, keys)
 
-    if ( !this.__next ) {
-      return def;
+    if (!this.__next) {
+      return def
     }
-    if ( this.__nextKey === 0 ) {
-      return obj[ this.key ];
+    if (this.__nextKey === 0) {
+      return obj[this.key]
     }
 
-    return this.get( obj[ this.key ], this.arr.join( '.' ), def );
+    return this.get(obj[this.key], this.arr.join('.'), def)
+  }
+
+  /**
+   * Set a nested property in an object using dot notation
+   * @param {object|array} obj - The object or array to modify
+   * @param {string} keys - The path to the property, using dot notation
+   * @param {*} value - The value to set
+   * @return {object|array} - The modified object or array
+   */
+  static set (obj, keys, value) {
+    const parts = keys.split('.')
+    let current = obj
+    const lastIndex = parts.length - 1
+
+    for (let i = 0; i < lastIndex; i++) {
+      const key = parts[i]
+      const numberKey = Number(key)
+      const useNumberKey = Number.isInteger(numberKey)
+
+      if (!(useNumberKey ? numberKey : key in current)) {
+        current[useNumberKey ? numberKey : key] = parts[i + 1].match(/^\d+$/) ? [] : {}
+      }
+      current = current[useNumberKey ? numberKey : key]
+    }
+
+    const lastKey = parts[lastIndex]
+    const lastNumberKey = Number(lastKey)
+    current[Number.isInteger(lastNumberKey) ? lastNumberKey : lastKey] = value
+
+    return obj
   }
 }

package/src/libraries/Hex.js

@@ -1,8 +1,12 @@
 /**
  * Create Uint8Array buffers from hexadecimal strings, and vice versa.
  */
-export default class Hex {
 
+if (typeof self === 'undefined') {
+  global.self = global
+}
+
+export default class Hex {
   /**
    * Converts the given buffer to a string containing its hexadecimal representation.
    *
@@ -19,58 +23,52 @@ export default class Hex {
    * @param {object} options
    * @return {string}
    */
-  static toHex ( arr, options ) {
-
+  static toHex (arr, options) {
     /**
      * @param {number} val
      * @param {boolean} uppercase
      * @return {*}
      */
-    const numberToHex = ( val, uppercase ) => {
-
-        const set = uppercase ?
-          [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' ] :
-          [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' ];
-
-        return set[ Math.floor( val / 16 ) ] + set[ val % 16 ];
+    const numberToHex = (val, uppercase) => {
+      const set = uppercase
+        ? ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F']
+        : ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
 
+      return set[Math.floor(val / 16)] + set[val % 16]
+    }
+    const opts = Object.assign(
+      {
+        grouping: 0,
+        rowlength: 0,
+        uppercase: false
       },
-      opts = Object.assign(
-        {
-          grouping: 0,
-          rowlength: 0,
-          uppercase: false
-        },
-        options || {}
-      );
-
-    let str = '',
-      group = 0,
-      column = 0;
+      options || {}
+    )
 
-    for ( let i = 0; i < arr.length; ++i ) {
+    let str = ''
+    let group = 0
+    let column = 0
 
-      str += numberToHex( arr[ i ], opts.uppercase );
+    for (let i = 0; i < arr.length; ++i) {
+      str += numberToHex(arr[i], opts.uppercase)
 
-      if ( i === arr.length - 1 ) {
-        break;
+      if (i === arr.length - 1) {
+        break
       }
 
-      if ( opts.grouping > 0 && ++group === opts.grouping ) {
-
-        group = 0;
-
-        if ( opts.rowlength > 0 && ++column === opts.rowlength ) {
+      if (opts.grouping > 0 && ++group === opts.grouping) {
+        group = 0
 
-          column = 0;
-          str += '\n';
+        if (opts.rowlength > 0 && ++column === opts.rowlength) {
+          column = 0
+          str += '\n'
         } else {
-          str += ' ';
+          str += ' '
         }
       }
     }
 
-    return str;
+    return str
   }
 
   /**
@@ -84,35 +82,32 @@ export default class Hex {
    * @param {string} str
    * @return {Uint8Array}
    */
-  static toUint8Array ( str ) {
+  static toUint8Array (str) {
+    let target = str.toLowerCase().replace(/\s/g, '')
 
-    let target = str.toLowerCase().replace( /\s/g, '' );
-
-    if ( target.length % 2 === 1 ) {
-      target = `0${ target }`;
+    if (target.length % 2 === 1) {
+      target = `0${ target }`
     }
 
-    let buffer = new Uint8Array( Math.floor( target.length / 2 ) ),
-      curr = -1;
-
-    for ( let i = 0; i < target.length; ++i ) {
+    const buffer = new Uint8Array(Math.floor(target.length / 2))
+    let curr = -1
 
-      let c = target[ i ],
-        val = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' ].indexOf( c );
+    for (let i = 0; i < target.length; ++i) {
+      const c = target[i]
+      const val = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'].indexOf(c)
 
-      if ( val === -1 ) {
-        throw Error( 'unexpected character' );
+      if (val === -1) {
+        throw Error('unexpected character')
       }
 
-      if ( curr === -1 ) {
-        curr = 16 * val;
+      if (curr === -1) {
+        curr = 16 * val
       } else {
-
-        buffer[ Math.floor( i / 2 ) ] = curr + val;
-        curr = -1;
+        buffer[Math.floor(i / 2)] = curr + val
+        curr = -1
       }
     }
 
-    return buffer;
+    return buffer
   }
 }

package/src/libraries/array.js

@@ -5,69 +5,78 @@
  * @param {number} size
  * @return {array}
  */
-export function chunkArray ( arr, size ) {
-
-  if ( !arr.length ) {
-    return [];
+export function chunkArray (arr, size) {
+  if (!arr.length) {
+    return []
   }
 
-  return [ arr.slice( 0, size ) ].concat( chunkArray( arr.slice( size ), size ) );
+  return [arr.slice(0, size)].concat(chunkArray(arr.slice(size), size))
 }
 
 export function deepCloning (
   o // The only argument passed by user: object to clone
   , h // Cache (organized as array: [key,value,key,value,...])
 ) {
-  let i,
-    r,
-    x // Property indexer, result, temporary variable
-    ,
-    t = [ Array, Date, Number, String, Boolean ] // Types to treat in a special way
-    ,
-    s = Object.prototype.toString; // Shortcut to Object.prototype.toString
-  h = h || []; // If cache is not created yet, create it!
-  for ( i = 0; i < h.length; i += 2 ) // Search cache for our object
-    if ( o === h[ i ] )
-      r = h[ i + 1 ];
-  if ( !r && o && typeof o == 'object' ) { // Clone o if it is uncached object and not null
-    r = {}; // Default result template: plain hash
-    for ( i = 0; i < t.length; i++ ) // To handle multiframe environment, search for type by
-      if ( s.call( o ) === s.call( //   comparing Object.prototype.toString's of our object
-        x = new t[ i ]( o ) ) ) //   and new object x created with the constructor t[i]
-        // Notice that it will create new Date(o), new String(o)
-        //   which is good and new Array(o) which is bad
-        r = i ? x : []; // If i==0, t==Array. We need to recreate it. Else use x
-    h.push( o, r ); // Add object to cache before (!) making recursive call
-    for ( i in o ) // Just copy properties recursively
-      if ( h.hasOwnProperty.call( o, i ) ) // As o might have key 'hasOwnProperty', use something
-        r[ i ] = deepCloning( o[ i ], h ); //   we defined right instead
+  let i
+  let r
+  let x // Property indexer, result, temporary variable
+
+  const t = [Array, Date, Number, String, Boolean] // Types to treat in a special way
+
+  const s = Object.prototype.toString // Shortcut to Object.prototype.toString
+  h = h || [] // If cache is not created yet, create it!
+  // Search cache for our object
+  for (i = 0; i < h.length; i += 2) {
+    if (o === h[i]) {
+      r = h[i + 1]
+    }
+  }
+  // Clone o if it is uncached object and not null
+  if (!r && o && typeof o === 'object') {
+    r = {} // Default result template: plain hash
+    // To handle multiframe environment, search for type by
+    for (i = 0; i < t.length; i++) {
+      //   comparing Object.prototype.toString's of our object
+      //   and new object x created with the constructor t[i]
+      // Notice that it will create new Date(o), new String(o)
+      //   which is good and new Array(o) which is bad
+      if (s.call(o) === s.call(x = new t[i](o))) {
+        r = i ? x : []
+      }
+    } // If i==0, t==Array. We need to recreate it. Else use x
+    h.push(o, r) // Add object to cache before (!) making recursive call
+    // Just copy properties recursively
+    for (i in o) {
+      // As o might have key 'hasOwnProperty', use something
+      if (h.hasOwnProperty.call(o, i)) {
+        r[i] = deepCloning(o[i], h)
+      }
+    } //   we defined right instead
   }
-  return r || o; // Return r if it was found in cache or built in if(){}
+  return r || o // Return r if it was found in cache or built in if(){}
 }
 
 /**
  * @param arrays
  * @returns {*[]}
  */
-export function diff ( ...arrays ) {
+export function diff (...arrays) {
+  return [].concat(...arrays.map((arr, i) => {
+    const others = arrays.slice(0)
 
-  return [].concat( ...arrays.map( ( arr, i ) => {
+    others.splice(i, 1)
 
-    const others = arrays.slice( 0 );
+    const unique = [...new Set([].concat(...others))]
 
-    others.splice( i, 1 );
-
-    const unique = [ ...new Set( [].concat( ...others ) ) ];
-
-    return arr.filter( item => !unique.includes( item ) );
-  } ) );
+    return arr.filter(item => !unique.includes(item))
+  }))
 }
 
- /**
+/**
  *
  * @param arrays
  * @return {*[]}
  */
-export function intersect ( ...arrays ) {
-  return arrays.reduce( ( first, second ) => first.filter( item => second.includes( item ) ) );
+export function intersect (...arrays) {
+  return arrays.reduce((first, second) => first.filter(item => second.includes(item)))
 }

package/src/libraries/crypto.js

@@ -45,8 +45,8 @@ Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
 
 License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
  */
-import { shake256 } from 'js-sha3';
-import { randomString } from './strings';
+import { randomString } from './strings'
+import JsSHA from 'jssha'
 
 /**
  * Generates a secret based on an optional seed
@@ -55,17 +55,14 @@ import { randomString } from './strings';
  * @param length
  * @return {string|*}
  */
-export function generateSecret ( seed = null, length = 2048 ) {
-
-  console.info( `Crypto::generateSecret() - Computing new secret${ seed ? ' from existing seed' : '' }...` );
-
-  if ( seed ) {
-    const sponge = shake256.create( length * 2 );
-    sponge.update( seed );
-    return sponge.hex();
-  }
-  else {
-    return randomString( length );
+export function generateSecret (seed = null, length = 2048) {
+  // console.info(`Crypto::generateSecret() - Computing new secret${ seed ? ' from existing seed' : '' }...`)
+  if (seed) {
+    const sponge = new JsSHA('SHAKE256', 'TEXT')
+    sponge.update(seed)
+    return sponge.getHash('HEX', { outputLen: length * 2 })
+  } else {
+    return randomString(length)
   }
 }
 
@@ -73,16 +70,13 @@ export function generateSecret ( seed = null, length = 2048 ) {
  * Hashes the user secret to produce a bundle hash
  *
  * @param {string} secret
+ * @param {string|null} source
  * @return {string}
  */
-export function generateBundleHash ( secret ) {
-
-  console.info( 'Crypto::generateBundleHash() - Computing wallet bundle from secret...' );
-
-  const sponge = shake256.create( 256 );
-  sponge.update( secret );
-  return sponge.hex();
-
+export function generateBundleHash (secret, source = null) {
+  const sponge = new JsSHA('SHAKE256', 'TEXT')
+  sponge.update(secret)
+  return sponge.getHash('HEX', { outputLen: 256 })
 }
 
 /**
@@ -93,14 +87,13 @@ export function generateBundleHash ( secret ) {
  *
  * @return {string}
  */
-export function generateBatchId ( {
+export function generateBatchId ({
   molecularHash = null,
   index = null
-} ) {
-
-  if ( molecularHash !== null && index !== null ) {
-    return generateBundleHash( String( molecularHash ) + String( index ) );
+}) {
+  if (molecularHash !== null && index !== null) {
+    return generateBundleHash(String(molecularHash) + String(index), 'generateBatchId')
   }
 
-  return randomString( 64 );
+  return randomString(64)
 }