Merge branch '1.0.0' into 366-refactor_transaction_bytes

.babelrc

@@ -3,6 +3,9 @@
 	"env": {
 		"test": {
 			"plugins": ["istanbul", "rewire"]
+		},
+		"browsertest": {
+			"plugins": ["rewire"]
 		}
 	}
 }

Gruntfile.js

@@ -26,7 +26,7 @@ module.exports = function configureGrunt(grunt) {
 			prepareDistNode: 'rm -r dist-node/* || mkdir dist-node | echo',
 			prepareDistBrowser: 'rm -r dist-browser/* || mkdir dist-browser | echo',
 			babel: './node_modules/.bin/babel src --out-dir ./dist-node',
-			babelTest: './node_modules/.bin/babel src --out-dir ./browsertest/src && ./node_modules/.bin/babel test --ignore test/transactions/dapp.js --out-dir ./browsertest/test',
+			babelTest: './node_modules/.bin/babel src --out-dir ./browsertest/src && BABEL_ENV=browsertest ./node_modules/.bin/babel test --ignore test/transactions/dapp.js --out-dir ./browsertest/test',
 			tidyTest: 'rm -r browsertest/{src,test}',
 		},
 
@@ -36,11 +36,11 @@ module.exports = function configureGrunt(grunt) {
 
 		browserify: {
 			dist: {
-				src: './dist-node/*',
+				src: './dist-node/*.js',
 				dest: './dist-browser/lisk-js.js',
 			},
 			test: {
-				src: './browsertest/test/**/*.js',
+				src: ['./browsertest/test/*.js', './browsertest/test/**/*.js'],
 				dest: './browsertest/browsertest.js',
 			},
 			options: {

package.json

@@ -10,6 +10,7 @@
 		"eslint": "./node_modules/.bin/grunt eslint --verbose",
 		"jenkins": "./node_modules/.bin/grunt jenkins --verbose",
 		"build": "grunt",
+		"buildBrowsertest": "grunt build-browsertest",
 		"prepush": "grunt eslint && npm test",
 		"prepublishOnly": "npm run build"
 	},

src/api/privateApi.js

@@ -248,7 +248,9 @@ function handleSendRequestFailures(requestMethod, requestType, options, error) {
 	if (checkReDial.call(that)) {
 		return new Promise(((resolve, reject) => {
 			setTimeout(() => {
-				banNode.call(that);
+				if (that.randomPeer) {
+					banNode.call(that);
+				}
 				that.setNode();
 				that.sendRequest(requestMethod, requestType, options)
 					.then(resolve, reject);

src/crypto/convert.js

@@ -36,7 +36,7 @@ export function bufferToHex(buffer) {
  */
 
 export function hexToBuffer(hex) {
-	return naclInstance.from_hex(hex);
+	return Buffer.from(hex, 'hex');
 }
 
 /**

src/crypto/sign.js

@@ -22,74 +22,81 @@ import {
 } from './convert';
 import {
 	getRawPrivateAndPublicKeyFromSecret,
-	getPrivateAndPublicKeyFromSecret,
 } from './keys';
 import { getTransactionHash, getSha256Hash } from './hash';
 
 /**
  * @method signMessageWithSecret
- * @param message
- * @param secret
+ * @param message - utf8
+ * @param secret - utf8
  *
- * @return {string}
+ * @return {Object} - message, publicKey, signature
  */
 
 export function signMessageWithSecret(message, secret) {
-	const msgBytes = naclInstance.encode_utf8(message);
-	const { privateKey } = getRawPrivateAndPublicKeyFromSecret(secret);
+	const msgBytes = Buffer.from(message, 'utf8');
+	const { privateKey, publicKey } = getRawPrivateAndPublicKeyFromSecret(secret);
+	const signature = naclInstance.crypto_sign_detached(msgBytes, privateKey);
 
-	const signedMessage = naclInstance.crypto_sign(msgBytes, privateKey);
-	const hexSignedMessage = bufferToHex(signedMessage);
-
-	return hexSignedMessage;
+	return {
+		message,
+		publicKey: bufferToHex(publicKey),
+		signature: Buffer.from(signature).toString('base64'),
+	};
 }
 
 /**
  * @method signMessageWithTwoSecrets
- * @param message
- * @param secret
- * @param secondSecret
+ * @param message - utf8
+ * @param secret - utf8
+ * @param secondSecret - utf8
  *
- * @return {string}
+ * @return {Object} - message, publicKey, secondPublicKey, signature, secondSignature
  */
 
 export function signMessageWithTwoSecrets(message, secret, secondSecret) {
-	const msgBytes = naclInstance.encode_utf8(message);
+	const msgBytes = Buffer.from(message, 'utf8');
 	const keypairBytes = getRawPrivateAndPublicKeyFromSecret(secret);
 	const secondKeypairBytes = getRawPrivateAndPublicKeyFromSecret(secondSecret);
 
-	const signedMessage = naclInstance.crypto_sign(msgBytes, keypairBytes.privateKey);
-	const doubleSignedMessage = naclInstance.crypto_sign(
-		signedMessage, secondKeypairBytes.privateKey,
+	const signature = naclInstance.crypto_sign_detached(msgBytes, keypairBytes.privateKey);
+	const secondSignature = naclInstance.crypto_sign_detached(
+		msgBytes, secondKeypairBytes.privateKey,
 	);
 
-	const hexSignedMessage = bufferToHex(doubleSignedMessage);
-
-	return hexSignedMessage;
+	return {
+		message,
+		publicKey: bufferToHex(keypairBytes.publicKey),
+		secondPublicKey: bufferToHex(secondKeypairBytes.publicKey),
+		signature: Buffer.from(signature).toString('base64'),
+		secondSignature: Buffer.from(secondSignature).toString('base64'),
+	};
 }
 
 /**
  * @method verifyMessageWithPublicKey
- * @param signedMessage
- * @param publicKey
+ * @param {Object} Object - Object
+ * @param {String} Object.message - message in utf8
+ * @param {String} Object.signature - signature in base64
+ * @param {String} Object.publicKey - publicKey in hex
  *
  * @return {string}
  */
 
-export function verifyMessageWithPublicKey(signedMessage, publicKey) {
-	const signedMessageBytes = hexToBuffer(signedMessage);
+export function verifyMessageWithPublicKey({ message, signature, publicKey }) {
+	const msgBytes = Buffer.from(message);
+	const signatureBytes = Buffer.from(signature, 'base64');
 	const publicKeyBytes = hexToBuffer(publicKey);
 
 	if (publicKeyBytes.length !== 32) {
 		throw new Error('Invalid publicKey, expected 32-byte publicKey');
 	}
 
-	const signatureVerified = naclInstance.crypto_sign_open(signedMessageBytes, publicKeyBytes);
-
-	if (signatureVerified) {
-		return naclInstance.decode_utf8(signatureVerified);
+	if (signatureBytes.length !== naclInstance.crypto_sign_BYTES) {
+		throw new Error('Invalid signature length, expected 64-byte signature');
 	}
-	throw new Error('Invalid signature publicKey combination, cannot verify message');
+
+	return naclInstance.crypto_sign_verify_detached(signatureBytes, msgBytes, publicKeyBytes);
 }
 
 /**
@@ -101,10 +108,22 @@ export function verifyMessageWithPublicKey(signedMessage, publicKey) {
  * @return {string}
  */
 
-export function verifyMessageWithTwoPublicKeys(signedMessage, publicKey, secondPublicKey) {
-	const signedMessageBytes = hexToBuffer(signedMessage);
-	const publicKeyBytes = hexToBuffer(publicKey);
-	const secondPublicKeyBytes = hexToBuffer(secondPublicKey);
+export function verifyMessageWithTwoPublicKeys(
+	{ message, signature, secondSignature, publicKey, secondPublicKey },
+) {
+	const messageBytes = Buffer.from(message);
+	const signatureBytes = Buffer.from(signature, 'base64');
+	const secondSignatureBytes = Buffer.from(secondSignature, 'base64');
+	const publicKeyBytes = Buffer.from(hexToBuffer(publicKey));
+	const secondPublicKeyBytes = Buffer.from(hexToBuffer(secondPublicKey));
+
+	if (signatureBytes.length !== naclInstance.crypto_sign_BYTES) {
+		throw new Error('Invalid first signature length, expected 64-byte signature');
+	}
+
+	if (secondSignatureBytes.length !== naclInstance.crypto_sign_BYTES) {
+		throw new Error('Invalid second signature length, expected 64-byte signature');
+	}
 
 	if (publicKeyBytes.length !== 32) {
 		throw new Error('Invalid first publicKey, expected 32-byte publicKey');
@@ -114,22 +133,14 @@ export function verifyMessageWithTwoPublicKeys(signedMessage, publicKey, secondP
 		throw new Error('Invalid second publicKey, expected 32-byte publicKey');
 	}
 
-	const secondSignatureVerified = naclInstance.crypto_sign_open(
-		signedMessageBytes, secondPublicKeyBytes,
+	const verifyFirstSignature = () => naclInstance.crypto_sign_verify_detached(
+		signatureBytes, messageBytes, publicKeyBytes,
 	);
-
-	if (!secondSignatureVerified) {
-		throw new Error('Invalid signature second publicKey, cannot verify message');
-	}
-
-	const firstSignatureVerified = naclInstance.crypto_sign_open(
-		secondSignatureVerified, publicKeyBytes,
+	const verifySecondSignature = () => naclInstance.crypto_sign_verify_detached(
+		secondSignatureBytes, messageBytes, secondPublicKeyBytes,
 	);
 
-	if (!firstSignatureVerified) {
-		throw new Error('Invalid signature first publicKey, cannot verify message');
-	}
-	return naclInstance.decode_utf8(firstSignatureVerified);
+	return verifyFirstSignature() && verifySecondSignature();
 }
 
 /**
@@ -141,7 +152,7 @@ export function verifyMessageWithTwoPublicKeys(signedMessage, publicKey, secondP
  * @return {string}
  */
 
-export function printSignedMessage(message, signedMessage, publicKey) {
+export function printSignedMessage({ message, signature, publicKey }) {
 	const signedMessageHeader = '-----BEGIN LISK SIGNED MESSAGE-----';
 	const messageHeader = '-----MESSAGE-----';
 	const publicKeyHeader = '-----PUBLIC KEY-----';
@@ -155,7 +166,7 @@ export function printSignedMessage(message, signedMessage, publicKey) {
 		publicKeyHeader,
 		publicKey,
 		signatureHeader,
-		signedMessage,
+		signature,
 		signatureFooter,
 	];
 
@@ -171,10 +182,8 @@ export function printSignedMessage(message, signedMessage, publicKey) {
  */
 
 export function signAndPrintMessage(message, secret) {
-	const { publicKey } = getPrivateAndPublicKeyFromSecret(secret);
 	const signedMessage = signMessageWithSecret(message, secret);
-
-	return printSignedMessage(message, signedMessage, publicKey);
+	return printSignedMessage(signedMessage);
 }
 
 /**

test/.eslintrc.json

@@ -3,6 +3,7 @@
 		"mocha": true
 	},
 	"globals": {
+		"sandbox": true,
 		"should": true,
 		"sinon": true
 	},

test/api/liskApi.js

@@ -16,6 +16,8 @@ import LiskAPI from '../../src/api/liskApi';
 import privateApi from '../../src/api/privateApi';
 import utils from '../../src/api/utils';
 
+afterEach(() => sandbox.restore());
+
 describe('Lisk API module', () => {
 	const fixedPoint = 10 ** 8;
 	const testPort = 7000;
@@ -70,36 +72,27 @@ describe('Lisk API module', () => {
 	let LSK;
 
 	beforeEach(() => {
-		selectNodeStub = sinon
+		selectNodeStub = sandbox
 			.stub(privateApi, 'selectNode')
 			.returns(defaultSelectedNode);
-		sendRequestPromiseStub = sinon
+		sendRequestPromiseStub = sandbox
 			.stub(privateApi, 'sendRequestPromise')
 			.resolves(Object.assign({}, defaultRequestPromiseResult));
-		checkOptionsStub = sinon
+		checkOptionsStub = sandbox
 			.stub(utils, 'checkOptions')
 			.returns(Object.assign({}, defaultCheckedOptions));
-		handleTimestampIsInFutureFailuresStub = sinon
+		handleTimestampIsInFutureFailuresStub = sandbox
 			.stub(privateApi, 'handleTimestampIsInFutureFailures')
 			.resolves(Object.assign({}, defaultRequestPromiseResult.body));
-		handleSendRequestFailuresStub = sinon
+		handleSendRequestFailuresStub = sandbox
 			.stub(privateApi, 'handleSendRequestFailures');
-		getFullURLStub = sinon
+		getFullURLStub = sandbox
 			.stub(privateApi, 'getFullURL')
 			.returns(defaultUrl);
 
 		LSK = new LiskAPI();
 	});
 
-	afterEach(() => {
-		selectNodeStub.restore();
-		sendRequestPromiseStub.restore();
-		checkOptionsStub.restore();
-		handleTimestampIsInFutureFailuresStub.restore();
-		handleSendRequestFailuresStub.restore();
-		getFullURLStub.restore();
-	});
-
 	describe('LiskAPI()', () => {
 		it('should create a new instance of LiskAPI', () => {
 			(LSK).should.be.type('object').and.be.instanceof(LiskAPI);
@@ -482,15 +475,10 @@ describe('Lisk API module', () => {
 
 	describe('API methods', () => {
 		let callback;
-		let sendRequestStub;
 
 		beforeEach(() => {
 			callback = () => {};
-			sendRequestStub = sinon.stub(LSK, 'sendRequest');
-		});
-
-		afterEach(() => {
-			sendRequestStub.restore();
+			sandbox.stub(LSK, 'sendRequest');
 		});
 
 		describe('#getAccount', () => {