JAV-19 [Github #259 #260 #241] Various small issues fixed

README.md

@@ -14,7 +14,7 @@ with the NEM2 (a.k.a Catapult)
 
 Due to a network upgrade with [catapult-server@elephant3](https://github.com/nemtech/catapult-server/releases/tag/v0.7.0.1) version, **it is recommended to use this package's 0.13.2 version and upwards to use this package with Elephant versioned networks**.
 
-The upgrade to this package's [version v0.13.1](https://github.com/nemtech/nem2-sdk-typescript-javascript/releases/tag/v0.13.1) is mandatory for **elephant compatibility**.
+The upgrade to this package's [version v0.13.2](https://github.com/nemtech/nem2-sdk-typescript-javascript/releases/tag/v0.13.2) is mandatory for **elephant compatibility**.
 
 ### _Dragon_ Network Compatibility (catapult-server@0.4.0.1)
 

e2e/infrastructure/TransactionHttp.spec.ts

@@ -315,7 +315,7 @@ describe('TransactionHttp', () => {
             listener.confirmed(account.address).subscribe((transaction: NamespaceRegistrationTransaction) => {
                 expect(transaction.namespaceId, 'NamespaceId').not.to.be.undefined;
                 expect(transaction.namespaceName, 'NamespaceName').not.to.be.undefined;
-                expect(transaction.namespaceType, 'NamespaceRegistrationType').not.to.be.undefined;
+                expect(transaction.registrationType, 'RegistrationType').not.to.be.undefined;
                 done();
             });
             listener.status(account.address).subscribe((error) => {

e2e/infrastructure/transaction/ValidateTransaction.ts

@@ -28,7 +28,7 @@ import {UInt64} from '../../../src/model/UInt64';
 const ValidateTransaction = {
     validateStandaloneTx: (transaction, transactionDTO) => {
         deepEqual(transaction.transactionInfo.height,
-            new UInt64(transactionDTO.meta.height));
+            UInt64.fromNumericString(transactionDTO.meta.height));
         expect(transaction.transactionInfo.hash)
             .to.be.equal(transactionDTO.meta.hash);
         expect(transaction.transactionInfo.merkleComponentHash)
@@ -49,8 +49,8 @@ const ValidateTransaction = {
         expect(transaction.type)
             .to.be.equal(transactionDTO.transaction.type);
         deepEqual(transaction.maxFee,
-            new UInt64(transactionDTO.transaction.maxFee));
-        deepEqual(transaction.deadline.toDTO(),
+            UInt64.fromNumericString(transactionDTO.transaction.maxFee));
+        deepEqual(transaction.deadline.toString(),
             transactionDTO.transaction.deadline);
 
         if (transaction.type === TransactionType.TRANSFER) {
@@ -67,7 +67,7 @@ const ValidateTransaction = {
     },
     validateAggregateTx: (aggregateTransaction, aggregateTransactionDTO) => {
         deepEqual(aggregateTransaction.transactionInfo.height,
-            new UInt64(aggregateTransactionDTO.meta.height));
+            UInt64.fromNumericString(aggregateTransactionDTO.meta.height));
         expect(aggregateTransaction.transactionInfo.hash)
             .to.be.equal(aggregateTransactionDTO.meta.hash);
         expect(aggregateTransaction.transactionInfo.merkleComponentHash)
@@ -88,8 +88,8 @@ const ValidateTransaction = {
         expect(aggregateTransaction.type)
             .to.be.equal(aggregateTransactionDTO.transaction.type);
         deepEqual(aggregateTransaction.maxFee,
-            new UInt64(aggregateTransactionDTO.transaction.maxFee));
-        deepEqual(aggregateTransaction.deadline.toDTO(),
+            UInt64.fromNumericString(aggregateTransactionDTO.transaction.maxFee));
+        deepEqual(aggregateTransaction.deadline.toString(),
             aggregateTransactionDTO.transaction.deadline);
 
         ValidateTransaction.validateStandaloneTx(aggregateTransaction.innerTransactions[0],
@@ -98,15 +98,15 @@ const ValidateTransaction = {
     validateMosaicCreationTx: (mosaicDefinitionTransaction, mosaicDefinitionTransactionDTO) => {
 
         deepEqual(mosaicDefinitionTransaction.mosaicId,
-            new MosaicId(mosaicDefinitionTransactionDTO.transaction.mosaicId));
-        expect(mosaicDefinitionTransaction.mosaicProperties.divisibility)
-            .to.be.equal(mosaicDefinitionTransactionDTO.transaction.properties[1].value[0]);
-        deepEqual(mosaicDefinitionTransaction.mosaicProperties.duration,
-            new UInt64(mosaicDefinitionTransactionDTO.transaction.properties[2].value));
+            new MosaicId(mosaicDefinitionTransactionDTO.transaction.id));
+        expect(mosaicDefinitionTransaction.divisibility)
+            .to.be.equal(mosaicDefinitionTransactionDTO.transaction.divisibility);
+        deepEqual(mosaicDefinitionTransaction.duration,
+            UInt64.fromNumericString(mosaicDefinitionTransactionDTO.transaction.duration));
 
-        expect(mosaicDefinitionTransaction.mosaicProperties.supplyMutable)
+        expect(mosaicDefinitionTransaction.flags.supplyMutable)
             .to.be.equal(true);
-        expect(mosaicDefinitionTransaction.mosaicProperties.transferable)
+        expect(mosaicDefinitionTransaction.flags.transferable)
             .to.be.equal(true);
     },
     validateMosaicSupplyChangeTx: (mosaicSupplyChangeTransaction, mosaicSupplyChangeTransactionDTO) => {
@@ -115,7 +115,7 @@ const ValidateTransaction = {
         expect(mosaicSupplyChangeTransaction.direction)
             .to.be.equal(mosaicSupplyChangeTransactionDTO.transaction.direction);
         deepEqual(mosaicSupplyChangeTransaction.delta,
-            new UInt64(mosaicSupplyChangeTransactionDTO.transaction.delta));
+            UInt64.fromNumericString(mosaicSupplyChangeTransactionDTO.transaction.delta));
     },
     validateMultisigModificationTx: (modifyMultisigAccountTransaction, modifyMultisigAccountTransactionDTO) => {
         expect(modifyMultisigAccountTransaction.minApprovalDelta)
@@ -131,16 +131,16 @@ const ValidateTransaction = {
         );
     },
     validateNamespaceCreationTx: (registerNamespaceTransaction, registerNamespaceTransactionDTO) => {
-        expect(registerNamespaceTransaction.namespaceType)
-            .to.be.equal(registerNamespaceTransactionDTO.transaction.namespaceType);
+        expect(registerNamespaceTransaction.registrationType)
+            .to.be.equal(registerNamespaceTransactionDTO.transaction.registrationType);
         expect(registerNamespaceTransaction.namespaceName)
             .to.be.equal(registerNamespaceTransactionDTO.transaction.name);
         deepEqual(registerNamespaceTransaction.namespaceId,
-            NamespaceId.createFromEncoded(registerNamespaceTransactionDTO.transaction.namespaceId));
+            NamespaceId.createFromEncoded(registerNamespaceTransactionDTO.transaction.id));
 
-        if (registerNamespaceTransaction.namespaceType === 0) {
+        if (registerNamespaceTransaction.registrationType === 0) {
             deepEqual(registerNamespaceTransaction.duration,
-                new UInt64(registerNamespaceTransactionDTO.transaction.duration));
+                UInt64.fromNumericString(registerNamespaceTransactionDTO.transaction.duration));
         } else {
             deepEqual(registerNamespaceTransaction.parentId,
                 NamespaceId.createFromEncoded(registerNamespaceTransactionDTO.transaction.parentId));

src/infrastructure/AccountHttp.ts

@@ -32,6 +32,7 @@ import { NamespaceId } from '../model/namespace/NamespaceId';
 import { NamespaceName } from '../model/namespace/NamespaceName';
 import {AggregateTransaction} from '../model/transaction/AggregateTransaction';
 import {Transaction} from '../model/transaction/Transaction';
+import { UInt64 } from '../model/UInt64';
 import {AccountRepository} from './AccountRepository';
 import { AccountInfoDTO,
          AccountNamesDTO,
@@ -45,7 +46,6 @@ import {Http} from './Http';
 import {NetworkHttp} from './NetworkHttp';
 import {QueryParams} from './QueryParams';
 import {CreateTransactionFromDTO} from './transaction/CreateTransactionFromDTO';
-import { UInt64 } from '../model/UInt64';
 
 /**
  * Account http repository.

src/infrastructure/model/models.ts

@@ -92,7 +92,6 @@ export * from './mosaicDefinitionTransactionDTO';
 export * from './mosaicIds';
 export * from './mosaicInfoDTO';
 export * from './mosaicNamesDTO';
-export * from './mosaicPropertiesDTO';
 export * from './mosaicRestrictionTypeEnum';
 export * from './mosaicSupplyChangeActionEnum';
 export * from './mosaicSupplyChangeTransactionBodyDTO';
@@ -239,7 +238,6 @@ import { MosaicDefinitionTransactionDTO } from './mosaicDefinitionTransactionDTO
 import { MosaicIds } from './mosaicIds';
 import { MosaicInfoDTO } from './mosaicInfoDTO';
 import { MosaicNamesDTO } from './mosaicNamesDTO';
-import { MosaicPropertiesDTO } from './mosaicPropertiesDTO';
 import { MosaicRestrictionTypeEnum } from './mosaicRestrictionTypeEnum';
 import { MosaicSupplyChangeActionEnum } from './mosaicSupplyChangeActionEnum';
 import { MosaicSupplyChangeTransactionBodyDTO } from './mosaicSupplyChangeTransactionBodyDTO';
@@ -406,7 +404,6 @@ let typeMap: {[index: string]: any} = {
     "MosaicIds": MosaicIds,
     "MosaicInfoDTO": MosaicInfoDTO,
     "MosaicNamesDTO": MosaicNamesDTO,
-    "MosaicPropertiesDTO": MosaicPropertiesDTO,
     "MosaicSupplyChangeTransactionBodyDTO": MosaicSupplyChangeTransactionBodyDTO,
     "MosaicSupplyChangeTransactionDTO": MosaicSupplyChangeTransactionDTO,
     "MosaicsNamesDTO": MosaicsNamesDTO,

src/infrastructure/model/mosaicDTO.ts

@@ -25,8 +25,6 @@
  * Do not edit the class manually.
  */
 
-import { MosaicPropertiesDTO } from './mosaicPropertiesDTO';
-
 export class MosaicDTO {
     /**
     * Mosaic identifier.

src/infrastructure/transaction/SerializeTransactionToJSON.ts

@@ -130,7 +130,7 @@ export const SerializeTransactionToJSON = (transaction: Transaction): any => {
             const registerNamespaceParentId = (transaction as NamespaceRegistrationTransaction).parentId;
 
             const jsonObject = {
-                namespaceType: (transaction as NamespaceRegistrationTransaction).namespaceType,
+                registrationType: (transaction as NamespaceRegistrationTransaction).registrationType,
                 namespaceName: (transaction as NamespaceRegistrationTransaction).namespaceName,
                 id: (transaction as NamespaceRegistrationTransaction).namespaceId.toHex(),
             };

src/model/transaction/MosaicAddressRestrictionTransaction.ts

@@ -85,9 +85,12 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
      * @param version
      * @param deadline
      * @param maxFee
-     * @param mosaicNonce
      * @param mosaicId
-     * @param mosaicProperties
+     * @param signature
+     * @param restrictionKey
+     * @param targetAddress
+     * @param previousRestrictionValue
+     * @param newRestrictionValue
      * @param signature
      * @param signer
      * @param transactionInfo

src/model/transaction/MosaicDefinitionTransaction.ts

@@ -81,9 +81,11 @@ export class MosaicDefinitionTransaction extends Transaction {
      * @param version
      * @param deadline
      * @param maxFee
-     * @param mosaicNonce
+     * @param nonce
      * @param mosaicId
-     * @param mosaicProperties
+     * @param flags
+     * @param divisibility
+     * @param duration
      * @param signature
      * @param signer
      * @param transactionInfo

src/model/transaction/MosaicGlobalRestrictionTransaction.ts

@@ -89,16 +89,20 @@ export class MosaicGlobalRestrictionTransaction extends Transaction {
     }
 
     /**
-     * @param networkType
-     * @param version
-     * @param deadline
-     * @param maxFee
-     * @param mosaicNonce
-     * @param mosaicId
-     * @param mosaicProperties
-     * @param signature
-     * @param signer
-     * @param transactionInfo
+     * @param networkType - The network type
+     * @param version - The transaction version
+     * @param deadline - The deadline to include the transaction.
+     * @param maxFee - (Optional) Max fee defined by the sender
+     * @param mosaicId - The mosaic id ex: new MosaicId([481110499, 231112638]).
+     * @param referenceMosaicId - The mosaic id providing the restriction key.
+     * @param restrictionKey - The restriction key.
+     * @param previousRestrictionValue - The previous restriction value.
+     * @param previousRestrictionType - The previous restriction type.
+     * @param newRestrictionValue - The new restriction value.
+     * @param previousRestrictionType - The previous restriction tpye.
+     * @param signature - The transaction signature
+     * @param signer - The signer
+     * @param transactionInfo - The transaction info
      */
     constructor(networkType: NetworkType,
                 version: number,

src/model/transaction/NamespaceRegistrationTransaction.ts

@@ -108,7 +108,7 @@ export class NamespaceRegistrationTransaction extends Transaction {
      * @param version
      * @param deadline
      * @param maxFee
-     * @param namespaceType
+     * @param registrationType
      * @param namespaceName
      * @param namespaceId
      * @param duration
@@ -124,7 +124,7 @@ export class NamespaceRegistrationTransaction extends Transaction {
                 /**
                  * The namespace type could be namespace or sub namespace
                  */
-                public readonly namespaceType: NamespaceRegistrationType,
+                public readonly registrationType: NamespaceRegistrationType,
                 /**
                  * The namespace name
                  */
@@ -158,10 +158,10 @@ export class NamespaceRegistrationTransaction extends Transaction {
                                     isEmbedded: boolean = false): Transaction | InnerTransaction {
         const builder = isEmbedded ? EmbeddedNamespaceRegistrationTransactionBuilder.loadFromBinary(Convert.hexToUint8(payload)) :
             NamespaceRegistrationTransactionBuilder.loadFromBinary(Convert.hexToUint8(payload));
-        const namespaceType = builder.getRegistrationType().valueOf();
+        const registrationType = builder.getRegistrationType().valueOf();
         const signerPublicKey = Convert.uint8ToHex(builder.getSignerPublicKey().key);
         const networkType = Convert.hexToUint8(builder.getVersion().toString(16))[0];
-        const transaction = namespaceType === NamespaceRegistrationType.RootNamespace ?
+        const transaction = registrationType === NamespaceRegistrationType.RootNamespace ?
             NamespaceRegistrationTransaction.createRootNamespace(
                 isEmbedded ? Deadline.create() : Deadline.createFromDTO(
                     (builder as NamespaceRegistrationTransactionBuilder).getDeadline().timestamp),
@@ -210,7 +210,7 @@ export class NamespaceRegistrationTransaction extends Transaction {
         const signerBuffer = new Uint8Array(32);
         const signatureBuffer = new Uint8Array(64);
         let transactionBuilder: NamespaceRegistrationTransactionBuilder;
-        if (this.namespaceType === NamespaceRegistrationType.RootNamespace) {
+        if (this.registrationType === NamespaceRegistrationType.RootNamespace) {
             transactionBuilder = new NamespaceRegistrationTransactionBuilder(
                 new SignatureDto(signatureBuffer),
                 new KeyDto(signerBuffer),
@@ -246,7 +246,7 @@ export class NamespaceRegistrationTransaction extends Transaction {
      */
     protected generateEmbeddedBytes(): Uint8Array {
         let transactionBuilder: EmbeddedNamespaceRegistrationTransactionBuilder;
-        if (this.namespaceType === NamespaceRegistrationType.RootNamespace) {
+        if (this.registrationType === NamespaceRegistrationType.RootNamespace) {
             transactionBuilder = new EmbeddedNamespaceRegistrationTransactionBuilder(
                 new KeyDto(Convert.hexToUint8(this.signer!.publicKey)),
                 this.versionToDTO(),

src/model/wallet/EncryptedPrivateKey.ts

@@ -23,7 +23,6 @@ import { WalletAlgorithm } from './WalletAlgorithm';
  */
 export class EncryptedPrivateKey {
     /**
-     * @internal
      * @param encryptedKey
      * @param iv
      */
@@ -40,15 +39,14 @@ export class EncryptedPrivateKey {
     }
 
     /**
-     * @internal
      * Decrypt an encrypted private key
      * @param password
      */
-    decrypt(password: Password): string {
+    public decrypt(password: Password): string {
         const common = {
             password: password.value,
             privateKey: '',
-        }
+        };
         const wallet = {
             encrypted: this.encryptedKey,
             iv: this.iv,

src/model/wallet/SimpleWallet.ts

@@ -30,7 +30,6 @@ import {Wallet} from './Wallet';
 export class SimpleWallet extends Wallet {
 
     /**
-     * @internal
      * @param name
      * @param network
      * @param address

test/core/utils/TransactionMapping.spec.ts

@@ -509,7 +509,7 @@ describe('TransactionMapping - createFromPayload', () => {
 
         const transaction = TransactionMapping.createFromPayload(signedTransaction.payload) as NamespaceRegistrationTransaction;
 
-        expect(transaction.namespaceType).to.be.equal(NamespaceRegistrationType.RootNamespace);
+        expect(transaction.registrationType).to.be.equal(NamespaceRegistrationType.RootNamespace);
         expect(transaction.namespaceName).to.be.equal('root-test-namespace');
 
     });
@@ -526,7 +526,7 @@ describe('TransactionMapping - createFromPayload', () => {
 
         const transaction = TransactionMapping.createFromPayload(signedTransaction.payload) as NamespaceRegistrationTransaction;
 
-        expect(transaction.namespaceType).to.be.equal(NamespaceRegistrationType.SubNamespace);
+        expect(transaction.registrationType).to.be.equal(NamespaceRegistrationType.SubNamespace);
         expect(transaction.namespaceName).to.be.equal('root-test-namespace');
     });
 

test/model/mosaic/Mosaic.spec.ts

@@ -16,8 +16,8 @@
 
 import {deepEqual} from 'assert';
 import {Mosaic} from '../../../src/model/mosaic/Mosaic';
-import {UInt64} from '../../../src/model/UInt64';
 import {MosaicId} from '../../../src/model/mosaic/MosaicId';
+import {UInt64} from '../../../src/model/UInt64';
 
 describe('Mosaic', () => {
 

test/model/mosaic/MosaicFlags.spec.ts

@@ -22,14 +22,7 @@ import {UInt64} from '../../../src/model/UInt64';
 describe('MosaicFlags', () => {
 
     it('should createComplete an MosaicFlags object with constructor', () => {
-        const propertiesDTO = {
-            flags: 7,
-            divisibility: 3,
-            duration: '1000',
-        };
-
         const mosaicFlags = new MosaicFlags(7);
-
         expect(mosaicFlags.supplyMutable).to.be.equal(true);
         expect(mosaicFlags.transferable).to.be.equal(true);
         expect(mosaicFlags.restrictable).to.be.equal(true);