Merge pull request #467 from NEMStudios/task/g466_mosaic_nonce_uint32

Changed mosaicNonce to uint32 in dto

Author: rg911

src/infrastructure/transaction/CreateTransactionFromDTO.ts

@@ -25,6 +25,7 @@ import {EmptyMessage, PlainMessage} from '../../model/message/PlainMessage';
 import {Mosaic} from '../../model/mosaic/Mosaic';
 import {MosaicFlags} from '../../model/mosaic/MosaicFlags';
 import {MosaicId} from '../../model/mosaic/MosaicId';
+import { MosaicNonce } from '../../model/mosaic/MosaicNonce';
 import {NamespaceId} from '../../model/namespace/NamespaceId';
 import {AccountAddressRestrictionTransaction} from '../../model/transaction/AccountAddressRestrictionTransaction';
 import { AccountLinkTransaction } from '../../model/transaction/AccountLinkTransaction';
@@ -54,6 +55,7 @@ import {TransactionInfo} from '../../model/transaction/TransactionInfo';
 import {TransactionType} from '../../model/transaction/TransactionType';
 import {TransferTransaction} from '../../model/transaction/TransferTransaction';
 import {UInt64} from '../../model/UInt64';
+
 // tslint:disable: no-use-before-declare
 /**
  * @internal
@@ -159,7 +161,7 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             transactionDTO.version,
             Deadline.createFromDTO(transactionDTO.deadline),
             UInt64.fromNumericString(transactionDTO.maxFee || '0'),
-            transactionDTO.nonce,
+            MosaicNonce.createFromHex(transactionDTO.nonce.toString(16)),
             new MosaicId(transactionDTO.id),
             new MosaicFlags(transactionDTO.flags),
             transactionDTO.divisibility,

src/infrastructure/transaction/NamespaceMosaicIdGenerator.ts

@@ -19,9 +19,11 @@ import { IdGenerator } from '../../core/format';
 
 export class NamespaceMosaicIdGenerator {
     /**
+     * @param {Uint8Array} nonce Mosaic nonce
+     * @param {Uint8Array} ownerPublicId Public key
      * @returns mosaic Id
      */
-    public static mosaicId = (nonce, ownerPublicId) => {
+    public static mosaicId = (nonce: Uint8Array, ownerPublicId: Uint8Array) => {
         return IdGenerator.generateMosaicId(nonce, ownerPublicId);
     }
 
@@ -36,7 +38,7 @@ export class NamespaceMosaicIdGenerator {
      * @param {string} namespaceName - The namespace name
      * @returns sub namespace id
      */
-    public static namespaceId = (namespaceName) => {
+    public static namespaceId = (namespaceName: string) => {
         const path = IdGenerator.generateNamespacePath(namespaceName);
         return path.length ? IdGenerator.generateNamespacePath(namespaceName)[path.length - 1] : [];
     }
@@ -55,7 +57,7 @@ export class NamespaceMosaicIdGenerator {
      * @param {string} namespaceName - The namespace name
      * @returns sub namespace id
      */
-    public static subnamespaceNamespaceId = (parentNamespaceName, namespaceName) => {
+    public static subnamespaceNamespaceId = (parentNamespaceName: string, namespaceName: string) => {
         const path = IdGenerator.generateNamespacePath(`${parentNamespaceName}.${namespaceName}`);
         return path[path.length - 1];
     }

src/infrastructure/transaction/SerializeTransactionToJSON.ts

@@ -139,7 +139,7 @@ export const SerializeTransactionToJSON = (transaction: Transaction): any => {
         case TransactionType.MOSAIC_DEFINITION:
             const mosaicDefinitionTx = transaction as MosaicDefinitionTransaction;
             return {
-                nonce: mosaicDefinitionTx.nonce,
+                nonce: mosaicDefinitionTx.nonce.toDTO(),
                 id: mosaicDefinitionTx.mosaicId.toHex(),
                 flags: mosaicDefinitionTx.flags.getValue(),
                 divisibility: mosaicDefinitionTx.divisibility,

src/model/mosaic/MosaicInfo.ts

@@ -25,13 +25,14 @@ import { MosaicId } from './MosaicId';
 export class MosaicInfo {
 
     /**
-     * @param active
-     * @param index
-     * @param nonce
+     * @param id
      * @param supply
      * @param height
      * @param owner
-     * @param properties
+     * @param revision
+     * @param flags
+     * @param divisibility
+     * @param duration
      */
     constructor(
                 /**

src/model/mosaic/MosaicNonce.ts

@@ -71,8 +71,8 @@ export class MosaicNonce {
      * @internal
      * @returns {[number,number,number,number]}
      */
-    public toDTO(): Uint8Array {
-        return this.nonce;
+    public toDTO(): number {
+        return (this.nonce[0] + (this.nonce[1] << 8) + (this.nonce[2] << 16) + (this.nonce[3] << 24)) >>> 0;
     }
 
     /**

src/model/transaction/MosaicDefinitionTransaction.ts

@@ -178,7 +178,7 @@ export class MosaicDefinitionTransaction extends Transaction {
      * @memberof MosaicDefinitionTransaction
      */
     public getMosaicNonceIntValue(): number {
-        return GeneratorUtils.readUint32At(this.nonce.toDTO(), 0);
+        return this.nonce.toDTO();
     }
 
     /**

test/infrastructure/transaction/CreateTransactionFromDTO.spec.ts

@@ -347,7 +347,7 @@ describe('CreateTransactionFromDTO', () => {
                     deadline: '1',
                     maxFee: '0',
                     id: '85BBEA6CC462B244',
-                    nonce: '1',
+                    nonce: 1177824765,
                     flags: 7,
                     diversibility: 6,
                     duration: '1000',
@@ -398,7 +398,7 @@ describe('CreateTransactionFromDTO', () => {
                             },
                             transaction: {
                                 id: '85BBEA6CC462B244',
-                                nonce: '1',
+                                nonce: 1177824765,
                                 flags: 7,
                                 divisibility: 6,
                                 duration: '1000',

test/model/mosaic/MosaicNonce.spec.ts

@@ -24,7 +24,7 @@ describe('MosaicNonce', () => {
     it('should be created from Uint8Array', () => {
         const nonce = new MosaicNonce(new Uint8Array([0x0, 0x0, 0x0, 0x0]));
         deepEqual(nonce.nonce, new Uint8Array([0x0, 0x0, 0x0, 0x0]));
-        deepEqual(nonce.toDTO(), new Uint8Array([0x0, 0x0, 0x0, 0x0]));
+        deepEqual(nonce.toDTO(), 0);
     });
 
     it('should create random nonce', () => {
@@ -44,6 +44,7 @@ describe('MosaicNonce', () => {
         const nonce = MosaicNonce.createFromHex('00000000');
         expect(nonce.nonce).to.not.be.null;
         deepEqual(nonce.nonce, new Uint8Array([0x0, 0x0, 0x0, 0x0]));
+        deepEqual(nonce.toDTO(), 0);
     });
 
     describe('toHex()', () => {