@wishknish/knishio-client-js 0.5.2 → 0.6.1

package/src/libraries/CheckMolecule.js

@@ -1,60 +1,104 @@
-import AtomIndexException from './../exception/AtomIndexException';
-import AtomsMissingException from './../exception/AtomsMissingException';
-import MolecularHashMismatchException from './../exception/MolecularHashMismatchException';
-import MolecularHashMissingException from './../exception/MolecularHashMissingException';
-import PolicyInvalidException from './../exception/PolicyInvalidException';
-import SignatureMalformedException from './../exception/SignatureMalformedException';
-import SignatureMismatchException from './../exception/SignatureMismatchException';
-import TransferBalanceException from './../exception/TransferBalanceException';
-import TransferMalformedException from './../exception/TransferMalformedException';
-import TransferMismatchedException from './../exception/TransferMismatchedException';
-import TransferRemainderException from './../exception/TransferRemainderException';
-import TransferToSelfException from './../exception/TransferToSelfException';
-import TransferUnbalancedException from './../exception/TransferUnbalancedException';
-import MetaMissingException from './../exception/MetaMissingException';
-import WrongTokenTypeException from './../exception/WrongTokenTypeException';
-import BatchIdException from './../exception/BatchIdException';
-import Atom from './../Atom';
-import Meta from './../Meta';
-import Wallet from './../Wallet';
-import Rule from '../instance/Rules/Rule';
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (/////////////)
+                       (////////////////(               (//////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        Powered by Knish.IO: Connecting a Decentralized World
+
+Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
+
+License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
+ */
+import AtomIndexException from './../exception/AtomIndexException'
+import AtomsMissingException from './../exception/AtomsMissingException'
+import MolecularHashMismatchException from './../exception/MolecularHashMismatchException'
+import MolecularHashMissingException from './../exception/MolecularHashMissingException'
+import PolicyInvalidException from './../exception/PolicyInvalidException'
+import SignatureMalformedException from './../exception/SignatureMalformedException'
+import SignatureMismatchException from './../exception/SignatureMismatchException'
+import TransferBalanceException from './../exception/TransferBalanceException'
+import TransferMalformedException from './../exception/TransferMalformedException'
+import TransferMismatchedException from './../exception/TransferMismatchedException'
+import TransferRemainderException from './../exception/TransferRemainderException'
+import TransferToSelfException from './../exception/TransferToSelfException'
+import TransferUnbalancedException from './../exception/TransferUnbalancedException'
+import MetaMissingException from './../exception/MetaMissingException'
+import WrongTokenTypeException from './../exception/WrongTokenTypeException'
+import BatchIdException from './../exception/BatchIdException'
+import Atom from './../Atom'
+import Meta from './../Meta'
+import Wallet from './../Wallet'
+import Rule from '../instance/Rules/Rule'
 import {
   base64ToHex,
   chunkSubstr
-} from './strings';
-import { shake256 } from 'js-sha3';
-import Dot from './../libraries/Dot';
+} from './strings'
+import JsSHA from 'jssha'
+import Dot from './../libraries/Dot'
 
 /**
  *
  */
 export default class CheckMolecule {
-
-
   /**
    *
    * @param molecule
    */
-  constructor ( molecule ) {
-
+  constructor (molecule) {
     // No molecular hash?
-    if ( molecule.molecularHash === null ) {
-      throw new MolecularHashMissingException();
+    if (molecule.molecularHash === null) {
+      throw new MolecularHashMissingException()
     }
 
     // No atoms?
-    if ( !molecule.atoms.length ) {
-      throw new AtomsMissingException();
+    if (!molecule.atoms.length) {
+      throw new AtomsMissingException()
     }
 
     // Check atom indexes
-    for ( let atom of molecule.atoms ) {
-      if ( atom.index === null ) {
-        throw new AtomIndexException();
+    for (const atom of molecule.atoms) {
+      if (atom.index === null) {
+        throw new AtomIndexException()
       }
     }
 
-    this.molecule = molecule;
+    this.molecule = molecule
   }
 
   /**
@@ -62,18 +106,18 @@ export default class CheckMolecule {
    * @param senderWallet
    * @returns {false|*|boolean}
    */
-  verify ( senderWallet ) {
-    return this.molecularHash()
-      && this.ots()
-      && this.batchId()
-      && this.continuId()
-      && this.isotopeM()
-      && this.isotopeT()
-      && this.isotopeC()
-      && this.isotopeU()
-      && this.isotopeI()
-      && this.isotopeR()
-      && this.isotopeV( senderWallet );
+  verify (senderWallet) {
+    return this.molecularHash() &&
+      this.ots() &&
+      this.batchId() &&
+      this.continuId() &&
+      this.isotopeM() &&
+      this.isotopeT() &&
+      this.isotopeC() &&
+      this.isotopeU() &&
+      this.isotopeI() &&
+      this.isotopeR() &&
+      this.isotopeV(senderWallet)
   }
 
   /**
@@ -81,14 +125,13 @@ export default class CheckMolecule {
    * @returns {boolean}
    */
   continuId () {
+    const firstAtom = this.molecule.atoms[0]
 
-    const firstAtom = this.molecule.atoms[ 0 ];
-
-    if ( firstAtom.token === 'USER' && this.molecule.getIsotopes( 'I' ).length < 1 ) {
-      throw new AtomsMissingException( 'Check::continuId() - Molecule is missing required ContinuID Atom!' );
+    if (firstAtom.token === 'USER' && this.molecule.getIsotopes('I').length < 1) {
+      throw new AtomsMissingException('Check::continuId() - Molecule is missing required ContinuID Atom!')
     }
 
-    return true;
+    return true
   }
 
   /**
@@ -96,29 +139,28 @@ export default class CheckMolecule {
    * @returns {boolean}
    */
   batchId () {
+    if (this.molecule.atoms.length > 0) {
+      const signingAtom = this.molecule.atoms[0]
 
-    if ( this.molecule.atoms.length > 0 ) {
-      const signingAtom = this.molecule.atoms[ 0 ];
-
-      if ( signingAtom.isotope === 'V' && signingAtom.batchId !== null ) {
-        const atoms = this.molecule.getIsotopes( 'V' );
-        const remainderAtom = atoms[ atoms.length - 1 ];
+      if (signingAtom.isotope === 'V' && signingAtom.batchId !== null) {
+        const atoms = this.molecule.getIsotopes('V')
+        const remainderAtom = atoms[atoms.length - 1]
 
-        if ( signingAtom.batchId !== remainderAtom.batchId ) {
-          throw new BatchIdException();
+        if (signingAtom.batchId !== remainderAtom.batchId) {
+          throw new BatchIdException()
         }
 
-        for ( const atom of atoms ) {
-          if ( atom.batchId === null ) {
-            throw new BatchIdException();
+        for (const atom of atoms) {
+          if (atom.batchId === null) {
+            throw new BatchIdException()
           }
         }
       }
 
-      return true;
+      return true
     }
 
-    throw new BatchIdException();
+    throw new BatchIdException()
   }
 
   /**
@@ -126,18 +168,17 @@ export default class CheckMolecule {
    * @returns {boolean}
    */
   isotopeI () {
-
-    for ( let atom of this.molecule.getIsotopes( 'I' ) ) {
-      if ( atom.token !== 'USER' ) {
-        throw new WrongTokenTypeException( `Check::isotopeI() - "${ atom.token }" is not a valid Token slug for "${ atom.isotope }" isotope Atoms!` );
+    for (const atom of this.molecule.getIsotopes('I')) {
+      if (atom.token !== 'USER') {
+        throw new WrongTokenTypeException(`Check::isotopeI() - "${ atom.token }" is not a valid Token slug for "${ atom.isotope }" isotope Atoms!`)
       }
 
-      if ( atom.index === 0 ) {
-        throw new AtomIndexException( `Check::isotopeI() - Isotope "${ atom.isotope }" Atoms must have a non-zero index!` );
+      if (atom.index === 0) {
+        throw new AtomIndexException(`Check::isotopeI() - Isotope "${ atom.isotope }" Atoms must have a non-zero index!`)
       }
     }
 
-    return true;
+    return true
   }
 
   /**
@@ -145,18 +186,17 @@ export default class CheckMolecule {
    * @returns {boolean}
    */
   isotopeU () {
-
-    for ( let atom of this.molecule.getIsotopes( 'U' ) ) {
-      if ( atom.token !== 'AUTH' ) {
-        throw new WrongTokenTypeException( `Check::isotopeU() - "${ atom.token }" is not a valid Token slug for "${ atom.isotope }" isotope Atoms!` );
+    for (const atom of this.molecule.getIsotopes('U')) {
+      if (atom.token !== 'AUTH') {
+        throw new WrongTokenTypeException(`Check::isotopeU() - "${ atom.token }" is not a valid Token slug for "${ atom.isotope }" isotope Atoms!`)
       }
 
-      if ( atom.index !== 0 ) {
-        throw new AtomIndexException( `Check::isotopeU() - Isotope "${ atom.isotope }" Atoms must have an index equal to 0!` );
+      if (atom.index !== 0) {
+        throw new AtomIndexException(`Check::isotopeU() - Isotope "${ atom.isotope }" Atoms must have an index equal to 0!`)
       }
     }
 
-    return true;
+    return true
   }
 
   /**
@@ -164,39 +204,34 @@ export default class CheckMolecule {
    * @returns {boolean}
    */
   isotopeM () {
+    const policyArray = ['readPolicy', 'writePolicy']
 
-    const policyArray = [ 'readPolicy', 'writePolicy' ];
-
-    for ( /** @type {Atom} */ let atom of this.molecule.getIsotopes( 'M' ) ) {
-
-      if ( atom.meta.length < 1 ) {
-        throw new MetaMissingException();
+    for (/** @type {Atom} */ const atom of this.molecule.getIsotopes('M')) {
+      if (atom.meta.length < 1) {
+        throw new MetaMissingException()
       }
 
-      if ( atom.token !== 'USER' ) {
-        throw new WrongTokenTypeException( `Check::isotopeM() - "${ atom.token }" is not a valid Token slug for "${ atom.isotope }" isotope Atoms!` );
+      if (atom.token !== 'USER') {
+        throw new WrongTokenTypeException(`Check::isotopeM() - "${ atom.token }" is not a valid Token slug for "${ atom.isotope }" isotope Atoms!`)
       }
 
-      const metas = Meta.aggregateMeta( atom.meta );
-
-      for ( const key of policyArray ) {
-        let policy = metas[ key ];
-
-        if ( policy ) {
-          policy = JSON.parse( policy );
+      const metas = Meta.aggregateMeta(atom.meta)
 
-          for ( const [ policyName, policyValue ] of Object.entries( policy ) ) {
+      for (const key of policyArray) {
+        let policy = metas[key]
 
-            if ( !policyArray.includes( policyName ) ) {
+        if (policy) {
+          policy = JSON.parse(policy)
 
-              if ( !Object.keys( metas ).includes( policyName ) ) {
-                throw new PolicyInvalidException( `${ policyName } is missing from the meta.` );
+          for (const [policyName, policyValue] of Object.entries(policy)) {
+            if (!policyArray.includes(policyName)) {
+              if (!Object.keys(metas).includes(policyName)) {
+                throw new PolicyInvalidException(`${ policyName } is missing from the meta.`)
               }
 
-              for ( const value of policyValue ) {
-
-                if ( !Wallet.isBundleHash( value ) && ![ 'all', 'self' ].includes( value ) ) {
-                  throw new PolicyInvalidException( `${ value } does not correspond to the format of the policy.` );
+              for (const value of policyValue) {
+                if (!Wallet.isBundleHash(value) && !['all', 'self'].includes(value)) {
+                  throw new PolicyInvalidException(`${ value } does not correspond to the format of the policy.`)
                 }
               }
             }
@@ -205,7 +240,7 @@ export default class CheckMolecule {
       }
     }
 
-    return true;
+    return true
   }
 
   /**
@@ -213,18 +248,17 @@ export default class CheckMolecule {
    * @returns {boolean}
    */
   isotopeC () {
-
-    for ( let atom of this.molecule.getIsotopes( 'C' ) ) {
-      if ( atom.token !== 'USER' ) {
-        throw new WrongTokenTypeException( `Check::isotopeC() - "${ atom.token }" is not a valid Token slug for "${ atom.isotope }" isotope Atoms!` );
+    for (const atom of this.molecule.getIsotopes('C')) {
+      if (atom.token !== 'USER') {
+        throw new WrongTokenTypeException(`Check::isotopeC() - "${ atom.token }" is not a valid Token slug for "${ atom.isotope }" isotope Atoms!`)
       }
 
-      if ( atom.index !== 0 ) {
-        throw new AtomIndexException( `Check::isotopeC() - Isotope "${ atom.isotope }" Atoms must have an index equal to 0!` );
+      if (atom.index !== 0) {
+        throw new AtomIndexException(`Check::isotopeC() - Isotope "${ atom.isotope }" Atoms must have an index equal to 0!`)
       }
     }
 
-    return true;
+    return true
   }
 
   /**
@@ -232,35 +266,34 @@ export default class CheckMolecule {
    * @returns {boolean}
    */
   isotopeT () {
-
-    for ( let atom of this.molecule.getIsotopes( 'T' ) ) {
-      const meta = atom.aggregatedMeta(),
-        metaType = String( atom.metaType ).toLowerCase();
-
-      if ( metaType === 'wallet' ) {
-        for ( let key of [ 'position', 'bundle' ] ) {
-          if ( !meta.hasOwnProperty( key ) || !Boolean( meta[ key ] ) ) {
-            throw new MetaMissingException( `Check::isotopeT() - Required meta field "${ key }" is missing!` );
+    for (const atom of this.molecule.getIsotopes('T')) {
+      const meta = atom.aggregatedMeta()
+      const metaType = String(atom.metaType).toLowerCase()
+
+      if (metaType === 'wallet') {
+        for (const key of ['position', 'bundle']) {
+          if (!Object.prototype.hasOwnProperty.call(meta, key) || !meta[key]) {
+            throw new MetaMissingException(`Check::isotopeT() - Required meta field "${ key }" is missing!`)
           }
         }
       }
 
-      for ( let key of [ 'token' ] ) {
-        if ( !meta.hasOwnProperty( key ) || !Boolean( meta[ key ] ) ) {
-          throw new MetaMissingException( `Check::isotopeT() - Required meta field "${ key }" is missing!` );
+      for (const key of ['token']) {
+        if (!Object.prototype.hasOwnProperty.call(meta, key) || !meta[key]) {
+          throw new MetaMissingException(`Check::isotopeT() - Required meta field "${ key }" is missing!`)
         }
       }
 
-      if ( atom.token !== 'USER' ) {
-        throw new WrongTokenTypeException( `Check::isotopeT() - "${ atom.token }" is not a valid Token slug for "${ atom.isotope }" isotope Atoms!` );
+      if (atom.token !== 'USER') {
+        throw new WrongTokenTypeException(`Check::isotopeT() - "${ atom.token }" is not a valid Token slug for "${ atom.isotope }" isotope Atoms!`)
       }
 
-      if ( atom.index !== 0 ) {
-        throw new AtomIndexException( `Check::isotopeT() - Isotope "${ atom.isotope }" Atoms must have an index equal to 0!` );
+      if (atom.index !== 0) {
+        throw new AtomIndexException(`Check::isotopeT() - Isotope "${ atom.isotope }" Atoms must have an index equal to 0!`)
       }
     }
 
-    return true;
+    return true
   }
 
   /**
@@ -268,36 +301,35 @@ export default class CheckMolecule {
    * @returns {boolean}
    */
   isotopeR () {
+    for (const atom of this.molecule.getIsotopes('R')) {
+      const metas = atom.aggregatedMeta()
 
-    for ( let atom of this.molecule.getIsotopes( 'R' ) ) {
-      const metas = atom.aggregatedMeta();
+      if (metas.policy) {
+        const policy = JSON.parse(metas.policy)
 
-      if ( metas.policy ) {
-        const policy = JSON.parse( metas.policy );
-
-        if ( !Object.keys( policy ).every( i => [ 'read', 'write' ].includes( i ) ) ) {
-          throw new MetaMissingException( 'Check::isotopeR() - Mixing rules with politics!' );
+        if (!Object.keys(policy).every(i => ['read', 'write'].includes(i))) {
+          throw new MetaMissingException('Check::isotopeR() - Mixing rules with politics!')
         }
       }
 
-      if ( metas.rule ) {
-        const rules = JSON.parse( metas.rule );
+      if (metas.rule) {
+        const rules = JSON.parse(metas.rule)
 
-        if ( !Array.isArray( rules ) ) {
-          throw new MetaMissingException( 'Check::isotopeR() - Incorrect rule format!' );
+        if (!Array.isArray(rules)) {
+          throw new MetaMissingException('Check::isotopeR() - Incorrect rule format!')
         }
 
-        for ( const item of rules ) {
-          Rule.toObject( item );
+        for (const item of rules) {
+          Rule.toObject(item)
         }
 
-        if ( rules.length < 1 ) {
-          throw new MetaMissingException( 'Check::isotopeR() - No rules!' );
+        if (rules.length < 1) {
+          throw new MetaMissingException('Check::isotopeR() - No rules!')
         }
       }
     }
 
-    return true;
+    return true
   }
 
   /**
@@ -305,111 +337,102 @@ export default class CheckMolecule {
    * @param senderWallet
    * @returns {boolean}
    */
-  isotopeV ( senderWallet = null ) {
-
-    const isotopeV = this.molecule.getIsotopes( 'V' );
+  isotopeV (senderWallet = null) {
+    const isotopeV = this.molecule.getIsotopes('V')
 
-    if ( isotopeV.length === 0 ) {
-      return true;
+    if (isotopeV.length === 0) {
+      return true
     }
 
-    const firstAtom = this.molecule.atoms[ 0 ];
+    const firstAtom = this.molecule.atoms[0]
 
-    if ( firstAtom.isotope === 'V' && isotopeV.length === 2 ) {
+    if (firstAtom.isotope === 'V' && isotopeV.length === 2) {
+      const endAtom = isotopeV[isotopeV.length - 1]
 
-      const endAtom = isotopeV[ isotopeV.length - 1 ];
-
-      if ( firstAtom.token !== endAtom.token ) {
-        throw new TransferMismatchedException();
+      if (firstAtom.token !== endAtom.token) {
+        throw new TransferMismatchedException()
       }
 
-      if ( endAtom.value < 0 ) {
-        throw new TransferMalformedException();
+      if (endAtom.value < 0) {
+        throw new TransferMalformedException()
       }
 
-      return true;
+      return true
     }
 
+    let sum = 0
+    let value = 0
 
-    let sum = 0,
-      value = 0;
-
-    for ( let index in this.molecule.atoms ) {
-
-      if ( this.molecule.atoms.hasOwnProperty( index ) ) {
-
-        const vAtom = this.molecule.atoms[ index ];
+    for (const index in this.molecule.atoms) {
+      if (Object.prototype.hasOwnProperty.call(this.molecule.atoms, index)) {
+        const vAtom = this.molecule.atoms[index]
 
         // Not V? Next...
-        if ( vAtom.isotope !== 'V' ) {
-          continue;
+        if (vAtom.isotope !== 'V') {
+          continue
         }
 
         // Making sure we're in integer land
-        value = vAtom.value * 1;
+        value = vAtom.value * 1
 
-        if ( Number.isNaN( value ) ) {
-          throw new TypeError( 'Invalid isotope "V" values' );
+        if (Number.isNaN(value)) {
+          throw new TypeError('Invalid isotope "V" values')
         }
 
         // Making sure all V atoms of the same token
-        if ( vAtom.token !== firstAtom.token ) {
-          throw new TransferMismatchedException();
+        if (vAtom.token !== firstAtom.token) {
+          throw new TransferMismatchedException()
         }
 
         // Checking non-primary atoms
-        if ( index > 0 ) {
-
+        if (index > 0) {
           // Negative V atom in a non-primary position?
-          if ( value < 0 ) {
-            throw new TransferMalformedException();
+          if (value < 0) {
+            throw new TransferMalformedException()
           }
 
           // Cannot be sending and receiving from the same address
-          if ( vAtom.walletAddress === firstAtom.walletAddress ) {
-            throw new TransferToSelfException();
+          if (vAtom.walletAddress === firstAtom.walletAddress) {
+            throw new TransferToSelfException()
           }
-
         }
 
         // Adding this Atom's value to the total sum
-        sum += value;
+        sum += value
       }
     }
 
     // Does the total sum of all atoms equal the remainder atom's value? (all other atoms must add up to zero)
-    if ( sum !== value ) {
-      throw new TransferUnbalancedException();
+    if (sum !== value) {
+      throw new TransferUnbalancedException()
     }
 
     // If we're provided with a senderWallet argument, we can perform additional checks
-    if ( senderWallet ) {
+    if (senderWallet) {
+      value = firstAtom.value * 1
 
-      value = firstAtom.value * 1;
-
-      if ( Number.isNaN( value ) ) {
-        throw new TypeError( 'Invalid isotope "V" values' );
+      if (Number.isNaN(value)) {
+        throw new TypeError('Invalid isotope "V" values')
       }
 
-      const remainder = ( senderWallet.balance * 1 ) + ( value * 1 );
+      const remainder = senderWallet.balance + value
 
       // Is there enough balance to send?
-      if ( remainder < 0 ) {
-        throw new TransferBalanceException();
+      if (remainder < 0) {
+        throw new TransferBalanceException()
       }
 
       // Does the remainder match what should be there in the source wallet, if provided?
-      if ( remainder !== sum ) {
-        throw new TransferRemainderException();
+      if (remainder !== sum) {
+        throw new TransferRemainderException()
       }
-
-    } // No senderWallet, but have a remainder?
-    else if ( value !== 0 ) {
-      throw new TransferRemainderException();
+    } else if (value !== 0) {
+      // No senderWallet, but have a remainder?
+      throw new TransferRemainderException()
     }
 
     // Looks like we passed all the tests!
-    return true;
+    return true
   }
 
   /**
@@ -418,15 +441,14 @@ export default class CheckMolecule {
    * @returns {boolean}
    */
   molecularHash () {
-
-    if ( this.molecule.molecularHash !== Atom.hashAtoms( {
+    if (this.molecule.molecularHash !== Atom.hashAtoms({
       atoms: this.molecule.atoms
-    } ) ) {
-      throw new MolecularHashMismatchException();
+    })) {
+      throw new MolecularHashMismatchException()
     }
 
     // Looks like we passed all the tests!
-    return true;
+    return true
   }
 
   /**
@@ -437,72 +459,71 @@ export default class CheckMolecule {
    * @returns {boolean}
    */
   ots () {
-
     // Convert Hm to numeric notation via EnumerateMolecule(Hm)
-    const normalizedHash = this.molecule.normalizedHash();
+    const normalizedHash = this.molecule.normalizedHash()
 
     // Rebuilding OTS out of all the atoms
     let ots = this.molecule.atoms.map(
       atom => atom.otsFragment
     ).reduce(
-      ( accumulator, otsFragment ) => accumulator + otsFragment
-    );
+      (accumulator, otsFragment) => accumulator + otsFragment
+    )
 
     // Wrong size? Maybe it's compressed
-    if ( ots.length !== 2048 ) {
-
+    if (ots.length !== 2048) {
       // Attempting decompression
-      ots = base64ToHex( ots );
+      ots = base64ToHex(ots)
 
       // Still wrong? That's a failure
-      if ( ots.length !== 2048 ) {
-        throw new SignatureMalformedException();
+      if (ots.length !== 2048) {
+        throw new SignatureMalformedException()
       }
     }
 
     // Subdivide Kk into 16 segments of 256 bytes (128 characters) each
-    const otsChunks = chunkSubstr( ots, 128 );
-
-    let keyFragments = '';
+    const otsChunks = chunkSubstr(ots, 128)
 
-    for ( const index in otsChunks ) {
+    let keyFragments = ''
 
-      let workingChunk = otsChunks[ index ];
+    for (const index in otsChunks) {
+      let workingChunk = otsChunks[index]
 
-      for ( let iterationCount = 0, condition = 8 + normalizedHash[ index ]; iterationCount < condition; iterationCount++ ) {
-        workingChunk = shake256.create( 512 ).update( workingChunk ).hex();
+      for (let iterationCount = 0, condition = 8 + normalizedHash[index]; iterationCount < condition; iterationCount++) {
+        workingChunk = (new JsSHA('SHAKE256', 'TEXT')).update(workingChunk).getHash('HEX', { outputLen: 512 })
       }
 
-      keyFragments += workingChunk;
+      keyFragments += workingChunk
     }
 
     // Absorb the hashed Kk into the sponge to receive the digest Dk
-    const digest = shake256.create( 8192 ).update( keyFragments ).hex(),
-      // Squeeze the sponge to retrieve a 128 byte (64 character) string that should match the sender’s wallet address
-      address = shake256.create( 256 ).update( digest ).hex();
+    const digestSponge = new JsSHA('SHAKE256', 'TEXT')
+    digestSponge.update(keyFragments)
+    const digest = digestSponge.getHash('HEX', { outputLen: 8192 })
 
+    // Squeeze the sponge to retrieve a 128 byte (64 character) string that should match the sender’s wallet address
+    const addressSponge = new JsSHA('SHAKE256', 'TEXT')
+    addressSponge.update(digest)
+    const address = addressSponge.getHash('HEX', { outputLen: 256 })
 
     // Signing atom
-    let signingAtom = this.molecule.atoms[ 0 ];
+    const signingAtom = this.molecule.atoms[0]
 
     // Get a signing address
-    let signingAddress = signingAtom.walletAddress;
+    let signingAddress = signingAtom.walletAddress
 
     // Get signing wallet from first atom's metas
-    let signingWallet = Dot.get( signingAtom.aggregatedMeta(), 'signingWallet' );
+    const signingWallet = Dot.get(signingAtom.aggregatedMeta(), 'signingWallet')
 
     // Try to get custom signing address from the metas (local molecule with server secret)
-    if ( signingWallet ) {
-      signingAddress = Dot.get( JSON.parse( signingWallet ), 'address' );
+    if (signingWallet) {
+      signingAddress = Dot.get(JSON.parse(signingWallet), 'address')
     }
 
-    if ( address !== signingAddress ) {
-      throw new SignatureMismatchException();
+    if (address !== signingAddress) {
+      throw new SignatureMismatchException()
     }
 
     // Looks like we passed all the tests!
-    return true;
+    return true
   }
-
-
 }