issue #89: use auxiliary class for recipient extraction

Author: Greg S

src/infrastructure/transaction/CreateTransactionFromDTO.ts

@@ -16,7 +16,6 @@
 
 import {Address} from '../../model/account/Address';
 import {PublicAccount} from '../../model/account/PublicAccount';
-import {Recipient} from '../../model/account/Recipient';
 import {NetworkType} from '../../model/blockchain/NetworkType';
 import {Mosaic} from '../../model/mosaic/Mosaic';
 import {MosaicId} from '../../model/mosaic/MosaicId';
@@ -117,13 +116,12 @@ export const CreateTransactionFromDTO = (transactionDTO): Transaction => {
  */
 const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Transaction => {
     if (transactionDTO.type === TransactionType.TRANSFER) {
-        const recipient = Recipient.createFromEncoded(transactionDTO.recipient);
         return new TransferTransaction(
             extractNetworkType(transactionDTO.version),
             extractTransactionVersion(transactionDTO.version),
             Deadline.createFromDTO(transactionDTO.deadline),
             new UInt64(transactionDTO.fee || [0, 0]),
-            recipient.value,
+            extractRecipient(transactionDTO.recipient),
             transactionDTO.mosaics === undefined ? [] :
                 transactionDTO.mosaics
                     .map((mosaicDTO) => new Mosaic(new MosaicId(mosaicDTO.id), new UInt64(mosaicDTO.amount))),
@@ -341,3 +339,19 @@ const extractNetworkType = (version: number): NetworkType => {
 const extractTransactionVersion = (version: number): number => {
     return parseInt(version.toString(16).substr(2, 2), 16);
 };
+
+const extractRecipient = (recipient: string): Address | NamespaceId => {
+        // If bit 0 of byte 0 is not set (like in 0x90), then it is a regular address.
+        // Else (e.g. 0x91) it represents a namespace id which starts at byte 1.
+        const fstByteBit0 = recipient.substr(1, 1);
+
+        if (parseInt(fstByteBit0, 2) === 1) {
+            // namespaceId encoded hexadecimal notation provided
+            // only 8 bytes are relevant to resolve the NamespaceId
+            const relevantPart = recipient.substr(2, 16);
+            return NamespaceId.createFromEncoded(relevantPart);
+        }
+
+        // read address from encoded hexadecimal notation
+        return Address.createFromEncoded(recipient);
+};

src/model/account/Recipient.ts

@@ -17,7 +17,6 @@
 import { TransferTransaction as TransferTransactionLibrary, VerifiableTransaction } from 'nem2-library';
 import { Address } from '../account/Address';
 import { PublicAccount } from '../account/PublicAccount';
-import { Recipient } from '../account/Recipient';
 import { NetworkType } from '../blockchain/NetworkType';
 import { Mosaic } from '../mosaic/Mosaic';
 import { NamespaceId } from '../namespace/NamespaceId';
@@ -43,7 +42,7 @@ export class TransferTransaction extends Transaction {
      * @returns {TransferTransaction}
      */
     public static create(deadline: Deadline,
-                         recipient: Recipient | Address | NamespaceId,
+                         recipient: Address | NamespaceId,
                          mosaics: Mosaic[],
                          message: Message,
                          networkType: NetworkType): TransferTransaction {
@@ -75,7 +74,7 @@ export class TransferTransaction extends Transaction {
                 /**
                  * The address of the recipient.
                  */
-                public readonly recipient: Recipient | Address | NamespaceId,
+                public readonly recipient: Address | NamespaceId,
                 /**
                  * The array of Mosaic objects.
                  */
@@ -97,19 +96,13 @@ export class TransferTransaction extends Transaction {
      */
     public recipientToString(): string {
 
-        // handle `Recipient` wrapper class
-        let recipient = this.recipient;
-        if (recipient instanceof Recipient) {
-            recipient = (this.recipient as Recipient).value;
-        }
-
-        if (recipient instanceof NamespaceId) {
+        if (this.recipient instanceof NamespaceId) {
             // namespaceId recipient, return hexadecimal notation
-            return (recipient as NamespaceId).toHex();
+            return (this.recipient as NamespaceId).toHex();
         }
 
         // address recipient
-        return (recipient as Address).plain();
+        return (this.recipient as Address).plain();
     }
 
     /**

src/model/transaction/TransferTransaction.ts

@@ -17,7 +17,6 @@
 import { expect } from 'chai';
 import { Account } from '../../../src/model/account/Account';
 import { Address } from '../../../src/model/account/Address';
-import { Recipient } from '../../../src/model/account/Recipient';
 import { NetworkType } from '../../../src/model/blockchain/NetworkType';
 import { NetworkCurrencyMosaic } from '../../../src/model/mosaic/NetworkCurrencyMosaic';
 import { NamespaceId } from '../../../src/model/namespace/NamespaceId';
@@ -108,63 +107,6 @@ describe('TransferTransaction', () => {
             '44B262C46CEABB8500E1F50500000000');
     });
 
-    it('should createComplete an TransferTransaction object with Recipient given address recipient', () => {
-        const addressRecipient = new Recipient(Address.createFromRawAddress('SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC'));
-        const transferTransaction = TransferTransaction.create(
-            Deadline.create(),
-            addressRecipient,
-            [
-                NetworkCurrencyMosaic.createRelative(100),
-            ],
-            PlainMessage.create('test-message'),
-            NetworkType.MIJIN_TEST,
-        );
-
-        expect(transferTransaction.message.payload).to.be.equal('test-message');
-        expect(transferTransaction.mosaics.length).to.be.equal(1);
-        expect(transferTransaction.recipient).to.be.instanceof(Recipient);
-
-        const address = ((transferTransaction.recipient as Recipient).value as Address);
-        expect(address.plain()).to.be.equal('SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC');
-
-        const signedTransaction = transferTransaction.signWith(account);
-
-        expect(signedTransaction.payload.substring(
-            240,
-            signedTransaction.payload.length,
-        )).to.be.equal('9050B9837EFAB4BBE8A4B9BB32D812F9885C00D8FC1650E1420D000100746573742D6D657373616765' +
-            '44B262C46CEABB8500E1F50500000000');
-    });
-
-    it('should createComplete an TransferTransaction object with Recipient given namespaceId recipient', () => {
-        const namespaceId = new NamespaceId('nem.owner');
-        const namespaceRecipient = new Recipient(namespaceId);
-        const transferTransaction = TransferTransaction.create(
-            Deadline.create(),
-            namespaceRecipient,
-            [
-                NetworkCurrencyMosaic.createRelative(100),
-            ],
-            PlainMessage.create('test-message'),
-            NetworkType.MIJIN_TEST,
-        );
-
-        expect(transferTransaction.message.payload).to.be.equal('test-message');
-        expect(transferTransaction.mosaics.length).to.be.equal(1);
-        expect(transferTransaction.recipient).to.be.instanceof(Recipient);
-
-        const actualNamespaceId = ((transferTransaction.recipient as Recipient).value as NamespaceId);
-        expect(actualNamespaceId.toHex()).to.be.equal(namespaceId.toHex());
-
-        const signedTransaction = transferTransaction.signWith(account);
-
-        expect(signedTransaction.payload.substring(
-            240,
-            signedTransaction.payload.length,
-        )).to.be.equal('9151776168D24257D8000000000000000000000000000000000D000100746573742D6D657373616765' +
-            '44B262C46CEABB8500E1F50500000000');
-    });
-
     it('should format TransferTransaction payload with 25 bytes binary address', () => {
         const transferTransaction = TransferTransaction.create(
             Deadline.create(),