Merge pull request #111 from rg911/task/g109_optional_duration_for_mosaic_transaction

Grégory Saive · web-flow · commit 6afb2f1f4f54 · 2019-04-10T18:22:32.000+02:00
Task/g109 optional duration for mosaic transaction
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -53,7 +53,7 @@
     "@types/crypto-js": "^3.1.43",
     "crypto-js": "^3.1.9-1",
     "js-joda": "^1.6.2",
-    "nem2-library": "^0.9.13",
+    "nem2-library": "^0.9.14",
     "request": "^2.83.0",
     "request-promise-native": "^1.0.5",
     "rxjs": "^6.2.1",
diff --git a/src/infrastructure/transaction/CreateTransactionFromDTO.ts b/src/infrastructure/transaction/CreateTransactionFromDTO.ts
@@ -158,7 +158,7 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             new MosaicProperties(
                 new UInt64(transactionDTO.properties[0].value),
                 (new UInt64(transactionDTO.properties[1].value)).compact(),
-                new UInt64(transactionDTO.properties.length === 3 ? transactionDTO.properties[2].value : [0, 0]),
+                new UInt64(transactionDTO.properties.length === 3 ? transactionDTO.properties[2].value : undefined),
             ),
             transactionDTO.signature,
             transactionDTO.signer ? PublicAccount.createFromPublicKey(transactionDTO.signer,
diff --git a/src/infrastructure/transaction/CreateTransactionFromPayload.ts b/src/infrastructure/transaction/CreateTransactionFromPayload.ts
@@ -224,7 +224,7 @@ const CreateTransaction = (type: number, transactionData: string, networkType: N
                     transferable: (flags & 2) === 2,
                     levyMutable: (flags & 4) === 4,
                     divisibility: parseInt(convert.uint8ToHex(convert.hexToUint8(divisibility).reverse()), 16),
-                    duration: UInt64.fromHex(reverse(duration)),
+                    duration: duration ? UInt64.fromHex(reverse(duration)) : undefined,
                 }),
                 networkType,
             );
diff --git a/src/model/mosaic/MosaicInfo.ts b/src/model/mosaic/MosaicInfo.ts
@@ -81,7 +81,7 @@ export class MosaicInfo {
      * Mosaic duration
      * @returns {UInt64}
      */
-    public get duration(): UInt64 {
+    public get duration(): UInt64 | undefined {
         return this.properties.duration;
     }
 
diff --git a/src/model/mosaic/MosaicProperties.ts b/src/model/mosaic/MosaicProperties.ts
@@ -59,8 +59,9 @@ export class MosaicProperties {
                 /**
                  * 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) {
+                public readonly duration?: UInt64) {
         let binaryFlags = '00' + (flags.lower >>> 0).toString(2);
         binaryFlags = binaryFlags.substr(binaryFlags.length - 3, 3);
         this.supplyMutable = binaryFlags[2] === '1';
@@ -78,7 +79,7 @@ export class MosaicProperties {
         transferable: boolean,
         levyMutable: boolean,
         divisibility: number,
-        duration: UInt64,
+        duration?: UInt64,
     }) {
         const flags = (params.supplyMutable ? 1 : 0) + (params.transferable ? 2 : 0) + (params.levyMutable ? 4 : 0);
         return new MosaicProperties(UInt64.fromUint(flags), params.divisibility, params.duration);
@@ -88,12 +89,17 @@ export class MosaicProperties {
      * Create DTO object
      */
     toDTO() {
-        return [
+        const dto = [
             {id: 0, value: UInt64.fromUint((this.supplyMutable ? 1 : 0) +
-                                           (this.transferable ? 2 : 0) +
-                                           (this.levyMutable ? 4 : 0)).toDTO()},
+                                        (this.transferable ? 2 : 0) +
+                                        (this.levyMutable ? 4 : 0)).toDTO()},
             {id: 1, value: UInt64.fromUint(this.divisibility).toDTO()},
-            {id: 2, value: this.duration.toDTO()},
         ];
+
+        if (this.duration !== undefined) {
+            dto.push({id: 2, value: this.duration.toDTO()});
+        }
+
+        return dto;
     }
 }
diff --git a/src/model/transaction/EncryptedMessage.ts b/src/model/transaction/EncryptedMessage.ts
@@ -28,8 +28,8 @@ export class EncryptedMessage extends Message {
     public readonly recipientPublicAccount?: PublicAccount;
 
     constructor(payload: string,
-                recipientPublicAccount?: PublicAccount){
-        super(MessageType.EncryptedMessage,payload);
+                recipientPublicAccount?: PublicAccount) {
+        super(MessageType.EncryptedMessage, payload);
         this.recipientPublicAccount = recipientPublicAccount;
     }
 
@@ -40,7 +40,9 @@ export class EncryptedMessage extends Message {
      * @param privateKey
      */
     public static create(message: string, recipientPublicAccount: PublicAccount, privateKey) {
-        return new EncryptedMessage(crypto.encode(privateKey, recipientPublicAccount.publicKey, message), recipientPublicAccount);
+        return new EncryptedMessage(
+            crypto.encode(privateKey, recipientPublicAccount.publicKey, message).toUpperCase(),
+            recipientPublicAccount);
     }
 
     /**
diff --git a/src/model/transaction/MosaicDefinitionTransaction.ts b/src/model/transaction/MosaicDefinitionTransaction.ts
@@ -128,7 +128,7 @@ export class MosaicDefinitionTransaction extends Transaction {
             .addFee(this.maxFee.toDTO())
             .addVersion(this.versionToDTO())
             .addDivisibility(this.mosaicProperties.divisibility)
-            .addDuration(this.mosaicProperties.duration.toDTO())
+            .addDuration(this.mosaicProperties.duration ? this.mosaicProperties.duration.toDTO() : [])
             .addNonce(this.nonce.toDTO())
             .addMosaicId(this.mosaicId.id.toDTO());
 
diff --git a/test/core/utils/TransactionMapping.spec.ts b/test/core/utils/TransactionMapping.spec.ts
@@ -192,8 +192,108 @@ describe('TransactionMapping - createFromPayload', () => {
 
         const transaction = TransactionMapping.createFromPayload(signedTransaction.payload) as MosaicDefinitionTransaction;
 
-        expect(transaction.mosaicProperties.duration.lower).to.be.equal(1000);
-        expect(transaction.mosaicProperties.duration.higher).to.be.equal(0);
+        expect(transaction.mosaicProperties.duration!.lower).to.be.equal(1000);
+        expect(transaction.mosaicProperties.duration!.higher).to.be.equal(0);
+        expect(transaction.mosaicProperties.divisibility).to.be.equal(3);
+        expect(transaction.mosaicProperties.supplyMutable).to.be.equal(false);
+        expect(transaction.mosaicProperties.transferable).to.be.equal(false);
+        expect(transaction.mosaicProperties.levyMutable).to.be.equal(false);
+
+    });
+
+    it('should create MosaicDefinitionTransaction - without duration', () => {
+        const mosaicDefinitionTransaction = MosaicDefinitionTransaction.create(
+            Deadline.create(),
+            new MosaicNonce(new Uint8Array([0xE6, 0xDE, 0x84, 0xB8])), // nonce
+            new MosaicId(UInt64.fromUint(1).toDTO()), // ID
+            MosaicProperties.create({
+                supplyMutable: false,
+                transferable: false,
+                levyMutable: false,
+                divisibility: 3,
+            }),
+            NetworkType.MIJIN_TEST,
+        );
+
+        const signedTransaction = mosaicDefinitionTransaction.signWith(account);
+
+        const transaction = TransactionMapping.createFromPayload(signedTransaction.payload) as MosaicDefinitionTransaction;
+
+        expect(transaction.mosaicProperties.divisibility).to.be.equal(3);
+        expect(transaction.mosaicProperties.supplyMutable).to.be.equal(false);
+        expect(transaction.mosaicProperties.transferable).to.be.equal(false);
+        expect(transaction.mosaicProperties.levyMutable).to.be.equal(false);
+
+    });
+
+    it('should create MosaicDefinitionTransaction - without duration', () => {
+        const mosaicDefinitionTransaction = MosaicDefinitionTransaction.create(
+            Deadline.create(),
+            new MosaicNonce(new Uint8Array([0xE6, 0xDE, 0x84, 0xB8])), // nonce
+            new MosaicId(UInt64.fromUint(1).toDTO()), // ID
+            MosaicProperties.create({
+                supplyMutable: false,
+                transferable: false,
+                levyMutable: false,
+                divisibility: 3,
+            }),
+            NetworkType.MIJIN_TEST,
+        );
+
+        const signedTransaction = mosaicDefinitionTransaction.signWith(account);
+
+        const transaction = TransactionMapping.createFromPayload(signedTransaction.payload) as MosaicDefinitionTransaction;
+
+        expect(transaction.mosaicProperties.divisibility).to.be.equal(3);
+        expect(transaction.mosaicProperties.supplyMutable).to.be.equal(false);
+        expect(transaction.mosaicProperties.transferable).to.be.equal(false);
+        expect(transaction.mosaicProperties.levyMutable).to.be.equal(false);
+
+    });
+
+    it('should create MosaicDefinitionTransaction - without duration', () => {
+        const mosaicDefinitionTransaction = MosaicDefinitionTransaction.create(
+            Deadline.create(),
+            new MosaicNonce(new Uint8Array([0xE6, 0xDE, 0x84, 0xB8])), // nonce
+            new MosaicId(UInt64.fromUint(1).toDTO()), // ID
+            MosaicProperties.create({
+                supplyMutable: false,
+                transferable: false,
+                levyMutable: false,
+                divisibility: 3,
+            }),
+            NetworkType.MIJIN_TEST,
+        );
+
+        const signedTransaction = mosaicDefinitionTransaction.signWith(account);
+
+        const transaction = TransactionMapping.createFromPayload(signedTransaction.payload) as MosaicDefinitionTransaction;
+
+        expect(transaction.mosaicProperties.divisibility).to.be.equal(3);
+        expect(transaction.mosaicProperties.supplyMutable).to.be.equal(false);
+        expect(transaction.mosaicProperties.transferable).to.be.equal(false);
+        expect(transaction.mosaicProperties.levyMutable).to.be.equal(false);
+
+    });
+
+    it('should create MosaicDefinitionTransaction - without duration', () => {
+        const mosaicDefinitionTransaction = MosaicDefinitionTransaction.create(
+            Deadline.create(),
+            new MosaicNonce(new Uint8Array([0xE6, 0xDE, 0x84, 0xB8])), // nonce
+            new MosaicId(UInt64.fromUint(1).toDTO()), // ID
+            MosaicProperties.create({
+                supplyMutable: false,
+                transferable: false,
+                levyMutable: false,
+                divisibility: 3,
+            }),
+            NetworkType.MIJIN_TEST,
+        );
+
+        const signedTransaction = mosaicDefinitionTransaction.signWith(account);
+
+        const transaction = TransactionMapping.createFromPayload(signedTransaction.payload) as MosaicDefinitionTransaction;
+
         expect(transaction.mosaicProperties.divisibility).to.be.equal(3);
         expect(transaction.mosaicProperties.supplyMutable).to.be.equal(false);
         expect(transaction.mosaicProperties.transferable).to.be.equal(false);
diff --git a/test/infrastructure/SerializeTransactionToJSON.spec.ts b/test/infrastructure/SerializeTransactionToJSON.spec.ts
@@ -197,6 +197,27 @@ describe('SerializeTransactionToJSON', () => {
 
     });
 
+    it('should create MosaicDefinitionTransaction without duration', () => {
+        const mosaicDefinitionTransaction = MosaicDefinitionTransaction.create(
+            Deadline.create(),
+            new MosaicNonce(new Uint8Array([0xE6, 0xDE, 0x84, 0xB8])), // nonce
+            new MosaicId(UInt64.fromUint(1).toDTO()), // ID
+            MosaicProperties.create({
+                supplyMutable: false,
+                transferable: false,
+                levyMutable: false,
+                divisibility: 3,
+            }),
+            NetworkType.MIJIN_TEST,
+        );
+
+        const json = mosaicDefinitionTransaction.toJSON();
+
+        expect(json.transaction.type).to.be.equal(TransactionType.MOSAIC_DEFINITION);
+        expect(json.transaction.properties.length).to.be.equal(2);
+
+    });
+
     it('should create MosaicSupplyChangeTransaction', () => {
         const mosaicId = new MosaicId([2262289484, 3405110546]);
         const mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.create(
diff --git a/test/model/mosaic/MosaicInfo.spec.ts b/test/model/mosaic/MosaicInfo.spec.ts
@@ -78,6 +78,33 @@ describe('MosaicInfo', () => {
 
     });
 
+    it('should createComplete an MosaicInfo object without duration', () => {
+        const mosaicInfo = new MosaicInfo(
+            mosaicInfoDTO.meta.id,
+            mosaicInfoDTO.mosaic.mosaicId,
+            mosaicInfoDTO.mosaic.supply,
+            mosaicInfoDTO.mosaic.height,
+            mosaicInfoDTO.mosaic.owner,
+            mosaicInfoDTO.mosaic.revision,
+            new MosaicProperties(
+                mosaicInfoDTO.mosaic.properties[0],
+                mosaicInfoDTO.mosaic.properties[1].compact(),
+            ),
+            mosaicInfoDTO.mosaic.levy,
+        );
+
+        expect(mosaicInfo.metaId).to.be.equal(mosaicInfoDTO.meta.id);
+        deepEqual(mosaicInfo.mosaicId, mosaicInfoDTO.mosaic.mosaicId);
+        deepEqual(mosaicInfo.supply, mosaicInfoDTO.mosaic.supply);
+        deepEqual(mosaicInfo.height, mosaicInfoDTO.mosaic.height);
+        expect(mosaicInfo.owner).to.be.equal(mosaicInfoDTO.mosaic.owner);
+        deepEqual(mosaicInfo.revision, mosaicInfoDTO.mosaic.revision);
+
+        expect(mosaicInfo.divisibility).to.be.equal(mosaicInfoDTO.mosaic.properties[1].lower);
+        deepEqual(mosaicInfo.duration, undefined);
+
+    });
+
     describe('isSupplyMutable', () => {
         it('should return true when it\'s mutable', () => {
             const mosaicInfo = new MosaicInfo(
diff --git a/test/model/mosaic/MosaicProperties.spec.ts b/test/model/mosaic/MosaicProperties.spec.ts
@@ -69,4 +69,20 @@ describe('MosaicProperties', () => {
         expect(mosaicProperties.transferable).to.be.equal(false);
         expect(mosaicProperties.levyMutable).to.be.equal(false);
     });
+
+    it('should createComplete an MosaicProperties object without duration', () => {
+        const mosaicProperties = MosaicProperties.create({
+            supplyMutable: false,
+            transferable: false,
+            levyMutable: false,
+            divisibility: 10,
+        });
+
+        expect(mosaicProperties.divisibility).to.be.equal(10);
+        deepEqual(mosaicProperties.duration, undefined);
+
+        expect(mosaicProperties.supplyMutable).to.be.equal(false);
+        expect(mosaicProperties.transferable).to.be.equal(false);
+        expect(mosaicProperties.levyMutable).to.be.equal(false);
+    });
 });
diff --git a/test/model/transaction/EncryptedMessage.spec.ts b/test/model/transaction/EncryptedMessage.spec.ts
@@ -16,43 +16,33 @@
 
 import {expect} from 'chai';
 import {Account} from '../../../src/model/account/Account';
-
-import {PublicAccount} from '../../../src/model/account/PublicAccount';
-import {NetworkType} from '../../../src/model/blockchain/NetworkType';
 import {EncryptedMessage} from '../../../src/model/transaction/EncryptedMessage';
-
+import { TestingAccount } from '../../conf/conf.spec';
 
 describe('EncryptedMessage', () => {
 
-    const accountInformation = {
-        address: 'SCTVW23D2MN5VE4AQ4TZIDZENGNOZXPRPRLIKCF2',
-        privateKey: '26b64cb10f005e5988a36744ca19e20d835ccc7c105aaa5f3b212da593180930'.toUpperCase(),
-        publicKey: 'c2f93346e27ce6ad1a9f8f5e3066f8326593a406bdf357acb041e2f9ab402efe'.toUpperCase(),
-    };
-    let recipientPublicAccount:PublicAccount;
+    let account: Account;
 
     before(() => {
-        recipientPublicAccount = PublicAccount.createFromPublicKey(accountInformation.publicKey,NetworkType.MIJIN_TEST);
+        account = TestingAccount;
     });
 
-    it("should create a encrypted message from a DTO", () => {
-        const encryptedMessage = EncryptedMessage.createFromDTO("test transaction");
-        expect(encryptedMessage.payload).to.be.equal("test transaction");
+    it('should create a encrypted message from a DTO', () => {
+        const encryptedMessage = EncryptedMessage.createFromDTO('test transaction');
+        expect(encryptedMessage.payload).to.be.equal('test transaction');
     });
 
-    it("should return encrypted message dto", () => {
-        const account = Account.createFromPrivateKey(accountInformation.privateKey,NetworkType.MIJIN_TEST);
-        const publicAccount = PublicAccount.createFromPublicKey(account.publicKey,NetworkType.MIJIN_TEST);
-        const encryptedMessage = account.encryptMessage("test transaction", publicAccount);
-        const plainMessage = account.decryptMessage(encryptedMessage, publicAccount);
-        expect(plainMessage.payload).to.be.equal("test transaction");
+    it('should return encrypted message dto', () => {;
+        const encryptedMessage = account.encryptMessage('test transaction', account.publicAccount);
+        const plainMessage = account.decryptMessage(encryptedMessage, account.publicAccount);
+        expect(plainMessage.payload).to.be.equal('test transaction');
     });
 
-    it("should create an encrypted message from a DTO and decrypt it", () => {
-        const account = Account.createFromPrivateKey(accountInformation.privateKey,NetworkType.MIJIN_TEST);
-        const publicAccount = PublicAccount.createFromPublicKey("0414fe7647ec008e533aac98a4bf1c5fbf1d236c75b81fdadf1f5d1042fdd2ff",NetworkType.MIJIN_TEST);
-        const encryptMessage = EncryptedMessage.createFromDTO("02bb332c0fdd445455117882b2bec5e49f5713860d6b34650d0f769159d021a27518ea03539af8913231b9f80f600daae9291bb100a6d32e36b52a6c457fea287ca9942a32368618fe1fd0c185dbf834");
-        const plainMessage = account.decryptMessage(encryptMessage, publicAccount);
-        expect(plainMessage.payload).to.be.equal("test transaction");
+    it('should create an encrypted message from a DTO and decrypt it', () => {
+        const encryptMessage = EncryptedMessage
+            .createFromDTO('7245170507448c53d808524221b5d157e19b06f574120a044e48f54dd8e0a4dedbf50ded7ae71' +
+                           'b90b59949bb6acde81d987ee6648aae9f093b94ac7cc3e8dba0bed8fa04ba286df6b32d2d6d21cbdc4e');
+        const plainMessage = account.decryptMessage(encryptMessage, account.publicAccount);
+        expect(plainMessage.payload).to.be.equal('test transaction');
     });
 });
diff --git a/test/model/transaction/MosaicDefinitionTransaction.spec.ts b/test/model/transaction/MosaicDefinitionTransaction.spec.ts
diff --git a/tslint.json b/tslint.json

Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ export class MosaicInfo {`
`81`	`81`	`* Mosaic duration`
`82`	`82`	`* @returns {UInt64}`
`83`	`83`	`*/`
`84`		`- public get duration(): UInt64 {`
	`84`	`+ public get duration(): UInt64 \| undefined {`
`85`	`85`	`return this.properties.duration;`
`86`	`86`	`}`
`87`	`87`