Merge branch 'master' into task/g41-add-alias-for-HashLockTransaction

Grégory Saive · web-flow · commit f06e4730f1ae · 2019-02-21T17:56:44.000+01:00
diff --git a/.travis.yml b/.travis.yml
@@ -8,4 +8,17 @@ cache:
     - "node_modules"
 before_script:
   - npm run build
-script: npm run test:coveralls
+script: 
+  - npm run test:coveralls
+before_deploy:
+  - npm install --global typedoc
+  - typedoc --out ts-docs src
+deploy:
+  provider: pages
+  skip_cleanup: true
+  keep-history: true
+  local_dir: ts-docs
+  github_token: $GITHUB_TOKEN
+  on:
+    branch: master
+  
diff --git a/README.md b/README.md
@@ -16,6 +16,10 @@ with the NEM2 (a.k.a Catapult)
 - NodeJS 9.X.X
 - NodeJS 10.X.X
 
+## Installation
+
+```npm install nem2-sdk rxjs```
+
 ## Documentation and Getting Started
 
 Get started and learn more about nem2-sdk-typescript-javascript, check the [official documentation][docs].
@@ -47,4 +51,4 @@ Licensed under the [Apache License 2.0](LICENSE)
 [self]: https://github.com/nemtech/nem2-sdk-typescript-javascript
 [docs]: http://nemtech.github.io/getting-started/setup-workstation.html
 [issues]: https://github.com/nemtech/nem2-sdk-typescript-javascript/issues
-[sdk-ref]: http://nemtech.github.io/nem2-sdk-typescript-javascript
+[sdk-ref]: http://nemtech.github.io/nem2-sdk-typescript-javascript
diff --git a/e2e/infrastructure/TransactionHttp.spec.ts b/e2e/infrastructure/TransactionHttp.spec.ts
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -50,6 +50,8 @@
     "typescript-require": "^0.2.9-1"
   },
   "dependencies": {
+    "@types/crypto-js": "^3.1.43",
+    "crypto-js": "^3.1.9-1",
     "js-joda": "^1.6.2",
     "nem2-library": "^0.9.5",
     "request": "^2.83.0",
diff --git a/src/infrastructure/Listener.ts b/src/infrastructure/Listener.ts
@@ -104,6 +104,7 @@ export class Listener {
                 this.webSocket.onerror = (err) => {
                     console.log('WebSocket Error ');
                     console.log(err);
+                    reject(err);
                 };
                 this.webSocket.onmessage = (msg) => {
                     const message = JSON.parse(msg.data as string);
@@ -155,6 +156,17 @@ export class Listener {
         });
     }
 
+  /**
+     * returns a boolean that repressents the open state
+     * @returns a boolean
+     */
+    public isOpen(): boolean {
+        if(this.webSocket){
+            return this.webSocket.readyState === WebSocket.OPEN;
+        }
+        return false;
+    }
+    
     /**
      * Close web socket connection.
      * @returns void
@@ -189,7 +201,7 @@ export class Listener {
             share(),
             filter((_) => _.channelName === ListenerChannelName.block),
             filter((_) => _.message instanceof BlockInfo),
-            map((_) => _.message as BlockInfo),);
+            map((_) => _.message as BlockInfo));
     }
 
     /**
@@ -206,7 +218,7 @@ export class Listener {
             filter((_) => _.channelName === ListenerChannelName.confirmedAdded),
             filter((_) => _.message instanceof Transaction),
             map((_) => _.message as Transaction),
-            filter((_) => this.transactionFromAddress(_, address)),);
+            filter((_) => this.transactionFromAddress(_, address)));
     }
 
     /**
@@ -223,7 +235,7 @@ export class Listener {
             filter((_) => _.channelName === ListenerChannelName.unconfirmedAdded),
             filter((_) => _.message instanceof Transaction),
             map((_) => _.message as Transaction),
-            filter((_) => this.transactionFromAddress(_, address)),);
+            filter((_) => this.transactionFromAddress(_, address)));
     }
 
     /**
@@ -239,7 +251,7 @@ export class Listener {
         return this.messageSubject.asObservable().pipe(
             filter((_) => _.channelName === ListenerChannelName.unconfirmedRemoved),
             filter((_) => typeof _.message === 'string'),
-            map((_) => _.message as string),);
+            map((_) => _.message as string));
     }
 
     /**
@@ -256,7 +268,7 @@ export class Listener {
             filter((_) => _.channelName === ListenerChannelName.aggregateBondedAdded),
             filter((_) => _.message instanceof AggregateTransaction),
             map((_) => _.message as AggregateTransaction),
-            filter((_) => this.transactionFromAddress(_, address)),);
+            filter((_) => this.transactionFromAddress(_, address)));
     }
 
     /**
@@ -272,7 +284,7 @@ export class Listener {
         return this.messageSubject.asObservable().pipe(
             filter((_) => _.channelName === ListenerChannelName.aggregateBondedRemoved),
             filter((_) => typeof _.message === 'string'),
-            map((_) => _.message as string),);
+            map((_) => _.message as string));
     }
 
     /**
@@ -288,7 +300,7 @@ export class Listener {
         return this.messageSubject.asObservable().pipe(
             filter((_) => _.channelName === ListenerChannelName.status),
             filter((_) => _.message instanceof TransactionStatusError),
-            map((_) => _.message as TransactionStatusError),);
+            map((_) => _.message as TransactionStatusError));
     }
 
     /**
@@ -304,7 +316,7 @@ export class Listener {
         return this.messageSubject.asObservable().pipe(
             filter((_) => _.channelName === ListenerChannelName.cosignature),
             filter((_) => _.message instanceof CosignatureSignedTransaction),
-            map((_) => _.message as CosignatureSignedTransaction),);
+            map((_) => _.message as CosignatureSignedTransaction));
     }
 
     /**
@@ -320,6 +332,18 @@ export class Listener {
         this.webSocket.send(JSON.stringify(subscriptionMessage));
     }
 
+    /**
+     * @internal
+     * @param channel - Channel to unsubscribe
+     */
+    private unsubscribeTo(channel: string) {
+        const unsubscribeMessage = {
+            uid: this.uid,
+            unsubscribe: channel,
+        };
+        this.webSocket.send(JSON.stringify(unsubscribeMessage));
+    }
+
     /**
      * @internal
      * Filters if a transaction has been initiated or signed by an address
diff --git a/src/model/UInt64.ts b/src/model/UInt64.ts
@@ -37,6 +37,9 @@ export class UInt64 {
      * @returns {UInt64}
      */
     public static fromUint(value: number): UInt64 {
+        if (value < 0) {
+            throw new Error('Unsigned integer cannot be negative');
+        }
         return new UInt64(uint64.fromUint(value));
     }
 
diff --git a/src/model/mosaic/Mosaic.ts b/src/model/mosaic/Mosaic.ts
@@ -41,7 +41,6 @@ export class Mosaic {
 
     }
 
-
     /**
      * @internal
      * @returns {{amount: number[], id: number[]}}
diff --git a/src/model/mosaic/MosaicProperties.ts b/src/model/mosaic/MosaicProperties.ts
@@ -60,7 +60,7 @@ export class MosaicProperties {
                  * The duration in blocks a mosaic will be available.
                  * After the duration finishes mosaic is inactive and can be renewed.
                  */
-                public readonly duration: UInt64,) {
+                public readonly duration: UInt64) {
         let binaryFlags = '00' + (flags.lower >>> 0).toString(2);
         binaryFlags = binaryFlags.substr(binaryFlags.length - 3, 3);
         this.supplyMutable = binaryFlags[2] === '1';
diff --git a/src/model/transaction/HashType.ts b/src/model/transaction/HashType.ts
@@ -16,17 +16,32 @@
 
 /**
  * Hash type. Supported types are:
- * 0: SHA3_512.
+ * 0: Op_Sha3_256 (default).
+ * 1: Op_Keccak_256 (ETH compatibility).
+ * 2: Op_Hash_160 (first with SHA-256 and then with RIPEMD-160 (BTC compatibility))
+ * 3: Op_Hash_256: input is hashed twice with SHA-256 (BTC compatibility)
  */
 import {convert} from 'nem2-library';
 
 export enum HashType {
-    SHA3_512 = 0,
+    Op_Sha3_256 = 0,
+    Op_Keccak_256 = 1,
+    Op_Hash_160 = 2,
+    Op_Hash_256 = 3,
 }
 
 export function HashTypeLengthValidator(hashType: HashType, input: string): boolean {
-    if (hashType === HashType.SHA3_512 && convert.isHexString(input)) {
-        return input.length === 128;
+    if (convert.isHexString(input)) {
+        switch (hashType) {
+            case HashType.Op_Sha3_256:
+            case HashType.Op_Hash_256:
+            case HashType.Op_Keccak_256:
+                return input.length === 64;
+            case HashType.Op_Hash_160:
+                return input.length === 40;
+            default:
+                break;
+        }
     }
     return false;
 }
diff --git a/src/model/transaction/Transaction.ts b/src/model/transaction/Transaction.ts
@@ -158,12 +158,12 @@ export abstract class Transaction {
     }
 
     /**
-     * @description re-aplly a given value to the transaction in an immutable way
+     * @description reapply a given value to the transaction in an immutable way
      * @param {Deadline} deadline
      * @returns {Transaction}
      * @memberof Transaction
      */
-    public replyGiven(deadline: Deadline = Deadline.create()): Transaction {
+    public reapplyGiven(deadline: Deadline = Deadline.create()): Transaction {
         if (this.isUnannounced()) {
             return Object.assign({__proto__: Object.getPrototypeOf(this)}, this, {deadline});
         }
diff --git a/test/infrastructure/Listener.spec.ts b/test/infrastructure/Listener.spec.ts
@@ -23,4 +23,25 @@ describe('Listener', () => {
         expect('ws://localhost:3000/ws').to.be.equal(listener.url);
         listener.close();
     });
+
+    describe('isOpen', () => {
+        it('should return false when listener is created and not opened', () => {
+            const listener = new Listener('ws://localhost:3000');
+            expect(listener.isOpen()).to.be.false;
+            listener.close();
+        });
+    });
+
+    describe('onerror', () => {
+        it('should reject because of wrong server url', async () => {
+            const listener = new Listener('https://notcorrecturl:0000');
+            await listener.open()
+                .then((result) => {
+                    throw new Error('This should not be called when expecting error');
+                })
+                .catch((error) => {
+                    expect(error.toString()).to.be.equal("Error: getaddrinfo ENOTFOUND notcorrecturl notcorrecturl:0000");
+                })
+        });
+    });
 });
diff --git a/test/model/UInt64.spec.ts b/test/model/UInt64.spec.ts
@@ -64,6 +64,12 @@ describe('Uint64', () => {
         expect(uint64Compact).to.be.equal(51110867862);
     });
 
+    it('should fromUnit throw exception with negative unit value', () => {
+        expect(() => {
+            UInt64.fromUint(-1);
+        }).to.throw(Error, 'Unsigned integer cannot be negative');
+    });
+
     describe('equal', () => {
         it('should return true if the inside values are the same', () => {
             const value = new UInt64([12, 12]);
diff --git a/test/model/transaction/HashTypeLengthValidator.spec.ts b/test/model/transaction/HashTypeLengthValidator.spec.ts
@@ -14,21 +14,66 @@
  * limitations under the License.
  */
 import {expect} from 'chai';
-import {sha3_256, sha3_512} from 'js-sha3';
+import * as CryptoJS from 'crypto-js';
+import {keccak_256, sha3_256, sha3_512} from 'js-sha3';
 import {HashType, HashTypeLengthValidator} from '../../../src/model/transaction/HashType';
 
 describe('HashTypeLengthValidator', () => {
-    it('HashType.SHA3_512 should be exactly 128 chars length', () => {
-        expect(HashTypeLengthValidator(HashType.SHA3_512, sha3_512.create().update('abcxyz').hex())).to.be.equal(true);
+    it('HashType.SHA3_256 should be exactly 64 chars length', () => {
+        expect(HashTypeLengthValidator(HashType.Op_Sha3_256, sha3_256.create().update('abcxyz').hex())).to.be.equal(true);
     });
 
-    it('HashType.SHA3_512 should return false if it is not 128 chars length', () => {
-        expect(HashTypeLengthValidator(HashType.SHA3_512, sha3_256.create().update('abcxyz').hex())).to.be.equal(false);
+    it('HashType.SHA3_256 should return false if it is not 64 chars length', () => {
+        expect(HashTypeLengthValidator(HashType.Op_Sha3_256, sha3_512.create().update('abcxyz').hex())).to.be.equal(false);
     });
 
-    it('HashType.SHA_512 should return false if it is not a hash valid', () => {
+    it('HashType.SHA_256 should return false if it is not a hash valid', () => {
         const invalidHash = 'zyz6053bb910a6027f138ac5ebe92d43a9a18b7239b3c4d5ea69f1632e50aeef28184e46cd22ded096b76631858' +
             '0a569e74521a9d63885cc8d5e8644793be928';
-        expect(HashTypeLengthValidator(HashType.SHA3_512, invalidHash)).to.be.equal(false);
+        expect(HashTypeLengthValidator(HashType.Op_Sha3_256, invalidHash)).to.be.equal(false);
+    });
+
+    it('HashType.Keccak_256 should be exactly 64 chars length', () => {
+        expect(HashTypeLengthValidator(HashType.Op_Keccak_256, keccak_256.create().update('abcxyz').hex())).to.be.equal(true);
+    });
+
+    it('HashType.Keccak_256 should return false if it is not 64 chars length', () => {
+        expect(HashTypeLengthValidator(HashType.Op_Keccak_256, sha3_512.create().update('abcxyz').toString())).to.be.equal(false);
+    });
+
+    it('HashType.Keccak_256 should return false if it is not a hash valid', () => {
+        const invalidHash = 'zyz6053bb910a6027f138ac5ebe92d43a9a18b7239b3c4d5ea69f1632e50aeef28184e46cd22ded096b76631858' +
+            '0a569e74521a9d63885cc8d5e8644793be928';
+        expect(HashTypeLengthValidator(HashType.Op_Keccak_256, invalidHash)).to.be.equal(false);
+    });
+
+    it('HashType.Op_Hash_256 should be exactly 64 chars length', () => {
+        // tslint:disable-next-line:max-line-length
+        expect(HashTypeLengthValidator(HashType.Op_Hash_256, CryptoJS.SHA256(CryptoJS.SHA256('abcxyz').toString(CryptoJS.enc.Hex)).toString(CryptoJS.enc.Hex))).to.be.equal(true);
+    });
+
+    it('HashType.Op_Hash_256 should return false if it is not 64 chars length', () => {
+        expect(HashTypeLengthValidator(HashType.Op_Hash_256, sha3_512.create().update('abcxyz').toString())).to.be.equal(false);
+    });
+
+    it('HashType.Op_Hash_256 should return false if it is not a hash valid', () => {
+        const invalidHash = 'zyz6053bb910a6027f138ac5ebe92d43a9a18b7239b3c4d5ea69f1632e50aeef28184e46cd22ded096b76631858' +
+            '0a569e74521a9d63885cc8d5e8644793be928';
+        expect(HashTypeLengthValidator(HashType.Op_Hash_256, invalidHash)).to.be.equal(false);
+    });
+
+    it('HashType.Op_Hash_160 should be exactly 40 chars length', () => {
+        // tslint:disable-next-line:max-line-length
+        expect(HashTypeLengthValidator(HashType.Op_Hash_160, CryptoJS.RIPEMD160(CryptoJS.SHA256('abcxyz').toString(CryptoJS.enc.Hex)).toString(CryptoJS.enc.Hex))).to.be.equal(true);
+    });
+
+    it('HashType.Op_Hash_160 should return false if it is not 64 chars length', () => {
+        expect(HashTypeLengthValidator(HashType.Op_Hash_160, sha3_512.create().update('abcxyz').toString())).to.be.equal(false);
+    });
+
+    it('HashType.Op_Hash_160 should return false if it is not a hash valid', () => {
+        const invalidHash = 'zyz6053bb910a6027f138ac5ebe92d43a9a18b7239b3c4d5ea69f1632e50aeef28184e46cd22ded096b76631858' +
+            '0a569e74521a9d63885cc8d5e8644793be928';
+        expect(HashTypeLengthValidator(HashType.Op_Hash_160, invalidHash)).to.be.equal(false);
     });
 });
diff --git a/test/model/transaction/SecretLockTransaction.spec.ts b/test/model/transaction/SecretLockTransaction.spec.ts
diff --git a/test/model/transaction/SecretProofTransaction.spec.ts b/test/model/transaction/SecretProofTransaction.spec.ts
diff --git a/test/model/transaction/Transaction.spec.ts b/test/model/transaction/Transaction.spec.ts
diff --git a/tslint.json b/tslint.json

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,9 @@ export class UInt64 {`
`37`	`37`	`* @returns {UInt64}`
`38`	`38`	`*/`
`39`	`39`	`public static fromUint(value: number): UInt64 {`
	`40`	`+ if (value < 0) {`
	`41`	`+ throw new Error('Unsigned integer cannot be negative');`
	`42`	`+ }`
`40`	`43`	`return new UInt64(uint64.fromUint(value));`
`41`	`44`	`}`
`42`	`45`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,6 @@ export class Mosaic {`
`41`	`41`
`42`	`42`	`}`
`43`	`43`
`44`		`-`
`45`	`44`	`/**`
`46`	`45`	`* @internal`
`47`	`46`	`* @returns {{amount: number[], id: number[]}}`