Merge remote-tracking branch 'origin/master' into catbuffer-library

# Conflicts:
#	package.json
#	src/model/transaction/TransactionStatus.ts

Author: fboucquez

CHANGELOG.md

@@ -3,6 +3,32 @@ All notable changes to this project will be documented in this file.
 
 The changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## 09-Jan-2020
+
+**Milestone**: Fushicho.3
+ Versions  |   |
+---|---|---
+SDK Core| v0.16.3 | https://www.npmjs.com/package/nem2-sdk
+Catbuffer Library| v0.0.7 | https://www.npmjs.com/package/catbuffer
+Client Library | v0.7.20-beta.6  | https://www.npmjs.com/package/nem2-sdk-openapi-typescript-node-client
+
+- Fixed http client (OpenAPI client package) does not support ES6 issue.
+
+## 06-Jan-2020
+
+**Milestone**: Fushicho.3
+ Versions  |   |
+---|---|---
+SDK Core| v0.16.2 | https://www.npmjs.com/package/nem2-sdk
+Catbuffer Library| v0.0.7 | https://www.npmjs.com/package/catbuffer
+Client Library | v0.7.20-alpha.6  | https://www.npmjs.com/package/nem2-sdk-openapi-typescript-node-client
+
+- Refactored to replace generated codes by public library package for both `Catbuffer` and `OpenAPI Http Client`.
+- Added unresolved (mosaicId, address) support in `MosaicRestrictionTransaction`.
+- Added `toHex()` in `MosaicNonce` class.
+- Exposed `MultisigAccountGraphInfo` class constructor to public.
+- Fixed `transaction status` issue in both `Http` and `Websocket` due to schema update.
+
 ## [0.16.1] - 23-Dec-2019
 
 **Milestone**: Fushicho.3
@@ -302,6 +328,8 @@ The changelog format is based on [Keep a Changelog](https://keepachangelog.com/e
 **Milestone**: Alpaca
 
 - Initial code release.
+[0.16.3]: https://github.com/nemtech/nem2-sdk-typescript-javascript/compare/v0.16.2...v0.16.3
+[0.16.2]: https://github.com/nemtech/nem2-sdk-typescript-javascript/compare/v0.16.1...v0.16.2
 [0.16.1]: https://github.com/nemtech/nem2-sdk-typescript-javascript/compare/v0.16.0...v0.16.1
 [0.16.0]: https://github.com/nemtech/nem2-sdk-typescript-javascript/compare/v0.15.1...v0.16.0
 [0.15.1]: https://github.com/nemtech/nem2-sdk-typescript-javascript/compare/v0.15.0...v0.15.1

README.md

@@ -12,9 +12,9 @@ with the NEM2 (a.k.a Catapult)
 
 ### _Fushicho_ Network Compatibility (catapult-server@0.9.1.1)
 
-Due to a network upgrade with [catapult-server@Fushicho](https://github.com/nemtech/catapult-server/releases/tag/v0.9.1.1) version, **it is recommended to use this package's 0.16.1 version and upwards to use this package with Fushicho versioned networks**.
+Due to a network upgrade with [catapult-server@Fushicho](https://github.com/nemtech/catapult-server/releases/tag/v0.9.1.1) version, **it is recommended to use this package's 0.16.3 version and upwards to use this package with Fushicho versioned networks**.
 
-The upgrade to this package's [version v0.16.0](https://github.com/nemtech/nem2-sdk-typescript-javascript/releases/tag/v0.16.0) is mandatory for **fushicho compatibility**.
+The upgrade to this package's [version v0.16.3](https://github.com/nemtech/nem2-sdk-typescript-javascript/releases/tag/v0.16.3) is mandatory for **fushicho compatibility**.
 
 ### _Elephant_ Network Compatibility (catapult-server@0.7.0.1)
 

e2e/infrastructure/AccountHttp.spec.ts

@@ -18,6 +18,7 @@ import { assert, expect } from 'chai';
 import { AccountRepository } from '../../src/infrastructure/AccountRepository';
 import { MultisigRepository } from '../../src/infrastructure/MultisigRepository';
 import { NamespaceRepository } from '../../src/infrastructure/NamespaceRepository';
+import { QueryParams } from '../../src/infrastructure/QueryParams';
 import { Account } from '../../src/model/account/Account';
 import { Address } from '../../src/model/account/Address';
 import { PublicAccount } from '../../src/model/account/PublicAccount';
@@ -31,6 +32,7 @@ import { AggregateTransaction } from '../../src/model/transaction/AggregateTrans
 import { Deadline } from '../../src/model/transaction/Deadline';
 import { MultisigAccountModificationTransaction } from '../../src/model/transaction/MultisigAccountModificationTransaction';
 import { NamespaceRegistrationTransaction } from '../../src/model/transaction/NamespaceRegistrationTransaction';
+import { TransactionType } from '../../src/model/transaction/TransactionType';
 import { TransferTransaction } from '../../src/model/transaction/TransferTransaction';
 import { UInt64 } from '../../src/model/UInt64';
 import { IntegrationTestHelper } from './IntegrationTestHelper';
@@ -225,6 +227,30 @@ describe('AccountHttp', () => {
         });
     });
 
+    describe('transactions', () => {
+        it('should not return accounts when account does not exist', () => {
+            return accountRepository.getAccountInfo(Account.generateNewAccount(networkType).address).toPromise().then(r => {
+                return Promise.reject('should fail!');
+            }, err => {
+                const error = JSON.parse(err.message);
+                expect(error.statusCode).to.be.eq(404);
+                expect(error.errorDetails.statusMessage).to.be.eq('Not Found');
+                return Promise.resolve();
+            });
+        });
+    });
+
+    describe('transactions', () => {
+        it('should call transactions successfully by type', async () => {
+            const transactions = await accountRepository.getAccountTransactions(publicAccount.address, {transactionType: TransactionType.TRANSFER} as QueryParams).toPromise();
+
+            expect(transactions.length).to.be.greaterThan(0);
+            transactions.forEach(t => {
+                expect(t.type).to.be.eq(TransactionType.TRANSFER);
+            });
+        });
+    });
+
     describe('transactions', () => {
         it('should call transactions successfully', (done) => {
             accountRepository.getAccountTransactions(publicAccount.address).subscribe((transactions) => {

e2e/infrastructure/BlockHttp.spec.ts

@@ -80,7 +80,7 @@ describe('BlockHttp', () => {
             const signedTransaction = transferTransaction.signWith(account, generationHash);
             helper.announce(signedTransaction).then((transaction) => {
                 chainHeight = transaction.transactionInfo!.height.toString();
-                return transaction;
+                done();
             });
         });
     });

e2e/infrastructure/IntegrationTestHelper.ts

@@ -77,8 +77,7 @@ export class IntegrationTestHelper {
                                 '../../../catapult-service-bootstrap/build/generated-addresses/addresses.yaml'),
                                     (error: any, yamlData: any) => {
                             if (error) {
-                                console.log(`catapult-service-bootstrap generated address could not be loaded.
-                                    Ignoring and using accounts from network.conf. Error: ${error}`);
+                                console.log(`catapult-service-bootstrap generated address could not be loaded. Ignoring and using accounts from network.conf.`);
                                 return resolve(this);
                             } else {
                                 const parsedYaml = this.yaml.safeLoad(yamlData);

e2e/infrastructure/Listener.spec.ts

@@ -369,7 +369,7 @@ describe('Listener', () => {
             return helper.announce(transferTransaction.signWith(account, generationHash)).then(() => {
                 throw new Error('Transaction should have failed!!');
             }, (error) => {
-                expect(error.status).to.be.equal('Failure_Core_Insufficient_Balance');
+                expect(error.code).to.be.equal('Failure_Core_Insufficient_Balance');
             });
         });
     });

e2e/service/MosaicRestrictionTransactionService.spec.ts

@@ -1,17 +1,23 @@
 import { expect } from 'chai';
 import { KeyGenerator } from '../../src/core/format/KeyGenerator';
+import { NamespaceRepository } from '../../src/infrastructure/NamespaceRepository';
 import { RestrictionMosaicRepository } from '../../src/infrastructure/RestrictionMosaicRepository';
 import { Account } from '../../src/model/account/Account';
 import { NetworkType } from '../../src/model/blockchain/NetworkType';
 import { MosaicFlags } from '../../src/model/mosaic/MosaicFlags';
 import { MosaicId } from '../../src/model/mosaic/MosaicId';
 import { MosaicNonce } from '../../src/model/mosaic/MosaicNonce';
+import { AliasAction } from '../../src/model/namespace/AliasAction';
+import { NamespaceId } from '../../src/model/namespace/NamespaceId';
 import { MosaicRestrictionType } from '../../src/model/restriction/MosaicRestrictionType';
+import { AddressAliasTransaction } from '../../src/model/transaction/AddressAliasTransaction';
 import { AggregateTransaction } from '../../src/model/transaction/AggregateTransaction';
 import { Deadline } from '../../src/model/transaction/Deadline';
 import { MosaicAddressRestrictionTransaction } from '../../src/model/transaction/MosaicAddressRestrictionTransaction';
+import { MosaicAliasTransaction } from '../../src/model/transaction/MosaicAliasTransaction';
 import { MosaicDefinitionTransaction } from '../../src/model/transaction/MosaicDefinitionTransaction';
 import { MosaicGlobalRestrictionTransaction } from '../../src/model/transaction/MosaicGlobalRestrictionTransaction';
+import { NamespaceRegistrationTransaction } from '../../src/model/transaction/NamespaceRegistrationTransaction';
 import { TransactionType } from '../../src/model/transaction/TransactionType';
 import { UInt64 } from '../../src/model/UInt64';
 import { MosaicRestrictionTransactionService } from '../../src/service/MosaicRestrictionTransactionService';
@@ -22,17 +28,21 @@ describe('MosaicRestrictionTransactionService', () => {
     const key = KeyGenerator.generateUInt64Key('TestKey');
     let account: Account;
     let restrictionRepository: RestrictionMosaicRepository;
+    let namespaceRepository: NamespaceRepository;
     let mosaicId: MosaicId;
     let generationHash: string;
     const helper = new IntegrationTestHelper();
     let networkType: NetworkType;
+    let namespaceIdAddress: NamespaceId;
+    let namespaceIdMosaic: NamespaceId;
 
     before(() => {
         return helper.start().then(() => {
             account = helper.account;
             generationHash = helper.generationHash;
             networkType = helper.networkType;
             restrictionRepository = helper.repositoryFactory.createRestrictionMosaicRepository();
+            namespaceRepository = helper.repositoryFactory.createNamespaceRepository();
         });
     });
 
@@ -64,6 +74,7 @@ describe('MosaicRestrictionTransactionService', () => {
                 UInt64.fromUint(1000),
                 networkType, helper.maxFee,
             );
+            console.log(mosaicId.toHex());
             const signedTransaction = mosaicDefinitionTransaction.signWith(account, generationHash);
             return helper.announce(signedTransaction);
         });
@@ -99,6 +110,7 @@ describe('MosaicRestrictionTransactionService', () => {
                 account.address,
                 UInt64.fromUint(2),
                 networkType,
+                undefined,
                 helper.maxFee,
             );
             const aggregateTransaction = AggregateTransaction.createComplete(Deadline.create(),
@@ -111,14 +123,80 @@ describe('MosaicRestrictionTransactionService', () => {
         });
     });
 
+    describe('NamespaceRegistrationTransaction', () => {
+
+        it('standalone', () => {
+            const namespaceName = 'root-test-namespace-' + Math.floor(Math.random() * 10000);
+            const registerNamespaceTransaction = NamespaceRegistrationTransaction.createRootNamespace(
+                Deadline.create(),
+                namespaceName,
+                UInt64.fromUint(50),
+                networkType, helper.maxFee,
+            );
+            namespaceIdMosaic = new NamespaceId(namespaceName);
+            const signedTransaction = registerNamespaceTransaction.signWith(account, generationHash);
+
+            return helper.announce(signedTransaction);
+        });
+    });
+
+    describe('NamespaceRegistrationTransaction', () => {
+
+        it('standalone', () => {
+            const namespaceName = 'root-test-namespace-' + Math.floor(Math.random() * 10000);
+            const registerNamespaceTransaction = NamespaceRegistrationTransaction.createRootNamespace(
+                Deadline.create(),
+                namespaceName,
+                UInt64.fromUint(50),
+                networkType, helper.maxFee,
+            );
+            namespaceIdAddress = new NamespaceId(namespaceName);
+            const signedTransaction = registerNamespaceTransaction.signWith(account, generationHash);
+
+            return helper.announce(signedTransaction);
+        });
+    });
+
+    describe('AddressAliasTransaction', () => {
+
+        it('standalone', () => {
+            const addressAliasTransaction = AddressAliasTransaction.create(
+                Deadline.create(),
+                AliasAction.Link,
+                namespaceIdAddress,
+                account.address,
+                networkType, helper.maxFee,
+            );
+            const signedTransaction = addressAliasTransaction.signWith(account, generationHash);
+
+            return helper.announce(signedTransaction);
+        });
+    });
+
+    describe('MosaicAliasTransaction', () => {
+
+        it('standalone', () => {
+            const mosaicAliasTransaction = MosaicAliasTransaction.create(
+                Deadline.create(),
+                AliasAction.Link,
+                namespaceIdMosaic,
+                mosaicId,
+                networkType, helper.maxFee,
+            );
+            const signedTransaction = mosaicAliasTransaction.signWith(account, generationHash);
+
+            return helper.announce(signedTransaction);
+        });
+    });
+
     /**
      * =========================
      * Test
      * =========================
      */
-    describe('Test new services', () => {
+    describe('Test new services - MosaicGlobalRestriction', () => {
         it('should create MosaicGlobalRestrictionTransaction', (done) => {
-            const service = new MosaicRestrictionTransactionService(restrictionRepository);
+            const service = new MosaicRestrictionTransactionService(restrictionRepository, namespaceRepository);
 
             return service.createMosaicGlobalRestrictionTransaction(
                 deadline,
@@ -137,9 +215,33 @@ describe('MosaicRestrictionTransactionService', () => {
                 done();
             });
         });
-        it('should create MosaicAddressRestrictionTransaction', (done) => {
-            const service = new MosaicRestrictionTransactionService(restrictionRepository);
+    });
+
+    describe('Test new services - MosaicGlobalRestriction', () => {
+        it('should create MosaicGlobalRestrictionTransaction using alias', (done) => {
+            const service = new MosaicRestrictionTransactionService(restrictionRepository, namespaceRepository);
+            return service.createMosaicGlobalRestrictionTransaction(
+                deadline,
+                networkType,
+                namespaceIdMosaic,
+                key,
+                '2',
+                MosaicRestrictionType.GE, undefined, helper.maxFee,
+            ).subscribe((transaction: MosaicGlobalRestrictionTransaction) => {
+                expect(transaction.type).to.be.equal(TransactionType.MOSAIC_GLOBAL_RESTRICTION);
+                expect(transaction.previousRestrictionValue.toString()).to.be.equal('1');
+                expect(transaction.previousRestrictionType).to.be.equal(MosaicRestrictionType.GE);
+                expect(transaction.newRestrictionValue.toString()).to.be.equal('2');
+                expect(transaction.newRestrictionType).to.be.equal(MosaicRestrictionType.GE);
+                expect(transaction.restrictionKey.toHex()).to.be.equal(key.toHex());
+                done();
+            });
+        });
+    });
 
+    describe('Test new services - MosaicAddressRestriction', () => {
+        it('should create MosaicAddressRestrictionTransaction', (done) => {
+            const service = new MosaicRestrictionTransactionService(restrictionRepository, namespaceRepository);
             return service.createMosaicAddressRestrictionTransaction(
                 deadline,
                 networkType,
@@ -159,10 +261,33 @@ describe('MosaicRestrictionTransactionService', () => {
         });
     });
 
+    describe('Test new services - MosaicAddressRestriction', () => {
+        it('should create MosaicAddressRestrictionTransaction with address alias', (done) => {
+            const service = new MosaicRestrictionTransactionService(restrictionRepository, namespaceRepository);
+
+            return service.createMosaicAddressRestrictionTransaction(
+                deadline,
+                networkType,
+                mosaicId,
+                key,
+                namespaceIdAddress,
+                '4',
+                helper.maxFee,
+            ).subscribe((transaction: MosaicAddressRestrictionTransaction) => {
+                expect(transaction.type).to.be.equal(TransactionType.MOSAIC_ADDRESS_RESTRICTION);
+                expect(transaction.previousRestrictionValue.toString()).to.be.equal('3');
+                expect(transaction.newRestrictionValue.toString()).to.be.equal('4');
+                expect(transaction.targetAddressToString()).to.be.equal(account.address.plain());
+                expect(transaction.restrictionKey.toHex()).to.be.equal(key.toHex());
+                done();
+            });
+        });
+    });
+
     describe('Announce MosaicGlobalRestriction through service', () => {
 
         it('should create MosaicGlobalRestriction and announce', (done) => {
-            const service = new MosaicRestrictionTransactionService(restrictionRepository);
+            const service = new MosaicRestrictionTransactionService(restrictionRepository, namespaceRepository);
             service.createMosaicGlobalRestrictionTransaction(
                 deadline,
                 networkType,
@@ -188,7 +313,7 @@ describe('MosaicRestrictionTransactionService', () => {
     describe('Announce MosaicAddressRestriction through service', () => {
 
         it('should create MosaicAddressRestriction and announce', (done) => {
-            const service = new MosaicRestrictionTransactionService(restrictionRepository);
+            const service = new MosaicRestrictionTransactionService(restrictionRepository, namespaceRepository);
 
             return service.createMosaicAddressRestrictionTransaction(
                 deadline,