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

* 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

Author: rg911

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;
         });
     });
 

package-lock.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"

package.json

@@ -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,
         );
     }
 

src/infrastructure/BlockHttp.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;

src/infrastructure/transaction/CreateTransactionFromDTO.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 {

src/infrastructure/transaction/SerializeTransactionToJSON.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,
     ) {}
 }

src/model/blockchain/BlockInfo.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);
     }
 }

src/model/message/Message.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');
+        }
+    }
 }

src/model/transaction/TransferTransaction.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);
     }