Merge pull request #91 from evias/task/G89/alias-in-transaction

Fix issue #89: Read recipient from encoded hexadecimal notation

Author: Grégory Saive

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "nem2-sdk",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Reactive Nem2 sdk for typescript and javascript",
   "scripts": {
     "pretest": "npm run build",

package.json

@@ -13,10 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
+import {convert} from 'nem2-library';
+import {uint64 as UInt64Library} from 'nem2-library';
 import {Address} from '../../model/account/Address';
 import {PublicAccount} from '../../model/account/PublicAccount';
 import {NetworkType} from '../../model/blockchain/NetworkType';
+import {Id} from '../../model/Id';
 import {Mosaic} from '../../model/mosaic/Mosaic';
 import {MosaicId} from '../../model/mosaic/MosaicId';
 import {MosaicProperties} from '../../model/mosaic/MosaicProperties';
@@ -121,10 +123,8 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             extractTransactionVersion(transactionDTO.version),
             Deadline.createFromDTO(transactionDTO.deadline),
             new UInt64(transactionDTO.fee || [0, 0]),
-            Address.createFromEncoded(transactionDTO.recipient),
-            transactionDTO.mosaics === undefined ? [] :
-                transactionDTO.mosaics
-                    .map((mosaicDTO) => new Mosaic(new MosaicId(mosaicDTO.id), new UInt64(mosaicDTO.amount))),
+            extractRecipient(transactionDTO.recipient),
+            extractMosaics(transactionDTO.mosaics),
             transactionDTO.message !== undefined ?
                 PlainMessage.createFromDTO(transactionDTO.message.payload) : EmptyMessage,
             transactionDTO.signature,
@@ -339,3 +339,60 @@ const extractNetworkType = (version: number): NetworkType => {
 const extractTransactionVersion = (version: number): number => {
     return parseInt(version.toString(16).substr(2, 2), 16);
 };
+
+/**
+ * Extract recipient value from encoded hexadecimal notation.
+ *
+ * If bit 0 of byte 0 is not set (e.g. 0x90), then it is a regular address.
+ * Else (e.g. 0x91) it represents a namespace id which starts at byte 1.
+ *
+ * @param recipient {string} Encoded hexadecimal recipient notation
+ * @return {Address | NamespaceId}
+ */
+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 bit0 = convert.hexToUint8(recipient.substr(1, 2))[0];
+
+    if ((bit0 & 16) === 16) {
+        // 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);
+};
+
+/**
+ * Extract mosaics from encoded UInt64 notation.
+ *
+ * If most significant bit of byte 0 is set, then it is a namespaceId.
+ * If most significant bit of byte 0 is not set, then it is a mosaicId.
+ *
+ * @param mosaics {Array | undefined} The DTO array of mosaics (with UInt64 Id notation)
+ * @return {Mosaic[]}
+ */
+const extractMosaics = (mosaics: any): Mosaic[] => {
+
+    if (mosaics === undefined) {
+        return [];
+    }
+
+    return mosaics.map((mosaicDTO) => {
+
+        // convert ID to UInt8 bytes array and get first byte (most significant byte)
+        const uint64 = new Id(mosaicDTO.id);
+        const bytes = convert.hexToUint8(UInt64Library.toHex(uint64.toDTO()));
+        const byte0 = bytes[0];
+
+        // if most significant bit of byte 0 is set, then we have a namespaceId
+        if ((byte0 & 128) === 128) {
+            return new Mosaic(new NamespaceId(mosaicDTO.id), new UInt64(mosaicDTO.amount));
+        }
+
+        // most significant bit of byte 0 is not set => mosaicId
+        return new Mosaic(new MosaicId(mosaicDTO.id), new UInt64(mosaicDTO.amount));
+    });
+};

src/infrastructure/transaction/CreateTransactionFromDTO.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {namespaceId as NamespaceIdGenerator} from 'nem2-library';
+import {convert, namespaceId as NamespaceIdGenerator} from 'nem2-library';
 import {Id} from '../Id';
 
 /**
@@ -48,6 +48,18 @@ export class NamespaceId {
         }
     }
 
+    /**
+     * Create a NamespaceId object from its encoded hexadecimal notation.
+     * @param encoded
+     * @returns {NamespaceId}
+     */
+    public static createFromEncoded(encoded: string): NamespaceId {
+        const uint = convert.hexToUint8(encoded).reverse();
+        const hex  = convert.uint8ToHex(uint);
+        const namespace = new NamespaceId(Id.fromHex(hex).toDTO());
+        return namespace;
+    }
+
     /**
      * Get string value of id
      * @returns {string}

src/model/namespace/NamespaceId.ts

@@ -95,12 +95,13 @@ export class TransferTransaction extends Transaction {
      * @returns {string}
      */
     public recipientToString(): string {
+
         if (this.recipient instanceof NamespaceId) {
-            // namespaceId available, return hexadecimal notation
+            // namespaceId recipient, return hexadecimal notation
             return (this.recipient as NamespaceId).toHex();
         }
 
-        // address available
+        // address recipient
         return (this.recipient as Address).plain();
     }
 

src/model/transaction/TransferTransaction.ts

@@ -37,4 +37,21 @@ describe('NamespaceId', () => {
         deepEqual(id.id, new Id([3646934825, 3576016193]));
         expect(id.fullName).to.be.equal(undefined);
     });
+
+    const vectors = [
+        {encoded: '4bfa5f372d55b384', uint: [929036875, 2226345261]},  // new NamespaceId('nem')
+        {encoded: '08a12f89ee5a49f8', uint: [2301600008, 4165556974]}, // new NamespaceId('nem.owner.test1')
+        {encoded: '1f810565e8f4aeab', uint: [1694859551, 2880369896]}, // new NamespaceId('nem.owner.test2')
+        {encoded: '552d1c0a2bc9b8ae', uint: [169618773, 2931345707]},  // new NamespaceId('nem.owner.test3')
+        {encoded: 'bfca1440d49ae090', uint: [1075104447, 2430638804]}, // new NamespaceId('nem.owner.test4')
+        {encoded: 'ccf10b96814211ab', uint: [2517365196, 2870035073]}, // new NamespaceId('nem.owner.test5')
+    ];
+
+    it('should be created from encoded vectors', () => {
+        vectors.map(({encoded, uint}) => {
+            const fromHex = NamespaceId.createFromEncoded(encoded.toUpperCase());
+            const fromId = new NamespaceId(uint);
+            deepEqual(fromId.id, fromHex.id);
+        });
+    });
 });