Remove message type from payload for empty message + block meta change (#679)

rg911 · web-flow · commit bfbbe11d4663 · 2020-09-25T13:04:06.000+01:00
* Fixed #678 Remove message type from payload for empty message * Updaged method name * - Updated openAPI (removed message.type & payload) * Fixed #680 - Updated message .toJSON to use hex string input * fixed message toJson
diff --git a/e2e/infrastructure/BlockHttp.spec.ts b/e2e/infrastructure/BlockHttp.spec.ts
@@ -91,7 +91,7 @@ describe('BlockHttp', () => {
             expect(blockInfo.timestamp.lower).to.be.equal(0);
             expect(blockInfo.timestamp.higher).to.be.equal(0);
             expect(blockInfo.beneficiaryAddress).not.to.be.undefined;
-            expect(blockInfo.numStatements).not.to.be.undefined;
+            expect(blockInfo.statementsCount).not.to.be.undefined;
         });
     });
 
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -109,7 +109,7 @@
         "ripemd160": "^2.0.2",
         "rxjs": "^6.5.3",
         "rxjs-compat": "^6.5.3",
-        "symbol-openapi-typescript-fetch-client": "0.9.7-SNAPSHOT.202009171123",
+        "symbol-openapi-typescript-fetch-client": "0.10.0-SNAPSHOT.202009251042",
         "tweetnacl": "^1.0.3",
         "utf8": "^3.0.0",
         "ws": "^7.2.3"
diff --git a/src/infrastructure/BlockHttp.ts b/src/infrastructure/BlockHttp.ts
@@ -95,7 +95,7 @@ export class BlockHttp extends Http implements BlockRepository {
             dto.meta.generationHash,
             UInt64.fromNumericString(dto.meta.totalFee),
             dto.meta.stateHashSubCacheMerkleRoots,
-            dto.meta.numTransactions,
+            dto.meta.totalTransactionsCount,
             dto.block.signature,
             PublicAccount.createFromPublicKey(dto.block.signerPublicKey, networkType),
             networkType,
@@ -112,8 +112,9 @@ export class BlockHttp extends Http implements BlockRepository {
             dto.block.proofGamma,
             dto.block.proofScalar,
             dto.block.proofVerificationHash,
-            dto.block.beneficiaryAddress ? Address.createFromEncoded(dto.block.beneficiaryAddress) : undefined,
-            dto.meta.numStatements,
+            Address.createFromEncoded(dto.block.beneficiaryAddress),
+            dto.meta.transactionsCount,
+            dto.meta.statementsCount,
         );
     }
 
diff --git a/src/infrastructure/transaction/CreateTransactionFromDTO.ts b/src/infrastructure/transaction/CreateTransactionFromDTO.ts
@@ -18,6 +18,7 @@ import { UnresolvedMapping } from '../../core/utils/UnresolvedMapping';
 import { Address } from '../../model/account/Address';
 import { PublicAccount } from '../../model/account/PublicAccount';
 import { EncryptedMessage } from '../../model/message/EncryptedMessage';
+import { Message } from '../../model/message/Message';
 import { MessageType } from '../../model/message/MessageType';
 import { PersistentHarvestingDelegationMessage } from '../../model/message/PersistentHarvestingDelegationMessage';
 import { EmptyMessage, PlainMessage } from '../../model/message/PlainMessage';
@@ -104,19 +105,20 @@ export const extractMosaics = (mosaics: any): Mosaic[] => {
  * Extract message from either JSON payload (unencoded) or DTO (encoded)
  *
  * @param message - message payload
- * @return {PlainMessage}
+ * @return {Message}
  */
-const extractMessage = (message: any): PlainMessage | EncryptedMessage => {
+const extractMessage = (message: any): Message => {
     let msgObj = EmptyMessage;
     if (message) {
-        if (message.type === MessageType.PlainMessage) {
-            msgObj = convert.isHexString(message.payload)
-                ? PlainMessage.createFromPayload(message.payload)
-                : PlainMessage.create(message.payload);
-        } else if (message.type === MessageType.EncryptedMessage) {
-            msgObj = EncryptedMessage.createFromPayload(message.payload);
-        } else if (message.type === MessageType.PersistentHarvestingDelegationMessage) {
-            msgObj = PersistentHarvestingDelegationMessage.createFromPayload(message.payload);
+        const messagePayload = message.payload ? message.payload : message.substring(2);
+        const messageType = message.type !== undefined ? message.type : convert.hexToUint8(message.substring(0, 2))[0];
+
+        if (messageType === MessageType.PlainMessage) {
+            msgObj = PlainMessage.createFromPayload(messagePayload);
+        } else if (messageType === MessageType.EncryptedMessage) {
+            msgObj = EncryptedMessage.createFromPayload(messagePayload);
+        } else if (messageType === MessageType.PersistentHarvestingDelegationMessage) {
+            msgObj = PersistentHarvestingDelegationMessage.createFromPayload(messagePayload);
         }
     }
     return msgObj;
diff --git a/src/infrastructure/transaction/SerializeTransactionToJSON.ts b/src/infrastructure/transaction/SerializeTransactionToJSON.ts
@@ -197,13 +197,18 @@ export const SerializeTransactionToJSON = (transaction: Transaction): any => {
             };
         case TransactionType.TRANSFER:
             const transferTx = transaction as TransferTransaction;
-            return {
+            const messageObject = {
                 recipientAddress: transferTx.recipientAddress.toDTO(),
                 mosaics: transferTx.mosaics.map((mosaic) => {
                     return mosaic.toDTO();
                 }),
-                message: transferTx.message.toDTO(),
             };
+            if (transferTx.message.toDTO().length) {
+                Object.assign(messageObject, {
+                    message: transferTx.message.toDTO(),
+                });
+            }
+            return messageObject;
         case TransactionType.MOSAIC_GLOBAL_RESTRICTION:
             const mosaicGlobalRestrictionTx = transaction as MosaicGlobalRestrictionTransaction;
             return {
diff --git a/src/model/blockchain/BlockInfo.ts b/src/model/blockchain/BlockInfo.ts
@@ -76,9 +76,9 @@ export class BlockInfo {
          */
         public readonly stateHashSubCacheMerkleRoots: string[],
         /**
-         * The number of transactions included.
+         * The total number of transactions confirmed (including embedded transaction) included.
          */
-        public readonly numTransactions: number,
+        public readonly totalTransactionsCount: number,
         /**
          * The block signature.
          * The signature was generated by the signer and can be used to validate that the blockchain
@@ -149,10 +149,14 @@ export class BlockInfo {
         /**
          * The beneficiary address.
          */
-        public readonly beneficiaryAddress?: Address | undefined,
+        public readonly beneficiaryAddress: Address,
+        /**
+         * The number of statements confiemd (excluding embedded transaction) included.
+         */
+        public readonly transactionsCount: number,
         /**
          * The number of statements included.
          */
-        public readonly numStatements?: number,
+        public readonly statementsCount: number,
     ) {}
 }
diff --git a/src/model/message/Message.ts b/src/model/message/Message.ts
@@ -1,4 +1,5 @@
 /*
+import { Convert } from '../../core/format/Convert';
  * Copyright 2018 NEM
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,6 +15,9 @@
  * limitations under the License.
  */
 
+import { MessageType } from './MessageType';
+import { Convert } from '../../core/format/Convert';
+
 /**
  * An abstract message class that serves as the base class of all message types.
  */
@@ -46,10 +50,12 @@ export abstract class Message {
     /**
      * Create DTO object
      */
-    toDTO(): any {
-        return {
-            type: this.type,
-            payload: this.payload,
-        };
+    toDTO(): string {
+        if (!this.payload) {
+            return '';
+        }
+        return this.type === MessageType.PersistentHarvestingDelegationMessage
+            ? this.payload
+            : this.type.toString(16).padStart(2, '0').toUpperCase() + Convert.utf8ToHex(this.payload);
     }
 }
diff --git a/src/model/transaction/TransferTransaction.ts b/src/model/transaction/TransferTransaction.ts
@@ -34,10 +34,8 @@ import { DtoMapping } from '../../core/utils/DtoMapping';
 import { UnresolvedMapping } from '../../core/utils/UnresolvedMapping';
 import { Address } from '../account/Address';
 import { PublicAccount } from '../account/PublicAccount';
-import { EncryptedMessage } from '../message/EncryptedMessage';
 import { Message } from '../message/Message';
 import { MessageType } from '../message/MessageType';
-import { PlainMessage } from '../message/PlainMessage';
 import { Mosaic } from '../mosaic/Mosaic';
 import { NamespaceId } from '../namespace/NamespaceId';
 import { NetworkType } from '../network/NetworkType';
@@ -50,6 +48,9 @@ import { TransactionInfo } from './TransactionInfo';
 import { TransactionType } from './TransactionType';
 import { TransactionVersion } from './TransactionVersion';
 import { UnresolvedAddress } from '../account/UnresolvedAddress';
+import { EmptyMessage, PlainMessage } from '../message/PlainMessage';
+import { EncryptedMessage } from '../message/EncryptedMessage';
+import { PersistentHarvestingDelegationMessage } from '../message/PersistentHarvestingDelegationMessage';
 
 /**
  * Transfer transactions contain data about transfers of mosaics and message to another account.
@@ -121,7 +122,7 @@ export class TransferTransaction extends Transaction {
         /**
          * The transaction message of 2048 characters.
          */
-        public readonly message: Message,
+        public readonly message: Message = EmptyMessage,
         signature?: string,
         signer?: PublicAccount,
         transactionInfo?: TransactionInfo,
@@ -140,8 +141,6 @@ export class TransferTransaction extends Transaction {
         const builder = isEmbedded
             ? EmbeddedTransferTransactionBuilder.loadFromBinary(Convert.hexToUint8(payload))
             : TransferTransactionBuilder.loadFromBinary(Convert.hexToUint8(payload));
-        const messageType = builder.getMessage()[0];
-        const messageHex = Convert.uint8ToHex(builder.getMessage()).substring(2);
         const signerPublicKey = Convert.uint8ToHex(builder.getSignerPublicKey().key);
         const networkType = builder.getNetwork().valueOf();
         const signature = payload.substring(16, 144);
@@ -152,9 +151,7 @@ export class TransferTransaction extends Transaction {
                 const id = new UInt64(mosaic.mosaicId.unresolvedMosaicId).toHex();
                 return new Mosaic(UnresolvedMapping.toUnresolvedMosaic(id), new UInt64(mosaic.amount.amount));
             }),
-            messageType === MessageType.PlainMessage
-                ? PlainMessage.createFromPayload(messageHex)
-                : EncryptedMessage.createFromPayload(messageHex),
+            TransferTransaction.createMessageFromBuffer(builder.getMessage()),
             networkType,
             isEmbedded ? new UInt64([0, 0]) : new UInt64((builder as TransferTransactionBuilder).fee.amount),
             isEmbedded || signature.match(`^[0]+$`) ? undefined : signature,
@@ -168,7 +165,7 @@ export class TransferTransaction extends Transaction {
      * @internal
      */
     protected validate(): void {
-        if (this.message.type === MessageType.PersistentHarvestingDelegationMessage) {
+        if (this.message?.type === MessageType.PersistentHarvestingDelegationMessage) {
             if (this.mosaics.length > 0) {
                 throw new Error('PersistentDelegationRequestTransaction should be created without Mosaic');
             } else if (!/^[0-9a-fA-F]{264}$/.test(this.message.payload)) {
@@ -211,13 +208,16 @@ export class TransferTransaction extends Transaction {
      * @returns {Uint8Array}
      */
     public getMessageBuffer(): Uint8Array {
+        if (!this.message || !this.message.payload) {
+            return Uint8Array.of();
+        }
         const messgeHex =
             this.message.type === MessageType.PersistentHarvestingDelegationMessage
                 ? this.message.payload
                 : Convert.utf8ToHex(this.message.payload);
         const payloadBuffer = Convert.hexToUint8(messgeHex);
         const typeBuffer = GeneratorUtils.uintToBuffer(this.message.type, 1);
-        return this.message.type === MessageType.PersistentHarvestingDelegationMessage
+        return this.message.type === MessageType.PersistentHarvestingDelegationMessage || !this.message.payload
             ? payloadBuffer
             : GeneratorUtils.concatTypedArrays(typeBuffer, payloadBuffer);
     }
@@ -298,4 +298,25 @@ export class TransferTransaction extends Transaction {
             alias.find((name) => this.recipientAddress.equals(name)) !== undefined
         );
     }
+
+    /**
+     * @internal
+     */
+    private static createMessageFromBuffer(messageBuffer: Uint8Array): Message {
+        if (!messageBuffer.length) {
+            return EmptyMessage;
+        }
+        const messageType = messageBuffer[0];
+        const messageHex = Convert.uint8ToHex(messageBuffer).substring(2);
+        switch (messageType) {
+            case MessageType.PlainMessage:
+                return PlainMessage.createFromPayload(messageHex);
+            case MessageType.EncryptedMessage:
+                return EncryptedMessage.createFromPayload(messageHex);
+            case MessageType.PersistentHarvestingDelegationMessage:
+                return PersistentHarvestingDelegationMessage.createFromPayload(messageHex);
+            default:
+                throw new Error('Message Type is not valid');
+        }
+    }
 }
diff --git a/test/infrastructure/BlockHttp.spec.ts b/test/infrastructure/BlockHttp.spec.ts
@@ -57,8 +57,9 @@ describe('BlockHttp', () => {
     const blockMetaDTO = {} as BlockMetaDTO;
     blockMetaDTO.generationHash = 'abc';
     blockMetaDTO.hash = 'aHash';
-    blockMetaDTO.numStatements = 10;
-    blockMetaDTO.numTransactions = 20;
+    blockMetaDTO.statementsCount = 10;
+    blockMetaDTO.transactionsCount = 20;
+    blockMetaDTO.totalTransactionsCount = 30;
     blockMetaDTO.totalFee = '30';
     blockMetaDTO.stateHashSubCacheMerkleRoots = ['a', 'b', 'c'];
 
@@ -94,8 +95,9 @@ describe('BlockHttp', () => {
 
         expect(blockInfo.generationHash).to.be.equals(blockInfoDto.meta.generationHash);
         expect(blockInfo.hash).to.be.equals(blockInfoDto.meta.hash);
-        expect(blockInfo.numStatements).to.be.equals(blockInfoDto.meta.numStatements);
-        expect(blockInfo.numTransactions).to.be.equals(blockInfoDto.meta.numTransactions);
+        expect(blockInfo.statementsCount).to.be.equals(blockInfoDto.meta.statementsCount);
+        expect(blockInfo.transactionsCount).to.be.equals(blockInfoDto.meta.transactionsCount);
+        expect(blockInfo.totalTransactionsCount).to.be.equals(blockInfoDto.meta.totalTransactionsCount);
         expect(blockInfo.totalFee.toString()).to.be.equals(blockInfoDto.meta.totalFee);
     }
 
diff --git a/test/infrastructure/SerializeTransactionToJSON.spec.ts b/test/infrastructure/SerializeTransactionToJSON.spec.ts
@@ -225,8 +225,7 @@ describe('SerializeTransactionToJSON', () => {
         const json = transferTransaction.toJSON();
 
         expect(json.transaction.type).to.be.equal(TransactionType.TRANSFER);
-        expect(json.transaction.message.payload).to.be.equal('test-message');
-        expect(json.transaction.message.type).to.be.equal(0);
+        expect(json.transaction.message).to.be.equal('00746573742D6D657373616765');
     });
 
     it('should create SecretLockTransaction', () => {
diff --git a/test/infrastructure/TransactionHttp.spec.ts b/test/infrastructure/TransactionHttp.spec.ts
@@ -368,8 +368,9 @@ describe('TransactionHttp', () => {
         const blockMetaDTO = {} as BlockMetaDTO;
         blockMetaDTO.generationHash = 'abc';
         blockMetaDTO.hash = 'aHash';
-        blockMetaDTO.numStatements = 10;
-        blockMetaDTO.numTransactions = 20;
+        blockMetaDTO.statementsCount = 10;
+        blockMetaDTO.transactionsCount = 20;
+        blockMetaDTO.totalTransactionsCount = 30;
         blockMetaDTO.totalFee = '30';
         blockMetaDTO.stateHashSubCacheMerkleRoots = ['a', 'b', 'c'];
 
@@ -381,7 +382,7 @@ describe('TransactionHttp', () => {
         when(blockRoutesApi.getBlockByHeight(deepEqual(UInt64.fromUint(1).toString()))).thenReturn(Promise.resolve(blockInfoDto));
 
         const fees = await transactionHttp.getTransactionEffectiveFee(generationHash).toPromise();
-        expect(fees).to.be.equal(483);
+        expect(fees).to.be.equal(480);
     });
 
     it('Test announce', async () => {
diff --git a/test/model/blockchain/BlockInfo.spec.ts b/test/model/blockchain/BlockInfo.spec.ts
@@ -50,8 +50,9 @@ describe('BlockInfo', () => {
             meta: {
                 generationHash: '57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6',
                 hash: '24E92B511B54EDB48A4850F9B42485FDD1A30589D92C775632DDDD71D7D1D691',
-                numTransactions: 25,
-                numStatements: 1,
+                totalTransactionsCount: 35,
+                transactionsCount: 25,
+                statementsCount: 1,
                 totalFee: new UInt64([0, 0]),
                 stateHashSubCacheMerkleRoots: ['45FF761839D7219296341925EBA3BF4832BA9B3E29C854B83E6445D5F3E1DAB7'],
             },
@@ -64,7 +65,7 @@ describe('BlockInfo', () => {
             blockDTO.meta.generationHash,
             blockDTO.meta.totalFee,
             blockDTO.meta.stateHashSubCacheMerkleRoots,
-            blockDTO.meta.numTransactions,
+            blockDTO.meta.totalTransactionsCount,
             blockDTO.block.signature,
             PublicAccount.createFromPublicKey(blockDTO.block.signerPublicKey, blockDTO.block.network),
             blockDTO.block.network,
@@ -82,15 +83,16 @@ describe('BlockInfo', () => {
             blockDTO.block.proofScalar,
             blockDTO.block.proofVerificationHash,
             Address.createFromEncoded(blockDTO.block.beneficiaryAddress),
-            blockDTO.meta.numStatements,
+            blockDTO.meta.transactionsCount,
+            blockDTO.meta.statementsCount,
         );
 
         expect(blockInfo.recordId).to.be.equal(blockDTO.id);
         expect(blockInfo.size).to.be.equal(blockDTO.block.size);
         expect(blockInfo.hash).to.be.equal(blockDTO.meta.hash);
         expect(blockInfo.generationHash).to.be.equal(blockDTO.meta.generationHash);
         deepEqual(blockInfo.totalFee, blockDTO.meta.totalFee);
-        expect(blockInfo.numTransactions).to.be.equal(blockDTO.meta.numTransactions);
+        expect(blockInfo.totalTransactionsCount).to.be.equal(blockDTO.meta.totalTransactionsCount);
         expect(blockInfo.signature).to.be.equal(blockDTO.block.signature);
         expect(blockInfo.signer.publicKey).to.be.equal(blockDTO.block.signerPublicKey);
         expect(blockInfo.networkType).to.be.equal(blockDTO.block.network);
@@ -105,8 +107,8 @@ describe('BlockInfo', () => {
         expect(blockInfo.blockReceiptsHash).to.be.equal(blockDTO.block.blockReceiptsHash);
         expect(blockInfo.stateHash).to.be.equal(blockDTO.block.stateHash);
         expect(blockInfo.beneficiaryAddress?.plain()).to.be.equal(Address.createFromEncoded(blockDTO.block.beneficiaryAddress).plain());
-        expect(blockInfo.numStatements).to.be.equal(blockDTO.meta.numStatements);
-        expect(blockInfo.proofGamma).to.be.equal(blockDTO.block.proofGamma);
+        expect(blockInfo.statementsCount).to.be.equal(blockDTO.meta.statementsCount);
+        expect(blockInfo.transactionsCount).to.be.equal(blockDTO.meta.transactionsCount);
         expect(blockInfo.proofScalar).to.be.equal(blockDTO.block.proofScalar);
         expect(blockInfo.proofVerificationHash).to.be.equal(blockDTO.block.proofVerificationHash);
         expect(blockInfo.stateHashSubCacheMerkleRoots.length).to.be.equal(1);
diff --git a/test/model/message/Message.spec.ts b/test/model/message/Message.spec.ts
diff --git a/test/model/transaction/TransferTransaction.spec.ts b/test/model/transaction/TransferTransaction.spec.ts
diff --git a/test/service/BlockService.spec.ts b/test/service/BlockService.spec.ts
