@wishknish/knishio-client-js 0.4.41 → 0.4.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wishknish/knishio-client-js",
-  "version": "0.4.41",
+  "version": "0.4.44",
   "productName": "Knish.IO Javascript SDK Client",
   "description": "JavaScript implementation of the Knish.IO SDK to consume Knish.IO GraphQL APIs.",
   "license": "GPL-3.0-or-later",
@@ -45,6 +45,7 @@
     "base-x": "^3.0.8",
     "big-integer": "^1.6.48",
     "buffer": "^6.0.3",
+    "core-js": "3.21.1",
     "get-random-values": "^1.2.2",
     "graphql": "^15.5.0",
     "isomorphic-fetch": "^3.0.0",
@@ -58,50 +59,48 @@
     "/src"
   ],
   "devDependencies": {
-    "@babel/core": "^7.12.13",
-    "@babel/plugin-external-helpers": "^7.12.13",
-    "@babel/plugin-proposal-class-properties": "^7.12.13",
-    "@babel/plugin-proposal-decorators": "^7.12.13",
-    "@babel/plugin-proposal-do-expressions": "^7.12.13",
-    "@babel/plugin-proposal-export-default-from": "^7.12.13",
-    "@babel/plugin-proposal-export-namespace-from": "^7.12.13",
-    "@babel/plugin-proposal-function-bind": "^7.12.13",
-    "@babel/plugin-proposal-function-sent": "^7.12.13",
-    "@babel/plugin-proposal-json-strings": "^7.12.13",
-    "@babel/plugin-proposal-logical-assignment-operators": "^7.12.13",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.12.13",
-    "@babel/plugin-proposal-numeric-separator": "^7.12.13",
-    "@babel/plugin-proposal-optional-chaining": "^7.12.13",
-    "@babel/plugin-proposal-pipeline-operator": "^7.12.13",
-    "@babel/plugin-proposal-throw-expressions": "^7.12.13",
+    "@babel/core": "^7.17.8",
+    "@babel/eslint-parser": "^7.17.0",
+    "@babel/eslint-plugin": "^7.17.7",
+    "@babel/plugin-external-helpers": "^7.16.7",
+    "@babel/plugin-proposal-class-properties": "^7.16.7",
+    "@babel/plugin-proposal-decorators": "^7.17.8",
+    "@babel/plugin-proposal-do-expressions": "^7.16.7",
+    "@babel/plugin-proposal-export-default-from": "^7.16.7",
+    "@babel/plugin-proposal-export-namespace-from": "^7.16.7",
+    "@babel/plugin-proposal-function-bind": "^7.16.7",
+    "@babel/plugin-proposal-function-sent": "^7.16.7",
+    "@babel/plugin-proposal-json-strings": "^7.16.7",
+    "@babel/plugin-proposal-logical-assignment-operators": "^7.16.7",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.7",
+    "@babel/plugin-proposal-numeric-separator": "^7.16.7",
+    "@babel/plugin-proposal-optional-chaining": "^7.16.7",
+    "@babel/plugin-proposal-pipeline-operator": "^7.17.6",
+    "@babel/plugin-proposal-throw-expressions": "^7.16.7",
     "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-    "@babel/plugin-syntax-import-meta": "^7.0.0",
-    "@babel/plugin-transform-arrow-functions": "^7.12.13",
-    "@babel/plugin-transform-async-to-generator": "^7.12.13",
-    "@babel/plugin-transform-classes": "^7.12.13",
-    "@babel/plugin-transform-for-of": "^7.12.13",
-    "@babel/plugin-transform-property-mutators": "^7.12.13",
+    "@babel/plugin-syntax-import-meta": "^7.10.4",
+    "@babel/plugin-transform-arrow-functions": "^7.16.7",
+    "@babel/plugin-transform-async-to-generator": "^7.16.8",
+    "@babel/plugin-transform-classes": "^7.16.7",
+    "@babel/plugin-transform-for-of": "^7.16.7",
+    "@babel/plugin-transform-property-mutators": "^7.16.7",
     "@babel/plugin-transform-runtime": "^7.12.15",
     "@babel/plugin-transform-shorthand-properties": "^7.12.13",
-    "@babel/polyfill": "^7.12.1",
     "@babel/preset-env": "^7.12.13",
     "@babel/runtime": "^7.12.13",
     "@rollup/plugin-babel": "^5.2.3",
     "@rollup/plugin-commonjs": "^19.0.0",
+    "@rollup/plugin-inject": "^4.0.4",
     "@rollup/plugin-node-resolve": "^13.0.0",
-    "babel-eslint": "^10.1.0",
+    "@rollup/plugin-replace": "^4.0.0",
     "babel-loader": "^8.2.2",
-    "babel-preset-es2015-rollup": "^3.0.0",
     "eslint": "^7.23.0",
     "eslint-plugin-vue": "^7.8.0",
-    "nodemon": "^2.0.7",
-    "rollup": "^2.38.5",
-    "rollup-plugin-node-polyfills": "^0.2.1",
+    "nodemon": "^2.0.15",
+    "rollup": "^2.70.1",
     "rollup-plugin-peer-deps-external": "^2.2.4",
-    "rollup-plugin-replace": "^2.2.0",
     "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-uglify": "^6.0.4",
-    "uglify-es": "^3.3.9",
+    "uglify-js": "^3.15.3",
     "webpack": "^5.21.1",
     "webpack-cli": "^4.5.0",
     "webpack-merge": "^5.7.3"

package/src/Atom.js

@@ -319,6 +319,11 @@ export default class Atom {
           continue;
         }
 
+        // Excluded keys
+        if ( [ 'otsFragment', 'index' ].includes( property ) ) {
+          continue;
+        }
+
         // Hashing individual meta keys and values
         if ( property === 'meta' ) {
           for ( const meta of value ) {

package/src/KnishIOClient.js

@@ -93,6 +93,7 @@ import QueryAtom from './query/QueryAtom';
 import QueryPolicy from './query/QueryPolicy';
 import MutationCreatePolicy from './mutation/MutationCreatePolicy';
 import QueryMetaTypeViaAtom from './query/QueryMetaTypeViaAtom';
+import MutationCreateRule from './mutation/MutationCreateRule';
 
 
 /**
@@ -460,30 +461,29 @@ export default class KnishIOClient {
       console.info( 'KnishIOClient::createMolecule() - Creating a new molecule...' );
     }
 
-    const _secret = secret || this.getSecret();
-    let _sourceWallet = sourceWallet;
+    secret = secret || this.getSecret();
 
     // Sets the source wallet as the last remainder wallet (to maintain ContinuID)
-    if ( !sourceWallet && this.lastMoleculeQuery && this.getRemainderWallet().token !== 'AUTH' && this.lastMoleculeQuery && this.lastMoleculeQuery.response() && this.lastMoleculeQuery.response().success() ) {
-      _sourceWallet = this.getRemainderWallet();
+    if ( !sourceWallet && this.lastMoleculeQuery && this.getRemainderWallet().token !== 'AUTH' && this.lastMoleculeQuery.response() && this.lastMoleculeQuery.response().success() ) {
+      sourceWallet = this.getRemainderWallet();
     }
 
     // Unable to use last remainder wallet; Figure out what wallet to use:
-    if ( _sourceWallet === null ) {
-      _sourceWallet = await this.getSourceWallet();
+    if ( sourceWallet === null ) {
+      sourceWallet = await this.getSourceWallet();
     }
 
     // Set the remainder wallet for the next transaction
     this.remainderWallet = remainderWallet || Wallet.create( {
-      secretOrBundle: _secret,
+      secretOrBundle: secret,
       token: 'USER',
-      batchId: _sourceWallet.batchId,
-      characters: _sourceWallet.characters
+      batchId: sourceWallet.batchId,
+      characters: sourceWallet.characters
     } );
 
     return new Molecule( {
-      secret: _secret,
-      sourceWallet: _sourceWallet,
+      secret,
+      sourceWallet,
       remainderWallet: this.getRemainderWallet(),
       cellSlug: this.cellSlug()
     } );
@@ -1178,6 +1178,42 @@ export default class KnishIOClient {
     return await this.executeQuery( query );
   }
 
+  /**
+   *
+   * @param {string} metaType
+   * @param {string} metaId
+   * @param {object[]} rule
+   * @param {object} policy
+   * @returns {Promise<ResponseCreateRule>}
+   */
+  async createRule ( {
+    metaType,
+    metaId,
+    rule,
+    policy = {}
+  } ) {
+    /**
+     * @type {MutationCreateRule}
+     */
+    const query = await this.createMoleculeMutation( {
+        mutationClass: MutationCreateRule,
+        molecule: await this.createMolecule( {
+          secret: this.getSecret(),
+          sourceWallet: await this.getSourceWallet()
+        } )
+      }
+    );
+
+    query.fillMolecule( {
+      metaType,
+      metaId,
+      rule,
+      policy
+    } );
+
+    return await this.executeQuery( query );
+  }
+
   /**
    * Builds and executes a molecule to convey new metadata to the ledger
    *
@@ -1759,6 +1795,66 @@ export default class KnishIOClient {
   }
 
 
+
+  /**
+   * Builds and executes a molecule to destroy the specified Token units
+   *
+   * @param {string} token
+   * @param {number|null} amount
+   * @param {array|null} units
+   * @param {Wallet|null} sourceWallet
+   * @return {Promise<unknown>}
+   */
+  async replenishToken ( {
+    token,
+    amount = null,
+    units = [],
+    sourceWallet = null
+  } ) {
+
+
+    if ( sourceWallet === null ) {
+      sourceWallet = ( await this.queryBalance( { token } ) ).payload();
+    }
+    /*
+    if ( !sourceWallet ) {
+      throw new TransferWalletException( 'Source wallet is missing or invalid.' );
+    }
+    */
+
+    // Remainder wallet
+    let remainderWallet = Wallet.create( {
+      secretOrBundle: this.getSecret(),
+      token,
+      characters: sourceWallet.characters
+    } );
+
+    // Batch ID default initialization
+    remainderWallet.initBatchId( {
+      sourceWallet,
+      isRemainder: true
+    } );
+
+
+    // Burn tokens
+    let molecule = await this.createMolecule( {
+      secret: null,
+      sourceWallet,
+      remainderWallet
+    } );
+    molecule.replenishToken( {
+      amount,
+      units
+    } );
+    molecule.sign( {} );
+    molecule.check();
+
+
+    const query = ( new MutationProposeMolecule( this.client(), molecule ) );
+    return this.executeQuery( query );
+  }
+
+
   /**
    * Request a guest auth token
    *

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,119 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (/////////////)
+                       (////////////////(               (//////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        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 {
+
+  /**
+   *
+   * @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;
+  }
+}