@wishknish/knishio-client-js 0.4.39 → 0.4.42

package/src/Molecule.js

@@ -56,10 +56,10 @@ import CheckMolecule from './libraries/check';
 import { generateBundleHash } from './libraries/crypto';
 import AtomsMissingException from './exception/AtomsMissingException';
 import BalanceInsufficientException from './exception/BalanceInsufficientException';
-import MetaMissingException from './exception/MetaMissingException';
 import NegativeAmountException from './exception/NegativeAmountException';
 import { deepCloning } from './libraries/array';
 import Meta from './Meta';
+import Rule from './instance/Rules/Rule';
 
 const USE_META_CONTEXT = false;
 const DEFAULT_META_CONTEXT = 'https://www.schema.org';
@@ -158,13 +158,26 @@ export default class Molecule {
     meta = meta || {};
     wallet = wallet || this.sourceWallet;
 
+    meta[ 'pubkey' ] = wallet.pubkey;
+    meta[ 'characters' ] = wallet.characters;
+
+    return meta;
+  }
+
+
+  /**
+   *
+   * @param wallet
+   * @param meta
+   * @returns {*[]}
+   */
+  tokenUnitMetas ( wallet, meta = [] ) {
+
+    // Add token units meta key
     if ( wallet.hasTokenUnits() ) {
       meta[ 'tokenUnits' ] = wallet.tokenUnitsJson();
     }
 
-    meta[ 'pubkey' ] = wallet.pubkey;
-    meta[ 'characters' ] = wallet.characters;
-
     return meta;
   }
 
@@ -187,49 +200,6 @@ export default class Molecule {
   }
 
 
-  /*
-   * Replenishes non-finite token supplies
-   *
-   * @param {number} amount
-   * @param {string} token
-   * @param {array|object} metas
-   * @return {Molecule}
-   */
-  replenishTokens ( {
-    amount,
-    token,
-    metas
-  } ) {
-    metas.action = 'add';
-
-    for ( let key of [ 'address', 'position', 'batchId' ] ) {
-      if ( typeof metas[ key ] === 'undefined' ) {
-        throw new MetaMissingException( `Molecule::replenishTokens() - Missing ${ key } in meta!` );
-      }
-    }
-
-    this.molecularHash = null;
-
-    this.atoms.push(
-      Atom.create.C( {
-        position: this.sourceWallet.position,
-        walletAddress: this.sourceWallet.address,
-        token: this.sourceWallet.token,
-        amount,
-        batchId: this.sourceWallet.batchId,
-        metaType: 'token',
-        metaId: token,
-        meta: this.finalMetas( metas ),
-        index: this.generateIndex()
-      } )
-    );
-
-    this.addUserRemainderAtom( this.remainderWallet );
-    this.atoms = Atom.sortAtoms( this.atoms );
-
-    return this;
-  }
-
   /**
    * Add user remainder atom for ContinuID
    *
@@ -291,6 +261,7 @@ export default class Molecule {
     return this;
   }
 
+
   /**
    * Burns some amount of tokens from a wallet
    *
@@ -321,7 +292,7 @@ export default class Molecule {
         token: this.sourceWallet.token,
         value: -amount,
         batchId: this.sourceWallet.batchId,
-        meta: this.finalMetas( {} ),
+        meta: this.finalMetas( this.tokenUnitMetas( this.sourceWallet ) ),
         index: this.generateIndex()
       } )
     );
@@ -335,7 +306,7 @@ export default class Molecule {
         batchId: this.remainderWallet.batchId,
         metaType: walletBundle ? 'walletBundle' : null,
         metaId: walletBundle,
-        meta: this.finalMetas( {}, this.remainderWallet ),
+        meta: this.finalMetas( this.tokenUnitMetas( this.remainderWallet ), this.remainderWallet ),
         index: this.generateIndex()
       } )
     );
@@ -346,6 +317,83 @@ export default class Molecule {
 
   }
 
+
+  /*
+   * Replenishes non-finite token supplies
+   *
+   * @param {number} amount
+   * @param {string} token
+   * @param {array|object} metas
+   * @return {Molecule}
+   */
+  replenishToken ( {
+    amount,
+    units = []
+  } ) {
+
+    if ( amount < 0 ) {
+      throw new NegativeAmountException( 'Molecule::replenishToken() - Amount to replenish must be positive!' );
+    }
+
+    // Special code for the token unit logic
+    if ( units.length ) {
+
+      // Prepare token units to formatted style
+      units = Wallet.getTokenUnits( units );
+
+      // Merge token units with source wallet & new items
+      this.remainderWallet.tokenUnits = this.sourceWallet.tokenUnits;
+      for ( const unit of units ) {
+        this.remainderWallet.tokenUnits.push( unit );
+      }
+      this.remainderWallet.balance = this.remainderWallet.tokenUnits.length;
+
+      // Override first atom'a token units to replenish values
+      this.sourceWallet.tokenUnits = units;
+      this.sourceWallet.balance = this.sourceWallet.tokenUnits.length;
+    }
+
+    // Update wallet's balances
+    else {
+      this.remainderWallet.balance = this.sourceWallet.balance + amount;
+      this.sourceWallet.balance = amount;
+    }
+
+    this.molecularHash = null;
+
+    // Initializing a new Atom to remove tokens from source
+    this.atoms.push(
+      Atom.create.V( {
+        position: this.sourceWallet.position,
+        walletAddress: this.sourceWallet.address,
+        token: this.sourceWallet.token,
+        value: this.sourceWallet.balance,
+        batchId: this.sourceWallet.batchId,
+        meta: this.finalMetas( this.tokenUnitMetas( this.sourceWallet ) ),
+        index: this.generateIndex()
+      } )
+    );
+
+    const walletBundle = this.remainderWallet.bundle;
+    this.atoms.push(
+      Atom.create.V( {
+        position: this.remainderWallet.position,
+        walletAddress: this.remainderWallet.address,
+        token: this.sourceWallet.token,
+        value: this.remainderWallet.balance,
+        batchId: this.remainderWallet.batchId,
+        metaType: walletBundle ? 'walletBundle' : null,
+        metaId: walletBundle,
+        meta: this.finalMetas( this.tokenUnitMetas( this.remainderWallet ), this.remainderWallet ),
+        index: this.generateIndex()
+      } )
+    );
+
+    this.atoms = Atom.sortAtoms( this.atoms );
+
+    return this;
+  }
+
   /**
    * Initialize a V-type molecule to transfer value from one wallet to another, with a third,
    * regenerated wallet receiving the remainder
@@ -373,7 +421,7 @@ export default class Molecule {
         token: this.sourceWallet.token,
         value: -amount,
         batchId: this.sourceWallet.batchId,
-        meta: this.finalMetas( {} ),
+        meta: this.finalMetas( this.tokenUnitMetas( this.sourceWallet ) ),
         index: this.generateIndex()
       } )
     );
@@ -388,7 +436,7 @@ export default class Molecule {
         batchId: recipientWallet.batchId,
         metaType: 'walletBundle',
         metaId: recipientWallet.bundle,
-        meta: this.finalMetas( {}, recipientWallet ),
+        meta: this.finalMetas( this.tokenUnitMetas( recipientWallet ), recipientWallet ),
         index: this.generateIndex()
       } )
     );
@@ -402,7 +450,7 @@ export default class Molecule {
         batchId: this.remainderWallet.batchId,
         metaType: 'walletBundle',
         metaId: this.sourceWallet.bundle,
-        meta: this.finalMetas( {}, this.remainderWallet ),
+        meta: this.finalMetas( this.tokenUnitMetas( this.remainderWallet ), this.remainderWallet ),
         index: this.generateIndex()
       } )
     );
@@ -471,7 +519,7 @@ export default class Molecule {
     for ( const walletKey of [ 'walletAddress', 'walletPosition', 'walletPubkey', 'walletCharacters' ] ) {
       // Importing wallet fields into meta object
       if ( !meta[ walletKey ] ) {
-        meta[ walletKey ] = recipientWallet[ walletKey.toLowerCase().substr( 6 ) ];
+        meta[ walletKey ] = recipientWallet[ walletKey.toLowerCase().substring( 6 ) ];
       }
     }
 
@@ -501,27 +549,28 @@ export default class Molecule {
    *
    * @param {string} metaType
    * @param {string} metaId
-   * @param {object|array} meta
+   * @param {object[]} rule,
+   * @param {object} policy
    * @return {Molecule}
    */
   createRule ( {
     metaType,
     metaId,
-    meta
+    rule,
+    policy = {}
   } ) {
-    for ( let key of [ 'conditions', 'callback', 'rule' ] ) {
-
-      if ( typeof meta[ key ] === 'undefined' ) {
-        throw new MetaMissingException( `Molecule::createRule() - Value for required meta key ${ key } in missing!` );
-      }
+    const $rules = [];
 
-      for ( let item of [ '[object Object]', '[object Array]' ] ) {
-        if ( Object.prototype.toString.call( meta[ key ] ) === item ) {
-          meta[ key ] = JSON.stringify( meta[ key ] );
-        }
-      }
+    for ( const $rule of rule ) {
+      $rules.push( $rule instanceof Rule ? $rule : Rule.toObject( $rule ) );
     }
 
+    const rules = {
+      rule: JSON.stringify( $rules )
+    };
+
+    const policies = Meta.policy( rules, policy );
+
     this.addAtom(
       Atom.create.R( {
         position: this.sourceWallet.position,
@@ -529,7 +578,7 @@ export default class Molecule {
         token: this.sourceWallet.token,
         metaType,
         metaId,
-        meta: this.finalMetas( meta, this.sourceWallet ),
+        meta: { ...rules, ...policies },
         index: this.generateIndex()
       } )
     );

package/src/httpClient/ApolloClient.js

@@ -45,7 +45,6 @@ Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
 
 License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
 */
-import { Operation } from '@apollo/client/core';
 import { operationName } from '../libraries/ApolloLink/handler';
 import Client from '../libraries/ApolloLink/Client';
 

package/src/instance/Rules/Callback.js

@@ -0,0 +1,124 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (/////////////)
+                       (////////////////(               (//////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        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 Meta from './Meta';
+import RuleArgumentException from './exception/RuleArgumentException';
+
+
+export default class Callback {
+  // server to execute signed molecule with given atom meta; other options: 'reject' (reject matches);
+  // 'accept' (reject non-matches), 'burn' (require appropriate burning of tokens in same molecule)
+  #action
+  // supporting metadata for executing callback goes here
+  #meta = null
+
+  /**
+   *
+   * @param {string} action
+   * @param {Meta|null} meta
+   */
+  constructor ( {
+    action,
+    meta
+  } ) {
+    if ( meta ) {
+      this.meta = meta;
+    }
+
+    if ( !action ) {
+      throw new RuleArgumentException( 'Callback structure violated, missing mandatory "action" parameter.' );
+    }
+
+    this.#action = action;
+  }
+
+  set meta ( meta ) {
+    if ( ! ( meta instanceof Meta ) ) {
+      throw new RuleArgumentException( 'Incorrect meta argument. The meta argument can only be an instance of the Meta class.' );
+    }
+
+    this.#meta = meta;
+  }
+
+  toJSON () {
+    const meta = {
+      action: this.#action
+    };
+
+    if ( this.#meta ) {
+      meta.meta = this.#meta;
+    }
+
+    return meta;
+  }
+
+  /**
+   *
+   * @param {object} object
+   *
+   * @return Callback
+   */
+  static toObject ( object ) {
+    const callback = new Callback( {
+      action: object.action,
+      meta: null
+    } );
+
+    if ( object.meta ) {
+      callback.meta = new Meta( {
+        metaType: object.meta.metaType,
+        metaId: object.meta.metaId,
+        isotope: object.meta.isotope,
+        token: object.meta.token,
+        amount: object.meta.amount
+      } );
+    }
+
+    return callback;
+  }
+}

package/src/instance/Rules/Meta.js

@@ -0,0 +1,90 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (/////////////)
+                       (////////////////(               (//////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        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
+*/
+
+export default class Meta {
+
+  #metaType
+  #metaId
+  #isotope
+  #token
+  #amount
+
+  /**
+   *
+   * @param {string} metaType
+   * @param {string} metaId
+   * @param {string} isotope
+   * @param {string} token
+   * @param {number} amount
+   */
+  constructor ( {
+    metaType,
+    // keyword that will be automatically replaced on server with sender's wallet bundle,
+    metaId,
+    isotope,
+    token,
+    amount
+  } ) {
+    this.#metaType = metaType;
+    this.#metaId = metaId;
+    this.#isotope = isotope;
+    this.#token = token;
+    this.#amount = amount;
+  }
+
+
+  toJSON () {
+    return {
+      metaType: this.#metaType,
+      metaId: this.#metaId,
+      isotope: this.#isotope,
+      token: this.#token,
+      amount: this.#amount
+    };
+  }
+}

package/src/instance/Rules/Rule.js

@@ -0,0 +1,142 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (/////////////)
+                       (////////////////(               (//////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        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 Callback from './Callback';
+import RuleArgumentException from './exception/RuleArgumentException';
+
+
+export default class Rule {
+  // which metadata field are we targeting? (if we're dealing with a ledger object like a Wallet,
+  // this could be internal fields like 'amount', etc.)
+  #key
+  // what is the target value that will trigger the rule? (meta value OR token amount)
+  #value
+  // same list of possible options as when querying
+  #comparison
+  #callback
+
+  /**
+   *
+   * @param {string} key
+   * @param {string} value
+   * @param {string} comparison
+   * @param {Callback[]} callback
+   */
+  constructor ( {
+    key,
+    value,
+    comparison = '===',
+    callback = []
+  } ) {
+    if ( !key ) {
+      throw new RuleArgumentException( 'Rule structure violated, missing mandatory "key" parameter!' );
+    }
+
+    if ( !value ) {
+      throw new RuleArgumentException( 'Rule structure violated, missing mandatory "value" parameter' );
+    }
+
+    for ( const element of callback ) {
+      if ( ! ( element instanceof Callback ) ) {
+        throw new RuleArgumentException();
+      }
+    }
+
+    this.#key = key;
+    this.#value = value;
+    this.#comparison = comparison;
+    this.#callback = callback;
+  }
+
+  /**
+   *
+   * @param {string} comparison
+   */
+  set comparison ( comparison ) {
+    this.#comparison = comparison;
+  }
+
+  set callback ( callback ) {
+    this.#callback.push( callback );
+  }
+
+  toJSON () {
+    return {
+      key: this.#key,
+      value: this.#value,
+      comparison: this.#comparison,
+      callback: this.#callback
+    };
+  }
+
+  /**
+   *
+   * @param {object} object
+   *
+   * @return {Rule}
+   */
+  static toObject ( object ) {
+
+    const rule = new Rule( {
+      key: object.key,
+      value: object.value
+    } );
+
+    if ( object.comparison ) {
+      rule.comparison = object.comparison;
+    }
+
+    if ( object.callback ) {
+      for ( const callback of object.callback ) {
+        rule.callback = callback instanceof Callback ? callback : Callback.toObject( callback );
+      }
+    }
+
+    return rule;
+  }
+}

package/src/instance/Rules/exception/RuleArgumentException.js

@@ -0,0 +1,15 @@
+import BaseException from '../../../exception/BaseException';
+
+export default class RuleArgumentException extends BaseException {
+  /**
+   * Class constructor
+   *
+   * @param {string} message
+   * @param {string|null} fileName
+   * @param {number|null} lineNumber
+   */
+  constructor ( message = 'An incorrect argument!', fileName = null, lineNumber = null ) {
+    super( message, fileName, lineNumber );
+    this.name = 'RuleArgumentException';
+  }
+}

package/src/libraries/ApolloLink/AuthLink.js

@@ -46,9 +46,7 @@ Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
 License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
 */
 import {
-  ApolloLink,
-  Operation,
-  NextLink
+  ApolloLink
 } from '@apollo/client/core';
 
 

package/src/libraries/ApolloLink/CipherLink.js

@@ -1,7 +1,5 @@
 import {
-  ApolloLink,
-  Operation,
-  NextLink
+  ApolloLink
 } from '@apollo/client/core';
 import { print } from 'graphql';
 import { gql } from '@apollo/client/core';