postchain-client 0.7.4 → 0.10.0

package/src/gtv/index.js

@@ -0,0 +1,10 @@
+const {MerkleHashCalculator, CryptoSystem } = require("./merkle/merklehashcalculator");
+const theMerkleHashCalculator = new MerkleHashCalculator(new CryptoSystem);
+const merkleHashSummary = require('./merkle/proof/merkleproof').merkleHashSummary;
+const serialization = require('./serialization');
+
+exports.gtvHash = (obj) => {
+    return merkleHashSummary(obj, theMerkleHashCalculator).merkleHash;
+};
+exports.encodeGtv = serialization.encodeValue;
+exports.decodeGtv = serialization.decodeValue;

package/src/{base → gtv}/merkle/merklehashcalculator.js

@@ -1,4 +1,4 @@
-var serialization = require('../../gtx/serialization')
+var serialization = require('../serialization')
 var HASH_PREFIX_LEAF = require('./binarytree').HASH_PREFIX_LEAF
 var util = require('../../util')
 
@@ -41,7 +41,7 @@ MerkleHashCalculator.prototype.calculateNodeHash = function(prefix, hashLeft, ha
  * @param {*} value
  */
 MerkleHashCalculator.prototype.calculateLeafHash = function(value) {
-  return this.calculateHashOfValueInternal(value, serialization.encode, hashingFun)
+  return this.calculateHashOfValueInternal(value, serialization.encodeValue, hashingFun)
 }
 
 /**
@@ -74,4 +74,4 @@ MerkleHashCalculator.prototype.isContainerProofValueLeaf = function(value) {
   }
 }
 
-module.exports = {MerkleHashCalculator}
+module.exports = {MerkleHashCalculator, CryptoSystem};

package/src/{gtx → gtv}/serialization.js

@@ -1,4 +1,4 @@
-var asn = require('asn1.js');
+var asn = require('asn1.js/lib/asn1');
 
 var ASNDictPair = asn.define('DictPair', function () {
     this.seq().obj(
@@ -18,26 +18,10 @@ var ASNGTXValue = asn.define('GtxValue', function () {
     });
 });
 
-var ASNGTXOperation = asn.define('GtxOperation', function () {
-    this.seq().obj(
-        this.key('opName').utf8str(),
-        this.key('args').seqof(ASNGTXValue)
-    )
-})
-
-
 var ASNBuffer = asn.define('Buffer', function() {
     this.octstr();
 });
 
-var ASNGTXTransaction = asn.define('GtxTransaction', function () {
-    this.seq().obj(
-        this.key('blockchainRID').octstr(),
-        this.key('operations').seqof(ASNGTXOperation),
-        this.key('signers').seqof(ASNBuffer),
-        this.key('signatures').seqof(ASNBuffer)
-    )
-})
 /*
 Messages DEFINITIONS ::= BEGIN
 
@@ -54,58 +38,23 @@ GTXValue ::= CHOICE {
         dict [4] SEQUENCE OF DictPair,
         array [5] SEQUENCE OF GTXValue
 }
-
-GTXOperation ::= SEQUENCE {
-    opName UTF8String,
-        args SEQUENCE OF GTXValue
-}
-
-GTXTransaction ::= SEQUENCE {
-    blockchainID OCTET STRING,
-        operations SEQUENCE OF GTXOperation,
-        signers SEQUENCE OF OCTET STRING,
-        signatures SEQUENCE OF OCTET STRING
-}
-
 END
 */
-/**
- * @param bytes the raw client message
- * @returns {calls:      [{functionName: <funcName>, args: [arg1, arg2, ...]}, ...],
- *           signatures: [{pubKey: <buffer>, signature: <buffer>}]}
- */
-module.exports.decode = (bytes) => {
-    var rawObject = ASNGTXTransaction.decode(bytes);
-    rawObject.operations.forEach(operation => {
-        operation.args = operation.args.map(arg => parseValue(arg));
-    });
-    return rawObject;
-};
 
-module.exports.encode = (opsAndSigs) => {
-    var preparedOps = opsAndSigs.operations.map((op) => {
-        return {opName: op.opName,
-                args: op.args.map((arg) => createTypedArg(arg))}
-    });
-    var toEncode = {blockchainRID: opsAndSigs.blockchainRID, operations: preparedOps,
-                signers: opsAndSigs.signers, signatures: opsAndSigs.signatures}
-    if (toEncode.signatures == null) {
-        // use empty signatures
-        toEncode.signatures = opsAndSigs.signers.map(function () { return Buffer.alloc(0); })
-    }
-    return ASNGTXTransaction.encode(toEncode);
-};
+function encodeValue (arg) {
+    return ASNGTXValue.encode(createTypedArg(arg));
+}
 
-module.exports.encodeValue = (arg) => {
-    return ASNGTXValue.encode(createTypedArg(arg))
-};
+exports.encodeValue = encodeValue;
 
-module.exports.decodeValue = (bytes) => {
+function decodeValue (bytes) {
     const obj = ASNGTXValue.decode(bytes);
     return parseValue(obj);
-};
+}
+
+exports.decodeValue = decodeValue;
 
-var BN = require('bn.js')
+var BN = require('bn.js');
 function parseValue(typedArg) {
     // console.log("Typedarg:", typedArg);
     if (typedArg.type === 'null') {
@@ -124,10 +73,10 @@ function parseValue(typedArg) {
         return typedArg.value.map(item => parseValue(item));
     }
     if (typedArg.type === 'dict') {
-        var result = {}
+        var result = {};
         typedArg.value.forEach(function (pair) {
             result[pair.name] = parseValue(pair.value);
-        })
+        });
         return result
     }
     throw new Error(`Cannot parse typedArg ${typedArg}. Unknown type ${typedArg.type}`);

package/src/gtx/gtx.js

@@ -1,9 +1,10 @@
-var serialization = require('./serialization');
-var util = require('../util');
 
-module.exports.emptyGtx = function (blockchainRID) {
+const util = require('../util');
+const gtv = require("../gtv");
+
+exports.emptyGtx = function (blockchainRID) {
     return {blockchainRID: blockchainRID, operations: [], signers: []};
-}
+};
 
 /**
  * Adds a function call to a GTX. Creates a new GTX if none specified.
@@ -14,7 +15,7 @@ module.exports.emptyGtx = function (blockchainRID) {
  * @returns the gtx
  * @throws if gtx is null or if gtx is already signed
  */
-module.exports.addTransactionToGtx = function (opName, args, gtx) {
+exports.addTransactionToGtx = function (opName, args, gtx) {
     if (gtx == null) {
         throw new Error("No Gtx to add operation to")
     }
@@ -25,50 +26,59 @@ module.exports.addTransactionToGtx = function (opName, args, gtx) {
     return gtx;
 }
 
-module.exports.addSignerToGtx = function (signer, gtx) {
+exports.addSignerToGtx = function (signer, gtx) {
     if (gtx.signatures) {
         throw new Error("Cannot add signers to an already signed gtx");
     }
     gtx.signers.push(signer);
-}
+};
 
 /**
  * Serializes the gtx for signing
  * @param gtx the gtx to serialize
  */
-module.exports.getBufferToSign = function (gtx) {
-    // console.log("Buffer to sign: " + JSON.stringify({calls: gtx.calls, signers: gtx.signers}));
+exports.getDigestToSign = function (gtx) {
+    return gtv.gtvHash(gtvTxBody(gtx));
+};
 
-    return serialization.encode({blockchainRID: gtx.blockchainRID, operations: gtx.operations,
-        signers: gtx.signers, signatures: []});
+function gtvTxBody(txData) {
+    return [
+        txData.blockchainRID,
+        txData.operations.map(
+            (op) => [op.opName, op.args]
+        ),
+        txData.signers
+    ];
 }
 
 /**
  * Signs the gtx with the provided privKey. This is a convenience function
  * for situations where you don't have to ask someone else to sign.
  */
-module.exports.sign = function(privKey, pubKey, gtx) {
-    var bufferToSign = module.exports.getBufferToSign(gtx);
-    var signature = util.sign(bufferToSign, privKey);
+exports.sign = function (privKey, pubKey, gtx) {
+    var digestToSign = module.exports.getDigestToSign(gtx);
+    var signature = util.signDigest(digestToSign, privKey);
     console.log("PubKey: " + pubKey.toString('hex'));
     console.log("Signature: " + signature.toString('hex'));
     module.exports.addSignature(pubKey, signature, gtx);
-}
+};
 
-module.exports.signRawTransaction = function(keyPair, rawTransaction) {
+exports.signRawTransaction = function (keyPair, rawTransaction) {
+    throw Error("TODO");
+    //TODO
     const gtx = module.exports.deserialize(rawTransaction);
     module.exports.sign(keyPair.privKey, keyPair.pubKey, gtx);
     return module.exports.serialize(gtx)
-}
+};
 
 /**
  * Adds a signature to the gtx
  */
-module.exports.addSignature = function(pubKeyBuffer, signatureBuffer, gtx) {
+exports.addSignature = function (pubKeyBuffer, signatureBuffer, gtx) {
     if (!gtx.signatures) {
         gtx.signatures = Array(gtx.signers.length).fill(Buffer.alloc(0));
     }
-    if (gtx.signers.length != gtx.signatures.length) {
+    if (gtx.signers.length !== gtx.signatures.length) {
         throw new Error("Mismatching signers and signatures");
     }
     var signerIndex = gtx.signers.findIndex((signer) => pubKeyBuffer.equals(signer));
@@ -76,20 +86,47 @@ module.exports.addSignature = function(pubKeyBuffer, signatureBuffer, gtx) {
         throw new Error("No such signer, remember to call addSignerToGtx() before adding a signature");
     }
     gtx.signatures[signerIndex] = signatureBuffer;
-}
+};
 
-module.exports.serialize = function(gtx) {
+exports.serialize = function (gtx) {
     if (!gtx.signatures) {
+        // TODO
         // The gtx is not signed, but we must include
         // the signatures attribute, so let's add that.
         gtx.signatures = [];
     }
-    return serialization.encode(gtx);
-}
+    return gtv.encodeGtv([
+        gtvTxBody(gtx),
+        gtx.signatures
+    ]);
+};
+
+exports.deserialize = function (gtxBytes) {
+    const deserializedTx = gtv.decodeGtv(gtxBytes);
+    const body = deserializedTx[0];
+    const gtvTxBody = {
+        blockchainRID: body[0],
+        operations: body[1].map(operation => ({opName: operation[0], args: operation[1]})),
+        signers: body[2]
+    };
+    const signatures = deserializedTx[1];
+
+    return {
+        ...gtvTxBody,
+        signatures
+    }
+};
+
+exports.checkGTXSignatures = function(txHash, gtx) {
+    if(gtx.signatures.length < gtx.signers.length) throw Error("Not enough signatures");
+    for(const i in gtx.signers) {
+        const signValid = util.checkDigestSignature(txHash, gtx.signers[i], gtx.signatures[i]);
+        if(!signValid) return signValid;
+    }
+    return true;
+};
 
-module.exports.deserialize = function(gtxBytes) {
-    return serialization.decode(gtxBytes);
-}
 
-module.exports.encodeValue = serialization.encodeValue;
-module.exports.decodeValue = serialization.decodeValue;
+// DEPRECATED
+exports.encodeValue = gtv.encodeGtv;
+exports.decodeValue = gtv.decodeGtv;

package/src/gtx/gtxclient.js

@@ -3,7 +3,7 @@ var gtxTool = require('./gtx');
 var secp256k1 = require('secp256k1');
 var util = require('../util');
 
-module.exports.createClient = function (restApiClient, blockchainRID, functionNames) {
+exports.createClient = function (restApiClient, blockchainRID, functionNames) {
     functionNames.push('message');
 
     function transaction(gtx) {
@@ -19,11 +19,11 @@ module.exports.createClient = function (restApiClient, blockchainRID, functionNa
             },
 
             getTxRID: function () {
-                return util.sha256(this.getBufferToSign());
+                return this.getDigestToSign();
             },
 
-            getBufferToSign: function () {
-                return gtxTool.getBufferToSign(this.gtx);
+            getDigestToSign: function () {
+                return gtxTool.getDigestToSign(this.gtx);
             },
 
             addSignature: function (pubKey, signature) {

package/src/restclient.js

@@ -3,9 +3,7 @@
 var url = require('url');
 var rq = require('request');
 
-var separateReqPool = {maxSockets: 100};
-
-module.exports.createRestClient = function (urlBase, blockchainRID, maxSockets) {
+exports.createRestClient = function (urlBase, blockchainRID, maxSockets) {
     return {
         config: {urlBase: urlBase, pool: {maxSockets: maxSockets ? maxSockets : 10}},
 
@@ -19,7 +17,7 @@ module.exports.createRestClient = function (urlBase, blockchainRID, maxSockets)
          * the callback will be called with (null, null).
          */
         getTransaction: function (messageHash, callback) {
-            validateMessageHash(messageHash)
+            validateMessageHash(messageHash);
             get(this.config, 'tx/' + blockchainRID + '/' + messageHash.toString('hex'), (error, statusCode, responseObject) => {
                 handleGetResponse(error, statusCode, statusCode === 200 ? Buffer.from(responseObject.tx, 'hex') : null, callback);
             });

package/src/util.js

@@ -24,7 +24,7 @@ module.exports = {
 };
 
 function createPublicKey(privateKey) {
-    if (!Buffer.isBuffer(privateKey) || privateKey.length != 32) {
+    if (!Buffer.isBuffer(privateKey) || privateKey.length !== 32) {
         throw "privateKey must be a Buffer of 32 bytes"
     }
     return secp256k1.publicKeyCreate(privateKey, true);
@@ -164,7 +164,7 @@ function validateMerklePath(path, target, merkleRoot) {
     for (let i = 0; i < path.length; i++) {
         const item = path[i];
 
-        const prefix = (i == 0) ? Buffer.from([1]) : Buffer.from([0]);
+        const prefix = (i === 0) ? Buffer.from([1]) : Buffer.from([0]);
 
         if (item.side === 0) {
             currentHash = hashConcat([prefix, item.hash, prefix, currentHash]);
@@ -215,7 +215,7 @@ function sign(content, privKey) {
     if (!privKey) {
         throw new Error("Programmer error, missing privKey");
     }
-    if (privKey.length != 32) {
+    if (privKey.length !== 32) {
         throw new Error(`Programmer error. Invalid key length. Expected 32, but got ${privKey.length}`);
     }
     var digestBuffer = sha256(content);
@@ -244,8 +244,8 @@ function makeKeyPair() {
     let privKey;
     do {
         privKey = crypto.randomBytes(32)
-    } while (!secp256k1.privateKeyVerify(privKey))
-    const pubKey = secp256k1.publicKeyCreate(privKey)
+    } while (!secp256k1.privateKeyVerify(privKey));
+    const pubKey = secp256k1.publicKeyCreate(privKey);
     return {pubKey, privKey}
 }
 

package/test/{base → gtv}/merkle/merklerootcalculatortest.js

@@ -1,5 +1,5 @@
 var assert = require('chai').assert;
-var merkleHash = require('../../../src/base/merkle/proof/merkleproof').merkleHash
+var merkleHash = require('../../../src/gtv/merkle/proof/merkleproof').merkleHash
 var TreeHelper = require('./treehelper').TreeHelper
 var MerkleHashCalculatorDummy = require('../../merkle/merklehashcalculatordummy').MerkleHashCalculatorDummy
 var calculator = new MerkleHashCalculatorDummy()

package/test/{base → gtv}/merkle/treeprinter.js

@@ -1,14 +1,14 @@
 var StringBuilder = require('../stringbuilder').StringBuilder
-var BinaryTreeElement = require('../../../src/base/merkle/binarytree').BinaryTreeElement
-var BinaryTree = require('../../../src/base/merkle/binarytree').BinaryTree
-var EmptyLeaf = require('../../../src/base/merkle/binarytree').EmptyLeaf
-var Leaf = require('../../../src/base/merkle/binarytree').Leaf
-var Node = require('../../../src/base/merkle/binarytree').Node
-var ProofNode = require('../../../src/base/merkle/proof/merkleprooftree').ProofNode
-var ProofValueLeaf = require('../../../src/base/merkle/proof/merkleprooftree').ProofValueLeaf
-var ProofHashedLeaf = require('../../../src/base/merkle/proof/merkleprooftree').ProofHashedLeaf
-var ProofNodeArrayHead = require('../../../src/base/merkle/proof/merkleprooftree').ProofNodeArrayHead
-var ProofNodeDictHead = require('../../../src/base/merkle/proof/merkleprooftree').ProofNodeDictHead
+var BinaryTreeElement = require('../../../src/gtv/merkle/binarytree').BinaryTreeElement
+var BinaryTree = require('../../../src/gtv/merkle/binarytree').BinaryTree
+var EmptyLeaf = require('../../../src/gtv/merkle/binarytree').EmptyLeaf
+var Leaf = require('../../../src/gtv/merkle/binarytree').Leaf
+var Node = require('../../../src/gtv/merkle/binarytree').Node
+var ProofNode = require('../../../src/gtv/merkle/proof/merkleprooftree').ProofNode
+var ProofValueLeaf = require('../../../src/gtv/merkle/proof/merkleprooftree').ProofValueLeaf
+var ProofHashedLeaf = require('../../../src/gtv/merkle/proof/merkleprooftree').ProofHashedLeaf
+var ProofNodeArrayHead = require('../../../src/gtv/merkle/proof/merkleprooftree').ProofNodeArrayHead
+var ProofNodeDictHead = require('../../../src/gtv/merkle/proof/merkleprooftree').ProofNodeDictHead
 var TreeHelper = require('./treehelper').TreeHelper
 var helper = new TreeHelper()
 

package/test/gtx/checkGTXSignaturetest.js

@@ -0,0 +1,81 @@
+const gtv = require("../../src/gtv");
+
+const assert = require('chai').assert;
+const expect = require('chai').expect;
+const gtxU = require('../../src/gtx/gtx');
+
+var sigs = require('../signatures');
+var sig = sigs.sig;
+var signatures = sigs.signatures;
+var signers = sigs.signers;
+const blockchainRID = Buffer.from("DEADBEEF94");
+
+describe("check gtx signature", () => {
+    function test(txHash, gtx) {
+        console.log("GTX", gtx);
+        const checkResult = gtxU.checkGTXSignatures(txHash, gtx);
+        console.log("RESULT", checkResult);
+        assert.deepEqual(checkResult, true);
+    }
+
+    function testFail(txHash, gtx) {
+        const checkResult = gtxU.checkGTXSignatures(txHash, gtx);
+        assert.deepEqual(checkResult, false)
+    }
+
+    function tx(calls, signers, signaturesCount) {
+        const tx = {blockchainRID, operations: calls, signers};
+        console.log("THE TX", tx);
+        for(let i=0; i<signaturesCount; i++) {
+            const signer = sig(i);
+            gtxU.sign(signer.privKey, signer.pubKey, tx);
+        }
+
+        if(!tx.signatures) tx.signatures = [];
+        return tx;
+    }
+
+    it('empty call should be ok', () => {
+        const aTx = tx( [], [], 0);
+        const txHash = gtxU.getDigestToSign(aTx);
+        test(txHash, aTx);
+    });
+
+    it('empty call with one signature', () => {
+        const aTx = tx( [], [], signatures(1));
+        const txHash = gtxU.getDigestToSign(aTx);
+        test(txHash, aTx);
+    });
+
+    it('single call with no param, one signature and no signers', () => {
+        const aTx = tx([{opName: 'func1åäö', args: []}], [], 0);
+        const txHash = gtxU.getDigestToSign(aTx);
+        test(txHash, aTx);
+    });
+
+    it('single call with not enough signatures FAILS', () => {
+        const aTx = tx([{opName: 'func1åäö', args: []}], signers(2), 1);
+        const txHash = gtxU.getDigestToSign(aTx);
+        const checkResult = () => gtxU.checkGTXSignatures(txHash, aTx);
+        expect(checkResult).to.throw();
+    });
+
+    it('single call with enough signatueres works', () => {
+        const aTx = tx([{opName: 'func1åääö', args: []}], signers(1), 1);
+        const txHash = gtxU.getDigestToSign(aTx);
+        test(txHash, aTx);
+    });
+
+    it('single call with enough multiple signatures work', () => {
+        const aTx = tx([{opName: 'func1åääö', args: []}], signers(2), 2);
+        const txHash = gtxU.getDigestToSign(aTx);
+        test(txHash, aTx)
+    });
+
+    it('multiple calls with enought multiple signatures work', () => {
+        const aTx = tx([{opName: 'func1åääö', args: []}, {opName: 'guess_the_function', args: ['John Doe', 2222]}], signers(3), 3);
+        const txHash = gtxU.getDigestToSign(aTx);
+        test(txHash, aTx)
+    });
+});
+