Make sdk/node tests work

This commit adds missing files needed for by the SDK/node. These files
are brought over from
<https://github.com/hyperledger/fabric/tree/master/sdk/node/lib>,
and are needed for building the sdk/node and for unit testing.
These files were left out during the migration as they were listed in
the .gitignore file.

In addition, this patchset:
- Adds fixes (use byte arrays as arguments and use Txid instead of Uuid).
- Updates hash.js to also reuse SJCL's bytes codec for converting from
  and to BitArrays when using sha3 on the client-side.

Change-Id: I8e7f5ef9be7f187bcd2ca6948f04c9b122b9ec31
Signed-off-by: Gabor Hosszu <gabor@digitalasset.com>
Signed-off-by: Jonathan Levi <jonathan@levi.name>

sdk/node/.gitignore

@@ -4,4 +4,6 @@ node_modules/*
 /node.iml
 /typings/
 /doc/
-/lib/
+/lib/*
+!/lib/protos/google
+!/lib/hash.js

sdk/node/lib/hash.js

@@ -0,0 +1,168 @@
+/**
+ * Copyright 2016 IBM
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+/**
+ * Licensed Materials - Property of IBM
+ * © Copyright IBM Corp. 2016
+ */
+
+/**
+ * Implement hash primitives.
+ * Currently SHA3 is implemented, but needs to also add SHA2.
+ *
+ * NOTE: This is in pure java script to be compatible with the sjcl.hmac function.
+ */
+var sjcl = require('sjcl');
+var jssha = require('jssha');
+var sha3_256 = require('js-sha3').sha3_256;
+var sha3_384 = require('js-sha3').sha3_384;
+
+
+hash_sha2_256 = function (hash) {
+
+    if (hash) {
+        this._hash = hash._hash;
+    }
+    else {
+        this.reset();
+    }
+};
+
+hash_sha2_256.hash = function (data) {
+    return (new sjcl.hash.sha256()).update(data).finalize();
+};
+
+hash_sha2_256.prototype = {
+
+    blockSize: 512,
+
+    reset: function () {
+        this._hash = new sjcl.hash.sha256();
+        this._hash.reset();
+    },
+
+    update: function (data) {
+        this._hash.update(data);
+        return this;
+    },
+
+    finalize: function () {
+        var hash = this._hash.finalize();
+        this.reset();
+        return hash;
+
+    }
+};
+
+
+var hash_sha3_256 = function (hash) {
+
+    if (hash) {
+        this._hash = hash._hash;
+    }
+    else {
+        this.reset();
+    }
+};
+
+hash_sha3_256.hash = function (data) {
+    var hashBits = sjcl.codec.hex.toBits(sha3_256(bitsToBytes(data)));
+    return hashBits;
+};
+
+hash_sha3_256.prototype = {
+
+    blockSize: 1088,
+
+    reset: function () {
+        this._hash = sha3_256.create();
+    },
+
+    update: function (data) {
+        this._hash.update(bitsToBytes(data));
+        return this;
+    },
+
+    finalize: function () {
+        var hash = this._hash.hex();
+        var hashBits = sjcl.codec.hex.toBits(hash);
+        this.reset();
+        return hashBits;
+
+    }
+};
+
+var hash_sha3_384 = function (hash) {
+
+    if (hash) {
+        this._hash = hash._hash;
+    }
+    else {
+        this.reset();
+    }
+};
+
+hash_sha3_384.hash = function (data) {
+    var hashBits = sjcl.codec.hex.toBits(sha3_384(bitsToBytes(data)));
+    return hashBits;
+};
+
+hash_sha3_384.prototype = {
+
+    blockSize: 832,
+
+    reset: function () {
+        this._hash = sha3_384.create();
+    },
+
+    update: function (data) {
+        this._hash.update(bitsToBytes(data));
+        return this;
+    },
+
+    finalize: function () {
+        var hash = this._hash.hex();
+        var hashBits = sjcl.codec.hex.toBits(hash);
+        //debug('finalize hashBits:\n',hashBits)
+        this.reset();
+        return hashBits;
+
+    }
+};
+
+/**
+ * Convert from a bitArray to bytes (using SJCL's codec)
+ * @param {bits} a bitArray to convert from
+ * @return {bytes} the bytes converted from the bitArray
+ */
+bitsToBytes = function (bits) {
+   return sjcl.codec.bytes.fromBits(bits);
+}
+
+/**
+ * Convert from bytes to a bitArray (using SJCL's codec)
+ * @param {bytes} a bytes to convert from
+ * @return {bitArray} the bitArray converted from bytes
+ */
+bytesToBits = function (bytes) {
+    return sjcl.codec.bytes.toBits(bytes);
+}
+
+exports.hash_sha3_256 = hash_sha3_256;
+exports.hash_sha3_384 = hash_sha3_384;
+exports.hash_sha2_256 = hash_sha2_256;
+exports.sha2_256 = function (data) {
+    return bitsToBytes(new sjcl.hash.sha256().update(bytesToBits(data)).finalize());
+};

sdk/node/lib/protos/google/protobuf/empty.proto

@@ -0,0 +1,53 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option go_package = "github.com/golang/protobuf/ptypes/empty";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "EmptyProto";
+option java_multiple_files = true;
+option java_generate_equals_and_hash = true;
+option objc_class_prefix = "GPB";
+option cc_enable_arenas = true;
+
+// A generic empty message that you can re-use to avoid defining duplicated
+// empty messages in your APIs. A typical example is to use it as the request
+// or the response type of an API method. For instance:
+//
+//     service Foo {
+//       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+//     }
+//
+// The JSON representation for `Empty` is empty JSON object `{}`.
+message Empty {}

sdk/node/lib/protos/google/protobuf/timestamp.proto

@@ -0,0 +1,110 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option java_package = "com.google.protobuf";
+option java_outer_classname = "TimestampProto";
+option java_multiple_files = true;
+option java_generate_equals_and_hash = true;
+option objc_class_prefix = "GPB";
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     now = time.time()
+//     seconds = int(now)
+//     nanos = int((now - seconds) * 10**9)
+//     timestamp = Timestamp(seconds=seconds, nanos=nanos)
+//
+//
+message Timestamp {
+
+  // Represents seconds of UTC time since Unix epoch
+  // 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
+  // 9999-12-31T23:59:59Z inclusive.
+  int64 seconds = 1;
+
+  // Non-negative fractions of a second at nanosecond resolution. Negative
+  // second values with fractions must still have non-negative nanos values
+  // that count forward in time. Must be from 0 to 999,999,999
+  // inclusive.
+  int32 nanos = 2;
+}