Fix plain message payload size (#146)

* fix plain message size * fix test cases * fix UnknownTxn d file issue * update package version
proximax-storage · Apr 12, 2023 · 1cd9444 · 1cd9444
1 parent 472cf44
commit 1cd9444
Show file tree

Hide file tree

Showing 13 changed files with 71 additions and 63 deletions.
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "tsjs-xpx-chain-sdk",
-  "version": "0.9.19",
+  "version": "0.9.20",
   "description": "Proximax Blockchain sdk for typescript and javascript",
   "scripts": {
     "pretest": "npm run build",

diff --git a/src/infrastructure/builders/TransferTransaction.ts b/src/infrastructure/builders/TransferTransaction.ts
@@ -107,14 +107,8 @@ export class Builder {
         // Constants
 
         // Create message
-        let bytePayload;
-        if (this.message.type === MessageType.EncryptedMessage) {
-            bytePayload = convert.hexToUint8(this.message.payload);
-        } else if(this.message.type === MessageType.HexadecimalMessage){
-            bytePayload = convert.hexToUint8(this.message.payload);
-        } else {
-            bytePayload = convert.hexToUint8(convert.utf8ToHex(this.message.payload));
-        }
+        let bytePayload = convert.hexToUint8(this.message.payload);
+
         const payload = MessageBuffer.createPayloadVector(builder, bytePayload);
         MessageBuffer.startMessageBuffer(builder);
         MessageBuffer.addType(builder, this.message.type);

diff --git a/src/model/transaction/EncryptedMessage.ts b/src/model/transaction/EncryptedMessage.ts
@@ -29,9 +29,6 @@ export class EncryptedMessage extends Message {
         super(MessageType.EncryptedMessage, payload);
     }
 
-    public size(): number {
-        return (this.payload || '').length / 2;
-    }
 
     /**
      *

diff --git a/src/model/transaction/HexadecimalMessage.ts b/src/model/transaction/HexadecimalMessage.ts
@@ -48,8 +48,5 @@ export class HexadecimalMessage extends Message {
         super(MessageType.HexadecimalMessage, payload);
     }
 
-    public size(): number {
-        return (this.payload || '').length / 2;
-    }
 
 }
diff --git a/src/model/transaction/Message.ts b/src/model/transaction/Message.ts
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 
-import {decode} from 'utf8';
 import {Convert as convert} from '../../core/format'
 
 /**
@@ -28,21 +27,41 @@ export abstract class Message {
      * @returns {string}
      */
     public static decodeHex(hex: string): string {
-        let str = '';
-        for (let i = 0; i < hex.length; i += 2) {
-            str += String.fromCharCode(parseInt(hex.substring(i, i + 2), 16));
+        let message = "";
+        try {
+            let uint8Array = convert.hexToUint8(hex);
+
+            message = new TextDecoder().decode(uint8Array);
+        } catch (e) {
+
         }
+
+        return message;
+    }
+
+    /**
+     * @internal
+     * @param message
+     * @returns {string}
+     */
+    public static encodeToHex(message: string): string {
+
+        let payload = "";
         try {
-            return decode(str);
+            let uint8Array = new TextEncoder().encode(message);
+            payload = convert.uint8ToHex(uint8Array);
         } catch (e) {
-            return str;
+
         }
+
+        return payload;
     }
 
     /**
      * @internal
      * @param type
-     * @param payload
+     * @param payload - Hexadecimal message payload
+     * @param message
      */
     constructor(/**
                  * Message type
@@ -51,21 +70,28 @@ export abstract class Message {
                 /**
                  * Message payload
                  */
-                public readonly payload: string) {
+                public readonly payload: string, 
+                /**
+                 * Message payload
+                 */
+                public message: string = "") { 
     }
 
     /**
      * Returns the byte size of the message
      */
-    public abstract size(): number;
+    public size(): number{
+        return this.payload.length ? this.payload.length / 2 : 0;
+    }
 
     /**
      * Create DTO object
      */
     toDTO() {
         return {
             type: this.type,
-            payload: this.type === 0 ? convert.utf8ToHex(this.payload) : this.payload,
+            payload: this.payload,
+            message: this.message,
         };
     }
 }
diff --git a/src/model/transaction/PlainMessage.ts b/src/model/transaction/PlainMessage.ts
@@ -1,4 +1,5 @@
 /*
+ * Copyright 2023 ProximaX
  * Copyright 2018 NEM
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +17,6 @@
 
 import {Message} from './Message';
 import {MessageType} from './MessageType';
-import { Convert as convert } from '../../core/format';
 
 /**
  * The plain message model defines a plain string. When sending it to the network we transform the payload to hex-string.
@@ -27,32 +27,27 @@ export class PlainMessage extends Message {
      * @returns PlainMessage
      */
     public static create(message: string): PlainMessage {
-        return new PlainMessage(message);
+        return new PlainMessage(message, Message.encodeToHex(message));
     }
 
     /**
      * @internal
      */
     public static createFromPayload(payload: string): PlainMessage {
-        return new PlainMessage(this.decodeHex(payload));
+        return new PlainMessage(Message.decodeHex(payload), payload);
     }
 
     /**
      * @internal
      * @param payload
-     */
-    constructor(payload: string) {
-        super(MessageType.PlainMessage, payload);
-    }
-
-    public size(): number {
-        return convert.utf8ToHex(this.payload || '').length / 2;
+     */ 
+    constructor(public readonly message: string, payload?: string) {
+        super(MessageType.PlainMessage, payload ? payload: Message.encodeToHex(message), message);
     }
-
 }
 
 /**
  * Plain message containing an empty string
  * @type {PlainMessage}
  */
-export const EmptyMessage = PlainMessage.create('');
+export const EmptyMessage = PlainMessage.create('');
diff --git a/src/model/transaction/UnknownTransaction.ts b/src/model/transaction/UnknownTransaction.ts
@@ -86,7 +86,6 @@ export class UnknownTransaction extends Transaction{
 
     /**
      * @override Transaction.size()
-     * @internal
      * @description get the byte size of a UnknownTransaction, will return error
      * @returns {never}
      * @memberof UnknownTransaction

diff --git a/test/core/utils/TransactionMapping.spec.ts b/test/core/utils/TransactionMapping.spec.ts
@@ -382,7 +382,7 @@ describe('TransactionMapping - createFromPayload', () => {
 
         const transaction = TransactionMapping.createFromPayload(signedTransaction.payload) as TransferTransaction;
 
-        expect(transaction.message.payload).to.be.equal('test-message');
+        expect(transaction.message.message).to.be.equal('test-message');
         expect(transaction.mosaics.length).to.be.equal(1);
         expect(transaction.recipientToString()).to.be.equal('SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC');
 
@@ -812,7 +812,7 @@ describe('TransactionMapping - createFromDTO (Transaction.toJSON() feed)', () =>
         const transaction = TransactionMapping.createFromDTO(transferTransaction.toJSON()) as TransferTransaction;
 
         expect((transaction.recipient as Address).plain()).to.be.equal('SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC');
-        expect(transaction.message.payload).to.be.equal('test-message');
+        expect(transaction.message.message).to.be.equal('test-message');
     });
 
     it('should create TransferTransaction - NamespaceId', () => {
@@ -828,7 +828,7 @@ describe('TransactionMapping - createFromDTO (Transaction.toJSON() feed)', () =>
 
         const transaction = TransactionMapping.createFromDTO(transferTransaction.toJSON()) as TransferTransaction;
         expect((transaction.recipient as NamespaceId).id.toHex().toUpperCase()).to.be.equal(new UInt64([33347626, 3779697293]).toHex());
-        expect(transaction.message.payload).to.be.equal('test-message');
+        expect(transaction.message.message).to.be.equal('test-message');
     });
 
     it('should create TransferTransaction - Encrypted Message', () => {

diff --git a/test/infrastructure/SerializeTransactionToJSON.spec.ts b/test/infrastructure/SerializeTransactionToJSON.spec.ts
@@ -279,7 +279,7 @@ describe('SerializeTransactionToJSON', () => {
 
         expect(json.transaction.type).to.be.equal(TransactionType.TRANSFER);
         expect((json.transaction.recipient as any).address).to.be.equal(address.plain());
-        expect(json.transaction.message.payload).to.be.equal('746573742d6d657373616765');
+        expect(json.transaction.message.payload).to.be.equal('746573742D6D657373616765');
         expect(json.transaction.message.type).to.be.equal(0);
         expect(json.transaction.mosaics.length).to.be.equal(1);
         deepStrictEqual(json.transaction.mosaics[0].id, mosaic.id.id.toDTO());
@@ -304,7 +304,7 @@ describe('SerializeTransactionToJSON', () => {
         expect(json.transaction.type).to.be.equal(TransactionType.TRANSFER);
         expect((json.transaction.recipient as any).fullName).to.be.equal('some-namespace');
         deepStrictEqual((json.transaction.recipient as any).id, namespaceId.id.toDTO());
-        expect(json.transaction.message.payload).to.be.equal('746573742d6d657373616765');
+        expect(json.transaction.message.payload).to.be.equal('746573742D6D657373616765');
         expect(json.transaction.message.type).to.be.equal(0);
         expect(json.transaction.mosaics.length).to.be.equal(1);
         deepStrictEqual(json.transaction.mosaics[0].id, mosaic.id.id.toDTO());

diff --git a/test/model/transaction/EncryptedMessage.spec.ts b/test/model/transaction/EncryptedMessage.spec.ts
@@ -47,14 +47,14 @@ describe('EncryptedMessage', () => {
     it('should return encrypted message dto', () => {
         const encryptedMessage = sender.encryptMessage('test transaction', recipient.publicAccount);
         const plainMessage = recipient.decryptMessage(encryptedMessage, sender.publicAccount);
-        expect(plainMessage.payload).to.be.equal('test transaction');
+        expect(plainMessage.message).to.be.equal('test transaction');
     });
 
     it('should decrypt message from raw encrypted message payload', () => {
         const payload = 'EF6F9F6F8BEFD8BC1FAECD1E610CC195D87D667F401A5B4EA8F0398BDE0B0A2FA4543D7C5C2468D2' +
                         'D478347FB856243F66b3c55321afe7471862d93392a9c57ef0646a045c3e038706de519b8392f4a2';
         const plainMessage = recipient.decryptMessage(new EncryptedMessage(payload), sender.publicAccount);
-        expect(plainMessage.payload).to.be.equal('Testing simple transfer');
+        expect(plainMessage.message).to.be.equal('Testing simple transfer');
     });
 
     it('should return decrepted message reading from message payload', () => {
@@ -70,7 +70,7 @@ describe('EncryptedMessage', () => {
         const encryptMessage = EncryptedMessage
             .createFromPayload(signedTransaction.payload.substring(302, signedTransaction.payload.length - 32));
         const plainMessage = recipient.decryptMessage(encryptMessage, sender.publicAccount);
-        expect(plainMessage.payload).to.be.equal('Testing simple transfer');
+        expect(plainMessage.message).to.be.equal('Testing simple transfer');
     });
 
     it('should encrypt/decrypt message as in js library test', () => {
@@ -81,10 +81,10 @@ describe('EncryptedMessage', () => {
         const senderPublic = senderPrivate.publicAccount;
 
         const encryptedMessage = senderPrivate.encryptMessage(message, recipientPublic);
-        expect(encryptedMessage.payload).not.to.be.equal(message);
+        expect(encryptedMessage.message).not.to.be.equal(message);
 
         const decryptedMessage = recipientPrivate.decryptMessage(encryptedMessage, senderPublic);
-        expect(decryptedMessage.payload).to.be.equal(message);
+        expect(decryptedMessage.message).to.be.equal(message);
     });
 
     it('should decrypt message from js library test', () => {
@@ -94,7 +94,7 @@ describe('EncryptedMessage', () => {
 
         const encryptMessage = new EncryptedMessage(encryptedMessageString);
         const plainMessage = recipientPrivate.decryptMessage(encryptMessage, senderPublic);
-        expect(plainMessage.payload).to.be.equal('ProximaX is awesome !');
+        expect(plainMessage.message).to.be.equal('ProximaX is awesome !');
     });
 
     it('should decrypt message encrypted in java sdk', () => {
@@ -103,7 +103,7 @@ describe('EncryptedMessage', () => {
         const sender = PublicAccount.createFromPublicKey('A36DF1F0B64C7FF71499784317C8D63FB1DB8E1909519AB72051D2BE77A1EF45', NetworkType.TEST_NET);
         const recipient = Account.createFromPrivateKey('6556da78c063e0547b7fd2e8a8b66ba09b8f28043235fea441414f0fc591f507', NetworkType.TEST_NET);
         const plainMessage = recipient.decryptMessage(encryptMessage, sender);
-        expect(plainMessage.payload).to.be.equal('java SDK secure message');
+        expect(plainMessage.message).to.be.equal('java SDK secure message');
     });
 
     it('should create secure message and decrypt message with sender private key ', () => {
@@ -118,7 +118,7 @@ describe('EncryptedMessage', () => {
 
         const decodedMessagePayload = EncryptedMessage.decrypt(secureMessage, senderPrivateKey, recipientPublicAccount);
 
-        expect(decodedMessagePayload.payload).to.be.equal(payload);
+        expect(decodedMessagePayload.message).to.be.equal(payload);
     });
 
     it('should create secure message and decrypt message with receiver private key', () => {
@@ -133,7 +133,7 @@ describe('EncryptedMessage', () => {
 
         const decodedMessagePayload = EncryptedMessage.decrypt(secureMessage, recipientPrivateKey, senderPublicAccount);
 
-        expect(decodedMessagePayload.payload).to.be.equal(payload);
+        expect(decodedMessagePayload.message).to.be.equal(payload);
     });
 
     it('should decrypt payload uploaded from java sdk with sender private key', () => {
@@ -144,9 +144,9 @@ describe('EncryptedMessage', () => {
         const publicAccount = PublicAccount.createFromPublicKey(publicKey, NetworkType.MIJIN_TEST);
         const secureMessage = new EncryptedMessage(payload);
 
-        const decodedMessagePayload = EncryptedMessage.decrypt(secureMessage, privateKey, publicAccount).payload;
+        const decodedMessage = EncryptedMessage.decrypt(secureMessage, privateKey, publicAccount).message;
 
-        expect(decodedMessagePayload).to.be.equal(expectedPayload);
+        expect(decodedMessage).to.be.equal(expectedPayload);
     });
 
     it('should decrypt payload uploaded from java sdk with receiver private key', () => {
@@ -157,15 +157,15 @@ describe('EncryptedMessage', () => {
         const publicAccount = PublicAccount.createFromPublicKey(publicKey, NetworkType.MIJIN_TEST);
         const secureMessage = new EncryptedMessage(payload);
 
-        const decodedMessagePayload = EncryptedMessage.decrypt(secureMessage, privateKey, publicAccount).payload;
+        const decodedMessage = EncryptedMessage.decrypt(secureMessage, privateKey, publicAccount).message;
 
-        expect(decodedMessagePayload).to.be.equal(expectedPayload);
+        expect(decodedMessage).to.be.equal(expectedPayload);
     });
     it('should encrypt and decrypt message using NIS1 schema', () => {
         const encryptedMessage = sender_nis.encryptMessage('Testing simple transfer', recipient_nis.publicAccount, SignSchema.KECCAK_REVERSED_KEY);
         const payload = encryptedMessage.payload;
         const plainMessage = recipient_nis.decryptMessage(new EncryptedMessage(payload), sender_nis.publicAccount, SignSchema.KECCAK_REVERSED_KEY);
-        expect(plainMessage.payload).to.be.equal('Testing simple transfer');
+        expect(plainMessage.message).to.be.equal('Testing simple transfer');
     });
 
 });
diff --git a/test/model/transaction/PlainMessage.spec.ts b/test/model/transaction/PlainMessage.spec.ts
@@ -26,13 +26,13 @@ describe('PlainMessage', () => {
     it('should createComplete message from payload with constructor', () => {
         const payload = 'test-message';
         const message = new PlainMessage(payload);
-        expect(message.payload).to.be.equal(payload);
+        expect(message.message).to.be.equal(payload);
     });
 
     it('should createComplete message from payload with static method', () => {
         const payload = '746573742D6D657373616765';
         const message = PlainMessage.createFromPayload(payload);
-        expect(message.payload).to.be.equal('test-message');
+        expect(message.message).to.be.equal('test-message');
     });
 
     it('should decode hex message', ()  => {

diff --git a/test/model/transaction/TransferTransaction.spec.ts b/test/model/transaction/TransferTransaction.spec.ts
@@ -69,7 +69,7 @@ describe('TransferTransaction', () => {
             NetworkType.MIJIN_TEST,
         );
 
-        expect(transferTransaction.message.payload).to.be.equal('test-message');
+        expect(transferTransaction.message.message).to.be.equal('test-message');
         expect(transferTransaction.mosaics.length).to.be.equal(0);
         expect(transferTransaction.recipient).to.be.instanceof(Address);
         expect((transferTransaction.recipient as Address).plain()).to.be.equal('SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC');
@@ -93,7 +93,7 @@ describe('TransferTransaction', () => {
             NetworkType.MIJIN_TEST,
         );
 
-        expect(transferTransaction.message.payload).to.be.equal('test-message');
+        expect(transferTransaction.message.message).to.be.equal('test-message');
         expect(transferTransaction.mosaics.length).to.be.equal(1);
         expect(transferTransaction.recipient).to.be.instanceof(Address);
         expect((transferTransaction.recipient as Address).plain()).to.be.equal('SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC');
@@ -120,7 +120,7 @@ describe('TransferTransaction', () => {
             NetworkType.MIJIN_TEST,
         );
 
-        expect(transferTransaction.message.payload).to.be.equal('test-message');
+        expect(transferTransaction.message.message).to.be.equal('test-message');
         expect(transferTransaction.mosaics.length).to.be.equal(1);
         expect(transferTransaction.recipient).to.be.instanceof(NamespaceId);
         expect(transferTransaction.recipient).to.be.equal(addressAlias);
-Original file line number
+Diff line change
@@ Expand Up / @@ -29,9 +29,6 @@ export class EncryptedMessage extends Message { @@
             super(MessageType.EncryptedMessage, payload);
         }
-        public size(): number {
-            return (this.payload || '').length / 2;
-        }
         /**
          *
@@ Expand Down @@