postchain-client 0.9.2 → 0.10.3

package/dist/postchain-client.js.LICENSE.txt

@@ -0,0 +1,17 @@
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+/*! https://mths.be/punycode v1.3.2 by @mathias */
+
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "postchain-client",
-  "version": "0.9.2",
+  "version": "0.10.3",
   "description": "Client library for accessing a Postchain node through REST.",
   "repository": {
     "type": "git",
     "url": "ssh://git@bitbucket.org/chromawallet/postchain-client.git"
   },
-  "main": "index.js",
+  "main": "dist/postchain-client.js",
   "scripts": {
     "test": "npm run test:regtest",
     "build": "webpack --config webpack.config.js",
-    "test:regtest": "find test/ -type f -name \"*.js\" | grep -v \"manual\\.js\"| xargs mocha --reporter spec"
+    "test:regtest": "find test/ -type f -name \"*.js\" | grep -v \"manual\\.js\"| xargs mocha --reporter spec",
+    "prepare": "npm run build"
   },
   "author": "ChromaWay AB",
   "contributors": [
@@ -23,7 +24,6 @@
   "dependencies": {
     "asn1.js": "^4.10.1",
     "browser-request": "^0.3.3",
-    "collections": "^5.1.8",
     "request": "^2.81.0",
     "secp256k1": "^3.5.0"
   },
@@ -31,11 +31,15 @@
     "request": "browser-request"
   },
   "devDependencies": {
-    "babel-preset-es2015": "^6.24.1",
+    "@babel/core": "^7.17.0",
+    "@babel/preset-env": "^7.16.11",
+    "babel-loader": "^8.2.3",
     "body-parser": "^1.17.1",
     "chai": "^3.5.0",
     "express": "^4.15.2",
     "mocha": "^6.1.4",
-    "webpack": "^3.11.0"
+    "node-polyfill-webpack-plugin": "^1.1.4",
+    "webpack": "^5.68.0",
+    "webpack-cli": "^4.9.2"
   }
 }

package/src/gtv/merkle/path.js

@@ -1,8 +1,5 @@
 "use strict"
 
-var Set = require("collections/set").Set;
-var List = require("collections/list").List;
-
 function PathElement(previous) {
   this.previous = previous
 }
@@ -83,7 +80,7 @@ DictPathElement.prototype.equals = function(other) {
 
 /**
  * 
- * @param {List} pathElements 
+ * @param {Array} pathElements
  */
 function Path(pathElements) {
   this.pathElements = pathElements
@@ -93,7 +90,7 @@ function Path(pathElements) {
  * 
  */
 Path.prototype.getCurrentPathElement = function() {
-  return this.pathElements.peek()
+  return this.pathElements[0]
 }
 
 /**
@@ -163,7 +160,7 @@ var getTail = function(searchKey, path) {
   }
 
   try {
-    var firstElement = path.pathElements.peek()
+    var firstElement = path.pathElements[0]
     if (firstElement instanceof SearchablePathElement) {
       if (firstElement.getSearchKey() == searchKey) {   
         return path.tail()
@@ -178,12 +175,10 @@ var getTail = function(searchKey, path) {
 
 /**
  * 
- * @param {Array} paths 
+ * @param {Array} paths
  */
 function PathSet(paths) {
-  // convert inside path into Set from input array path
-  var set = new Set(paths)
-  this.paths = set
+  this.paths = paths
 }
 
 /**
@@ -253,9 +248,9 @@ PathSet.prototype.errorCheckUnequalParent = function(currPath, currElem, prevPat
  */
 PathSet.prototype.keepOnlyArrayPaths = function() {
   var filteredPaths = this.paths.filter(path => {
-    return path.pathElements.peek() instanceof ArrayPathElement
+    return path.pathElements[0] instanceof ArrayPathElement
   })
-  return new PathSet(filteredPaths.toArray())
+  return new PathSet(filteredPaths)
 }
 
 /**
@@ -263,9 +258,9 @@ PathSet.prototype.keepOnlyArrayPaths = function() {
  */
 PathSet.prototype.keepOnlyDictPaths = function() {
   var filteredPaths = this.paths.filter(path => {
-    return path.pathElements.peek() instanceof DictPathElement
+    return path.pathElements[0] instanceof DictPathElement
   })
-  return new PathSet(filteredPaths.toArray())
+  return new PathSet(filteredPaths)
 }
 
 /**
@@ -301,7 +296,7 @@ PathSet.prototype.getTailFromList = function(searchKey, filterFunc) {
  * @param {Array} arr 
  */
 var buildPathFromArray = function(arr) {
-  var pathElementList = new List([])
+  var pathElements = new Array()
   var lastPathElem = null
 
   arr.forEach(item => {
@@ -313,12 +308,12 @@ var buildPathFromArray = function(arr) {
     } else {
       throw new Error("A path structure must only consist of Ints and Strings, not " + item)
     }
-    pathElementList.add(newElem)
+    pathElements.push(newElem)
     lastPathElem = newElem
   })
   var lastOne = lastPathElem
-  pathElementList.add(new PathLeafElement(lastOne))
-  return new Path(pathElementList)
+  pathElements.push(new PathLeafElement(lastOne))
+  return new Path(pathElements)
 }
 
 module.exports = {Path, PathElement, PathLeafElement, ArrayPathElement, SearchablePathElement, DictPathElement, PathSet, 

package/src/gtv/merkle/proof/merkleprooftreefactory.js

@@ -15,7 +15,7 @@ var ArrayHeadNode = require('../binarytree').ArrayHeadNode
 var DictHeadNode = require('../binarytree').DictHeadNode
 var ProofNodeSimple = require('./merkleprooftree').ProofNodeSimple
 
-const EMPTY_HASH = new Buffer(32)
+const EMPTY_HASH = new Buffer.alloc(32)
 /**
  * 
  */

package/src/gtv/serialization.js

@@ -97,7 +97,7 @@ function createTypedArg(value) {
             if (!Number.isInteger(value)) {
                 throw Error("User error: Only integers are supported");
             }
-            return {type: 'integer', value: new BN(value)}
+            return {type: 'integer', value: new BN(value.toString())}
         }
         if (value.constructor === Array) {
             return {type: 'array', value: value.map(item => createTypedArg(item))};

package/src/gtx/gtx.js

@@ -104,13 +104,20 @@ exports.serialize = function (gtx) {
 exports.deserialize = function (gtxBytes) {
     const deserializedTx = gtv.decodeGtv(gtxBytes);
     const body = deserializedTx[0];
-    const signatures = deserializedTx[1];
-    return {
+    const gtvTxBody = {
         blockchainRID: body[0],
         operations: body[1].map(operation => ({opName: operation[0], args: operation[1]})),
-        signers: body[2],
-        signatures
+        signers: body[2]
     };
+    const signatures = deserializedTx[1];
+
+    return {
+        //...gtvTxBody,
+        blockchainRID: gtvTxBody.blockchainRID,
+        operations: gtvTxBody.operations,
+        signers: gtvTxBody.signers,
+        signatures
+    }
 };
 
 exports.checkGTXSignatures = function(txHash, gtx) {

package/src/restclient.js

@@ -2,6 +2,21 @@
 
 var url = require('url');
 var rq = require('request');
+var util = require('./util');
+
+class TxRejectedError extends Error {
+    constructor(rejectReason) {
+        super("Transaction was rejected");
+        this.name = "TxRejectedError";
+        this.fullReason = rejectReason;
+        const parsed = rejectReason.match(/^\[(.+)\] Operation '(.+)' failed: (.+)$/)
+        if (parsed) {
+            this.shortReason = parsed[3];
+            this.rellLine = parsed[1];
+            this.operation = parsed[2];
+        }
+    }
+}
 
 exports.createRestClient = function (urlBase, blockchainRID, maxSockets) {
     return {
@@ -132,7 +147,7 @@ exports.createRestClient = function (urlBase, blockchainRID, maxSockets) {
                         const status = res.status;
                         switch (status) {
                             case "confirmed": resolve(null); break;
-                            case "rejected": reject(Error("Message was rejected")); break;
+                            case "rejected": reject(new TxRejectedError(res.rejectReason)); break;
                             case "unknown": reject(Error("Server lost our message")); break;
                             case "waiting":
                                 setTimeout(
@@ -141,7 +156,7 @@ exports.createRestClient = function (urlBase, blockchainRID, maxSockets) {
                                 );
                                 break;
                             default:
-                                console.log(status);
+                                util.logError(status);
                                 reject(Error("got unexpected response from server"));
                         }
                     }
@@ -156,7 +171,10 @@ exports.createRestClient = function (urlBase, blockchainRID, maxSockets) {
                 this.postTransaction(serializedTransaction, (err) => {
                     if (err) reject(err);
                     else {
-                        this.waitConfirmation(txRID).then(resolve, reject);
+                        setTimeout(
+                            () => this.waitConfirmation(txRID).then(resolve, reject),
+                            1011
+                        )
                     }
                 })
 
@@ -168,24 +186,25 @@ exports.createRestClient = function (urlBase, blockchainRID, maxSockets) {
 function doPost(config, path, jsonObject, responseCallback) {
     post(config, path, jsonObject, (error, statusCode, responseObject) => {
         if (error) {
-            console.log("In restclient doPost().", error);
+            util.logError("In restclient doPost().", error);
             responseCallback(error);
         } else if (statusCode != 200) {
-            console.log(`Unexpected status code from server: ${statusCode}`);
+            util.logError(`Unexpected status code from server: ${statusCode}`);
             responseCallback(new Error(`Unexpected status code from server: ${statusCode}`), responseObject);
         } else {
             try {
-                console.log(`Ok calling responseCallback with responseObject: ${JSON.stringify(responseObject)}`);
+                util.logInfo(`Ok calling responseCallback with responseObject: ${JSON.stringify(responseObject)}`);
                 responseCallback(null, responseObject);
             } catch (error) {
-                console.error("restclient.doPost(): Failed to call callback function", error);
+                util.logError("restclient.doPost(): Failed to call callback function", error);
             }
         }
     });
 }
 
 function get(config, path, callback) {
-    console.log("GET URL " + url.resolve(config.urlBase, path));
+    util.logDebug("GET URL " + url.resolve(config.urlBase, path));
+
     var options = {
         method: 'GET', url: url.resolve(config.urlBase, path),
         json: true, pool: config.pool
@@ -194,18 +213,18 @@ function get(config, path, callback) {
         if (err) callback(err);
         else {
             try {
-                console.log("BODY", body);
-                console.log(typeof body);
+                util.logDebug("BODY", body);
                 callback(null, response.statusCode, body);
             } catch (e) {
-                console.error("restclient.get(): Failed to call callback function", e);
+                util.logError("restclient.get(): Failed to call callback function", e);
             }
         }
     });
 }
 
 function post(config, path, jsonBody, callback) {
-    console.log("POST URL " + url.resolve(config.urlBase, path));
+    util.logDebug("POST URL " + url.resolve(config.urlBase, path));
+
     let options = {
         method: 'POST', url: url.resolve(config.urlBase, path),
         json: true, body: jsonBody, pool: config.pool
@@ -214,8 +233,7 @@ function post(config, path, jsonBody, callback) {
         if (err) callback(err);
         else {
             try {
-                console.log(body);
-                console.log(typeof body);
+                util.logDebug(body);
                 callback(null, response.statusCode, body !== null ? body : null);
             } catch (e) {
                 callback(e);
@@ -238,7 +256,7 @@ function handleGetResponse(error, statusCode, responseObject, callback) {
     if (error) {
         callback(error);
     } else if (statusCode === 404) {
-        console.log("404 received");
+        util.logError("404 received");
         callback(null, null);
     } else if (statusCode != 200) {
         callback(new Error("Unexpected status code from server: " + statusCode));
@@ -246,7 +264,7 @@ function handleGetResponse(error, statusCode, responseObject, callback) {
         try {
             callback(null, responseObject);
         } catch (error) {
-            console.error("restclient.handleGetResponse(): Failed to call callback function", error);
+            util.logError("restclient.handleGetResponse(): Failed to call callback function", error);
         }
     }
 }

package/src/util.js

@@ -21,6 +21,10 @@ module.exports = {
     makeTuid: makeTuid,
     toBuffer: toBuffer,
     verifyKeyPair: verifyKeyPair,
+    logDebug: logDebug,
+    logError: logError,
+    logInfo: logInfo,
+    setLogLevel: setLogLevel
 };
 
 function createPublicKey(privateKey) {
@@ -275,4 +279,20 @@ function toBuffer(key) {
 function verifyKeyPair(privKey) {
     const pubKey = secp256k1.publicKeyCreate(privKey);
     return {pubKey, privKey};
-}
+}
+
+let logLevel = 2;
+
+function logDebug() {
+    if (logLevel >= 3) console.log.apply(console, arguments);
+}
+
+function logError() {
+   if (logLevel != -1)console.error.apply(console, arguments);
+}
+
+function logInfo () {
+  if (logLevel >= 1) console.log.apply(console, arguments);
+}
+
+function setLogLevel(level) { logLevel = level; }

package/test/merkle/pathtest.js

@@ -27,10 +27,10 @@ describe('path test', () => {
   it('test path get tail', () => {
     var org = path.buildPathFromArray([0, 7])
     assert.equal(org.size(), 3)
-    assert.equal(0, org.pathElements.peek().index)
+    assert.equal(0, org.pathElements[0].index)
     var tail = path.getTailIfFirstElementIsArrayOfThisIndex(0, org)
     assert.equal(2, tail.size())
-    assert.equal(7, tail.pathElements.peek().index)
+    assert.equal(7, tail.pathElements[0].index)
     var tail2 = path.getTailIfFirstElementIsArrayOfThisIndex(1, org) // won't find anything at index = 1
     assert.isNull(tail2)
     var tail7 = path.getTailIfFirstElementIsArrayOfThisIndex(7, tail)
@@ -54,7 +54,7 @@ describe('pathset test', () => {
 
     // ------------ Build the set --------------
     var paths = new  path.PathSet([path1, path2, path3])
-    assert.equal(3, paths.paths.size)
+    assert.equal(3, paths.paths.length)
 
     // ------------ Dig down and extract --------------
     var elem = paths.getPathLeafOrElseAnyCurrentPathElement()
@@ -63,37 +63,37 @@ describe('pathset test', () => {
 
     // ---- 0. The short path ---
     var pathsWithIndex0 = paths.getTailIfFirstElementIsArrayOfThisIndexFromList(0)
-    assert.equal(1, pathsWithIndex0.paths.size)
+    assert.equal(1, pathsWithIndex0.paths.length)
     var elemIndex0 = pathsWithIndex0.getPathLeafOrElseAnyCurrentPathElement()
     expect(new path.ArrayPathElement(null, 7).equals(elemIndex0)).to.be.true
 
     // ---- 1. Dead end ---
     var pathsWithIndex1 = paths.getTailIfFirstElementIsArrayOfThisIndexFromList(1)
-    assert.equal(0, pathsWithIndex1.paths.size)
+    assert.equal(0, pathsWithIndex1.paths.length)
     var elemIndex1 = pathsWithIndex1.getPathLeafOrElseAnyCurrentPathElement()
     assert.equal(null, elemIndex1)
 
     // ---- 3. The long path ---
     var pathsWithIndex3 = paths.getTailIfFirstElementIsArrayOfThisIndexFromList(3)
-    assert.equal(2, pathsWithIndex3.paths.size)
+    assert.equal(2, pathsWithIndex3.paths.length)
     var elemIndex3 = pathsWithIndex3.getPathLeafOrElseAnyCurrentPathElement()
     expect(new path.DictPathElement(null, "myKey").equals(elemIndex3)).to.be.true
 
     var pathWithIndexMyKey = pathsWithIndex3.getTailIfFirstElementIsDictOfThisKeyFromList("myKey")
-    assert.equal(2, pathWithIndexMyKey.paths.size)
+    assert.equal(2, pathWithIndexMyKey.paths.length)
     var elemIndex3myKey = pathWithIndexMyKey.getPathLeafOrElseAnyCurrentPathElement()
     expect(new path.ArrayPathElement(null, 2).equals(elemIndex3myKey)).to.be.true
 
     // Look for First leaf
     var myKeyPathsWithIndex2 = pathWithIndexMyKey.getTailIfFirstElementIsArrayOfThisIndexFromList(2)
-    assert.equal(2, myKeyPathsWithIndex2.paths.size)
+    assert.equal(2, myKeyPathsWithIndex2.paths.length)
     var elemIndex3myKeyLeaf = myKeyPathsWithIndex2.getPathLeafOrElseAnyCurrentPathElement()
     // Even though there are two possible elements, one is a leaf and that one must be returned.
     expect(new path.PathLeafElement(dummyPrevElem).equals(elemIndex3myKeyLeaf)).to.be.true
 
     // Look for Second leaf
     var myKeyPathsWithIndex2And5 = myKeyPathsWithIndex2.getTailIfFirstElementIsArrayOfThisIndexFromList(5)
-    assert.equal(1, myKeyPathsWithIndex2And5.paths.size)
+    assert.equal(1, myKeyPathsWithIndex2And5.paths.length)
     var elemIndex3myKey2Leaf = myKeyPathsWithIndex2And5.getPathLeafOrElseAnyCurrentPathElement()
     // One leaf left, should be a trivial check    
     expect(new path.PathLeafElement(dummyPrevElem).equals(elemIndex3myKey2Leaf)).to.be.true

package/webpack.config.js

@@ -1,4 +1,4 @@
-var path = require('path');
+const NodePolyfillPlugin = require("node-polyfill-webpack-plugin")
 
 module.exports = {
   entry: './index.js',
@@ -6,6 +6,23 @@ module.exports = {
     filename: 'postchain-client.js',
     libraryTarget: "umd",
     library: "PostchainClient"
-  }
+  },
+  module: {
+    rules: [
+      {
+        test: /\.m?js$/,
+        exclude: /(node_modules|bower_components)/,
+        use: {
+          loader: 'babel-loader',
+          options: {
+            presets: ['@babel/preset-env']
+          }
+        }
+      }
+    ]
+  },
+  plugins: [
+      new NodePolyfillPlugin()
+  ]
 };