Merge pull request #255 from rg911/task/g226_mosaic_property_refactoring

JAV-2 [Github #226] MosaicDefinition refactoring

Author: rg911

e2e/infrastructure/MosaicHttp.spec.ts

@@ -18,9 +18,9 @@ import { Listener, TransactionHttp } from '../../src/infrastructure/infrastructu
 import {MosaicHttp} from '../../src/infrastructure/MosaicHttp';
 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 { MosaicProperties } from '../../src/model/mosaic/MosaicProperties';
 import { AliasAction } from '../../src/model/namespace/AliasAction';
 import {NamespaceId} from '../../src/model/namespace/NamespaceId';
 import { Deadline } from '../../src/model/transaction/Deadline';
@@ -74,12 +74,9 @@ describe('MosaicHttp', () => {
                 Deadline.create(),
                 nonce,
                 mosaicId,
-                MosaicProperties.create({
-                    supplyMutable: true,
-                    transferable: true,
-                    divisibility: 3,
-                    duration: UInt64.fromUint(0),
-                }),
+                MosaicFlags.create(true, true, false),
+                3,
+                UInt64.fromUint(0),
                 NetworkType.MIJIN_TEST,
             );
             const signedTransaction = mosaicDefinitionTransaction.signWith(account, generationHash);

e2e/infrastructure/TransactionHttp.spec.ts

@@ -29,9 +29,9 @@ import { AccountRestrictionModificationAction } from '../../src/model/account/Ac
 import { AccountRestrictionType } from '../../src/model/account/AccountRestrictionType';
 import {NetworkType} from '../../src/model/blockchain/NetworkType';
 import { Mosaic } from '../../src/model/mosaic/Mosaic';
+import {MosaicFlags} from '../../src/model/mosaic/MosaicFlags';
 import {MosaicId} from '../../src/model/mosaic/MosaicId';
 import {MosaicNonce} from '../../src/model/mosaic/MosaicNonce';
-import {MosaicProperties} from '../../src/model/mosaic/MosaicProperties';
 import { MosaicRestrictionType } from '../../src/model/mosaic/MosaicRestrictionType';
 import {MosaicSupplyChangeAction} from '../../src/model/mosaic/MosaicSupplyChangeAction';
 import {NetworkCurrencyMosaic} from '../../src/model/mosaic/NetworkCurrencyMosaic';
@@ -143,23 +143,20 @@ describe('TransactionHttp', () => {
                 Deadline.create(),
                 nonce,
                 mosaicId,
-                MosaicProperties.create({
-                    supplyMutable: true,
-                    transferable: true,
-                    divisibility: 3,
-                    restrictable: true,
-                    duration: UInt64.fromUint(1000),
-                }),
+                MosaicFlags.create( true, true, true),
+                3,
+                UInt64.fromUint(1000),
                 NetworkType.MIJIN_TEST,
             );
             const signedTransaction = mosaicDefinitionTransaction.signWith(account, generationHash);
             listener.confirmed(account.address).subscribe((transaction: MosaicDefinitionTransaction) => {
                 expect(transaction.mosaicId, 'MosaicId').not.to.be.undefined;
                 expect(transaction.nonce, 'Nonce').not.to.be.undefined;
-                expect(transaction.mosaicProperties.divisibility, 'Divisibility').not.to.be.undefined;
-                expect(transaction.mosaicProperties.duration, 'Duration').not.to.be.undefined;
-                expect(transaction.mosaicProperties.supplyMutable, 'SupplyMutable').not.to.be.undefined;
-                expect(transaction.mosaicProperties.transferable, 'Transferable').not.to.be.undefined;
+                expect(transaction.divisibility, 'Divisibility').not.to.be.undefined;
+                expect(transaction.duration, 'Duration').not.to.be.undefined;
+                expect(transaction.flags.supplyMutable, 'SupplyMutable').not.to.be.undefined;
+                expect(transaction.flags.transferable, 'Transferable').not.to.be.undefined;
+                expect(transaction.flags.restrictable, 'Restrictable').not.to.be.undefined;
                 done();
             });
             listener.status(account.address).subscribe((error) => {
@@ -186,13 +183,9 @@ describe('TransactionHttp', () => {
                 Deadline.create(),
                 nonce,
                 MosaicId.createFromNonce(nonce, account.publicAccount),
-                MosaicProperties.create({
-                    supplyMutable: true,
-                    transferable: true,
-                    divisibility: 3,
-                    duration: UInt64.fromUint(0),
-                    restrictable: true,
-                }),
+                MosaicFlags.create( true, true, true),
+                3,
+                UInt64.fromUint(0),
                 NetworkType.MIJIN_TEST,
             );
             const aggregateTransaction = AggregateTransaction.createComplete(Deadline.create(),

src/infrastructure/MosaicHttp.ts

@@ -18,10 +18,10 @@ import { ClientResponse } from 'http';
 import {from as observableFrom, Observable, throwError} from 'rxjs';
 import {catchError, map, mergeMap} from 'rxjs/operators';
 import {PublicAccount} from '../model/account/PublicAccount';
+import {MosaicFlags} from '../model/mosaic/MosaicFlags';
 import {MosaicId} from '../model/mosaic/MosaicId';
 import {MosaicInfo} from '../model/mosaic/MosaicInfo';
 import { MosaicNames } from '../model/mosaic/MosaicNames';
-import {MosaicProperties} from '../model/mosaic/MosaicProperties';
 import {NamespaceId} from '../model/namespace/NamespaceId';
 import { NamespaceName } from '../model/namespace/NamespaceName';
 import {UInt64} from '../model/UInt64';
@@ -64,29 +64,15 @@ export class MosaicHttp extends Http implements MosaicRepository {
                 this.mosaicRoutesApi.getMosaic(mosaicId.toHex())).pipe(
                     map((response: { response: ClientResponse; body: MosaicInfoDTO; } ) => {
                         const mosaicInfoDTO = response.body;
-                        let mosaicFlag;
-                        let divisibility;
-                        let duration;
-                        if (mosaicInfoDTO.mosaic.flags) {
-                            mosaicFlag = mosaicInfoDTO.mosaic.flags;
-                        }
-                        if (mosaicInfoDTO.mosaic.divisibility) {
-                            divisibility = mosaicInfoDTO.mosaic.divisibility;
-                        }
-                        if (mosaicInfoDTO.mosaic.duration) {
-                            duration = mosaicInfoDTO.mosaic.duration;
-                        }
                         return new MosaicInfo(
                             new MosaicId(mosaicInfoDTO.mosaic.id),
                             UInt64.fromNumericString(mosaicInfoDTO.mosaic.supply),
                             UInt64.fromNumericString(mosaicInfoDTO.mosaic.startHeight),
                             PublicAccount.createFromPublicKey(mosaicInfoDTO.mosaic.ownerPublicKey, networkType),
                             mosaicInfoDTO.mosaic.revision,
-                            new MosaicProperties(
-                                mosaicFlag,
-                                divisibility,
-                                UInt64.fromNumericString(duration),
-                            ),
+                            new MosaicFlags(mosaicInfoDTO.mosaic.flags),
+                            mosaicInfoDTO.mosaic.divisibility,
+                            UInt64.fromNumericString(mosaicInfoDTO.mosaic.duration),
                     );
                 }),
                 catchError((error) =>  throwError(this.errorHandling(error))),
@@ -109,29 +95,15 @@ export class MosaicHttp extends Http implements MosaicRepository {
                     map((response: { response: ClientResponse; body: MosaicInfoDTO[]; }) => {
                         const mosaicInfosDTO = response.body;
                         return mosaicInfosDTO.map((mosaicInfoDTO) => {
-                            let mosaicFlag;
-                            let divisibility;
-                            let duration;
-                            if (mosaicInfoDTO.mosaic.flags) {
-                                mosaicFlag = mosaicInfoDTO.mosaic.flags;
-                            }
-                            if (mosaicInfoDTO.mosaic.divisibility) {
-                                divisibility = mosaicInfoDTO.mosaic.divisibility;
-                            }
-                            if (mosaicInfoDTO.mosaic.duration) {
-                                duration = mosaicInfoDTO.mosaic.duration;
-                            }
                             return new MosaicInfo(
                                 new MosaicId(mosaicInfoDTO.mosaic.id),
                                 UInt64.fromNumericString(mosaicInfoDTO.mosaic.supply),
                                 UInt64.fromNumericString(mosaicInfoDTO.mosaic.startHeight),
                                 PublicAccount.createFromPublicKey(mosaicInfoDTO.mosaic.ownerPublicKey, networkType),
                                 mosaicInfoDTO.mosaic.revision,
-                                new MosaicProperties(
-                                    mosaicFlag,
-                                    divisibility,
-                                    UInt64.fromNumericString(duration),
-                                ),
+                                new MosaicFlags(mosaicInfoDTO.mosaic.flags),
+                                mosaicInfoDTO.mosaic.divisibility,
+                                UInt64.fromNumericString(mosaicInfoDTO.mosaic.duration),
                             );
                         });
                     }),

src/infrastructure/transaction/CreateTransactionFromDTO.ts

@@ -20,8 +20,8 @@ import {PublicAccount} from '../../model/account/PublicAccount';
 import {NetworkType} from '../../model/blockchain/NetworkType';
 import {Id} from '../../model/Id';
 import {Mosaic} from '../../model/mosaic/Mosaic';
+import {MosaicFlags} from '../../model/mosaic/MosaicFlags';
 import {MosaicId} from '../../model/mosaic/MosaicId';
-import {MosaicProperties} from '../../model/mosaic/MosaicProperties';
 import {NamespaceId} from '../../model/namespace/NamespaceId';
 import {AccountAddressRestrictionTransaction} from '../../model/transaction/AccountAddressRestrictionTransaction';
 import { AccountLinkTransaction } from '../../model/transaction/AccountLinkTransaction';
@@ -163,11 +163,9 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             UInt64.fromNumericString(transactionDTO.maxFee || '0'),
             transactionDTO.nonce,
             new MosaicId(transactionDTO.id),
-            new MosaicProperties(
-                transactionDTO.flags,
-                transactionDTO.divisibility,
-                UInt64.fromNumericString(transactionDTO.duration),
-            ),
+            new MosaicFlags(transactionDTO.flags),
+            transactionDTO.divisibility,
+            UInt64.fromNumericString(transactionDTO.duration),
             transactionDTO.signature,
             transactionDTO.signerPublicKey ? PublicAccount.createFromPublicKey(transactionDTO.signerPublicKey,
                             extractNetworkType(transactionDTO.version)) : undefined,

src/infrastructure/transaction/SerializeTransactionToJSON.ts

@@ -112,13 +112,12 @@ export const SerializeTransactionToJSON = (transaction: Transaction): any => {
                 mosaicId: (transaction as MosaicAliasTransaction).mosaicId.toHex(),
             };
         case TransactionType.MOSAIC_DEFINITION:
-            const properties = (transaction as MosaicDefinitionTransaction).mosaicProperties.toDTO();
             return {
                 nonce: (transaction as MosaicDefinitionTransaction).nonce,
                 mosaicId: (transaction as MosaicDefinitionTransaction).mosaicId.toHex(),
-                flags: properties.flags,
-                divisibility: properties.divisibility,
-                duration: properties.duration,
+                flags: (transaction as MosaicDefinitionTransaction).flags.getValue(),
+                divisibility: (transaction as MosaicDefinitionTransaction).divisibility,
+                duration: (transaction as MosaicDefinitionTransaction).duration.toString(),
             };
         case TransactionType.MOSAIC_SUPPLY_CHANGE:
             return {

src/model/model.ts

@@ -50,7 +50,7 @@ export * from './mosaic/MosaicInfo';
 export * from './mosaic/MosaicId';
 export * from './mosaic/MosaicNonce';
 export * from './mosaic/MosaicSupplyChangeAction';
-export * from './mosaic/MosaicProperties';
+export * from './mosaic/MosaicFlags';
 export * from '../service/MosaicView';
 export * from '../service/MosaicAmountView';
 export * from './mosaic/NetworkCurrencyMosaic';

src/model/mosaic/MosaicFlag.ts

@@ -14,12 +14,10 @@
  * limitations under the License.
  */
 
-import {UInt64} from '../UInt64';
-
 /**
- * Mosaic properties model
+ * Mosaic flags model
  */
-export class MosaicProperties {
+export class MosaicFlags {
 
     /**
      * The creator can choose between a definition that allows a mosaic supply change at a later point or an immutable supply.
@@ -47,22 +45,7 @@ export class MosaicProperties {
      * @param divisibility
      * @param duration
      */
-    constructor(flags: number,
-                /**
-                 * The divisibility determines up to what decimal place the mosaic can be divided into.
-                 * Thus a divisibility of 3 means that a mosaic can be divided into smallest parts of 0.001 mosaics
-                 * i.e. milli mosaics is the smallest sub-unit.
-                 * When transferring mosaics via a transfer transaction the quantity transferred
-                 * is given in multiples of those smallest parts.
-                 * The divisibility must be in the range of 0 and 6. The default value is "0".
-                 */
-                public readonly divisibility: number,
-                /**
-                 * The duration in blocks a mosaic will be available.
-                 * After the duration finishes mosaic is inactive and can be renewed.
-                 * Duration is optional when defining the mosaic
-                 */
-                public readonly duration: UInt64) {
+    constructor(flags: number) {
         let binaryFlags = '00' + (flags >>> 0).toString(2);
         binaryFlags = binaryFlags.substr(binaryFlags.length - 3, 3);
         this.supplyMutable = binaryFlags[2] === '1';
@@ -72,29 +55,33 @@ export class MosaicProperties {
 
     /**
      * Static constructor function with default parameters
-     * @returns {MosaicProperties}
-     * @param params
+     * @returns {MosaicFlags}
+     * @param supplyMutable
+     * @param transferable
+     * @param restrictable
      */
-    public static create(params: {
+    public static create(
         supplyMutable: boolean,
         transferable: boolean,
-        divisibility: number,
-        duration: UInt64,
-        restrictable?: boolean,
-    }) {
-        const restrictable = params.restrictable ? 4 : 0;
-        const flags = (params.supplyMutable ? 1 : 0) + (params.transferable ? 2 : 0) + restrictable;
-        return new MosaicProperties(flags, params.divisibility, params.duration);
+        restrictable: boolean = false ): MosaicFlags {
+        const flags = (supplyMutable ? 1 : 0) + (transferable ? 2 : 0) + (restrictable ? 4 : 0);
+        return new MosaicFlags(flags);
+    }
+
+    /**
+     * Get mosaic flag value in number
+     * @returns {number}
+     */
+    public getValue(): number {
+        return (this.supplyMutable ? 1 : 0) + (this.transferable ? 2 : 0) + (this.restrictable ? 4 : 0);
     }
 
     /**
      * Create DTO object
      */
     toDTO() {
         return {
-            flags: (this.supplyMutable ? 1 : 0) + (this.transferable ? 2 : 0) + (this.transferable ? 4 : 0),
-            divisibility: this.divisibility,
-            duration: this.duration ? this.duration.toString() : '0',
+            flags: this.getValue(),
         };
     }
 }